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

Include dependency graph for dirwr.c:

Macros
#define	NDEBUG

Functions
NTSTATUS	vfatFCBInitializeCacheFromVolume (PVCB vcb, PVFATFCB fcb)

NTSTATUS	VfatUpdateEntry (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB pFcb)

NTSTATUS	vfatRenameEntry (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB pFcb, IN PUNICODE_STRING FileName, IN BOOLEAN CaseChangeOnly)

BOOLEAN	vfatFindDirSpace (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB pDirFcb, IN ULONG nbSlots, OUT PULONG start)

static NTSTATUS	FATAddEntry (IN PDEVICE_EXTENSION DeviceExt, IN PUNICODE_STRING NameU, IN PVFATFCB *Fcb, IN PVFATFCB ParentFcb, IN ULONG RequestedOptions, IN UCHAR ReqAttr, IN PVFAT_MOVE_CONTEXT MoveContext)

static NTSTATUS	FATXAddEntry (IN PDEVICE_EXTENSION DeviceExt, IN PUNICODE_STRING NameU, IN PVFATFCB *Fcb, IN PVFATFCB ParentFcb, IN ULONG RequestedOptions, IN UCHAR ReqAttr, IN PVFAT_MOVE_CONTEXT MoveContext)

static NTSTATUS	FATDelEntry (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB pFcb, OUT PVFAT_MOVE_CONTEXT MoveContext)

static NTSTATUS	FATXDelEntry (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB pFcb, OUT PVFAT_MOVE_CONTEXT MoveContext)

NTSTATUS	VfatMoveEntry (IN PDEVICE_EXTENSION DeviceExt, IN PVFATFCB pFcb, IN PUNICODE_STRING FileName, IN PVFATFCB ParentFcb)

BOOLEAN	FATXIsDirectoryEmpty (PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb)

BOOLEAN	FATIsDirectoryEmpty (PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb)

NTSTATUS	FATGetNextDirEntry (PVOID pContext, PVOID pPage, PVFATFCB pDirFcb, PVFAT_DIRENTRY_CONTEXT DirContext, BOOLEAN First)

NTSTATUS	FATXGetNextDirEntry (PVOID pContext, PVOID pPage, PVFATFCB pDirFcb, PVFAT_DIRENTRY_CONTEXT DirContext, BOOLEAN First)

Variables
VFAT_DISPATCH	FatXDispatch

VFAT_DISPATCH	FatDispatch

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 16 of file dirwr.c.

Function Documentation

◆ FATAddEntry()

static NTSTATUS FATAddEntry	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN PUNICODE_STRING	NameU,
		IN PVFATFCB *	Fcb,
		IN PVFATFCB	ParentFcb,
		IN ULONG	RequestedOptions,
		IN UCHAR	ReqAttr,
		IN PVFAT_MOVE_CONTEXT	MoveContext
	)

static

Definition at line 405 of file dirwr.c.

 {
     PVOID Context = NULL;
     PFAT_DIR_ENTRY pFatEntry;
     slot *pSlots;
     USHORT nbSlots = 0, j;
     PUCHAR Buffer;
     BOOLEAN needTilde = FALSE, needLong = FALSE;
     BOOLEAN BaseAllLower, BaseAllUpper;
     BOOLEAN ExtensionAllLower, ExtensionAllUpper;
     BOOLEAN InExtension;
     BOOLEAN IsDirectory;
     WCHAR c;
     ULONG CurrentCluster;
     LARGE_INTEGER SystemTime, FileOffset;
     NTSTATUS Status = STATUS_SUCCESS;
     ULONG size;
     long i;
 
     OEM_STRING NameA;
     CHAR aName[13];
     BOOLEAN IsNameLegal;
     BOOLEAN SpacesFound;
 
     VFAT_DIRENTRY_CONTEXT DirContext;
     WCHAR LongNameBuffer[LONGNAME_MAX_LENGTH + 1];
     WCHAR ShortNameBuffer[13];
 
     DPRINT("addEntry: Name='%wZ', Dir='%wZ'\n", NameU, &ParentFcb->PathNameU);
 
     DirContext.LongNameU = *NameU;
     IsDirectory = BooleanFlagOn(RequestedOptions, FILE_DIRECTORY_FILE);
 
     /* nb of entry needed for long name+normal entry */
     nbSlots = (DirContext.LongNameU.Length / sizeof(WCHAR) + 12) / 13 + 1;
     DPRINT("NameLen= %u, nbSlots =%u\n", DirContext.LongNameU.Length / sizeof(WCHAR), nbSlots);
     Buffer = ExAllocatePoolWithTag(NonPagedPool, (nbSlots - 1) * sizeof(FAT_DIR_ENTRY), TAG_DIRENT);
     if (Buffer == NULL)
     {
         return STATUS_INSUFFICIENT_RESOURCES;
     }
     RtlZeroMemory(Buffer, (nbSlots - 1) * sizeof(FAT_DIR_ENTRY));
     pSlots = (slot *) Buffer;
 
     NameA.Buffer = aName;
     NameA.Length = 0;
     NameA.MaximumLength = sizeof(aName);
 
     DirContext.DeviceExt = DeviceExt;
     DirContext.ShortNameU.Buffer = ShortNameBuffer;
     DirContext.ShortNameU.Length = 0;
     DirContext.ShortNameU.MaximumLength = sizeof(ShortNameBuffer);
 
     RtlZeroMemory(&DirContext.DirEntry.Fat, sizeof(FAT_DIR_ENTRY));
 
     IsNameLegal = RtlIsNameLegalDOS8Dot3(&DirContext.LongNameU, &NameA, &SpacesFound);
 
     if (!IsNameLegal || SpacesFound)
     {
         GENERATE_NAME_CONTEXT NameContext;
         VFAT_DIRENTRY_CONTEXT SearchContext;
         WCHAR ShortSearchName[13];
         needTilde = TRUE;
         needLong = TRUE;
         RtlZeroMemory(&NameContext, sizeof(GENERATE_NAME_CONTEXT));
         SearchContext.DeviceExt = DeviceExt;
         SearchContext.LongNameU.Buffer = LongNameBuffer;
         SearchContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
         SearchContext.ShortNameU.Buffer = ShortSearchName;
         SearchContext.ShortNameU.MaximumLength = sizeof(ShortSearchName);
 
         for (i = 0; i < 100; i++)
         {
             RtlGenerate8dot3Name(&DirContext.LongNameU, FALSE, &NameContext, &DirContext.ShortNameU);
             DirContext.ShortNameU.Buffer[DirContext.ShortNameU.Length / sizeof(WCHAR)] = 0;
                                          SearchContext.DirIndex = 0;
             Status = FindFile(DeviceExt, ParentFcb, &DirContext.ShortNameU, &SearchContext, TRUE);
             if (!NT_SUCCESS(Status))
             {
                 break;
             }
             else if (MoveContext)
             {
                 ASSERT(*Fcb);
                 if (strncmp((char *)SearchContext.DirEntry.Fat.ShortName, (char *)(*Fcb)->entry.Fat.ShortName, 11) == 0)
                 {
                     if (MoveContext->InPlace)
                     {
                         ASSERT(SearchContext.DirEntry.Fat.FileSize == MoveContext->FileSize);
                         break;
                     }
                 } 
             }
         }
         if (i == 100) /* FIXME : what to do after this ? */
         {
             ExFreePoolWithTag(Buffer, TAG_DIRENT);
             return STATUS_UNSUCCESSFUL;
         }
         IsNameLegal = RtlIsNameLegalDOS8Dot3(&DirContext.ShortNameU, &NameA, &SpacesFound);
     }
     else
     {
         BaseAllLower = BaseAllUpper = TRUE;
         ExtensionAllLower = ExtensionAllUpper = TRUE;
         InExtension = FALSE;
         for (i = 0; i < DirContext.LongNameU.Length / sizeof(WCHAR); i++)
         {
             c = DirContext.LongNameU.Buffer[i];
             if (c >= L'A' && c <= L'Z')
             {
                 if (InExtension)
                     ExtensionAllLower = FALSE;
                 else
                     BaseAllLower = FALSE;
             }
             else if (c >= L'a' && c <= L'z')
             {
                 if (InExtension)
                     ExtensionAllUpper = FALSE;
                 else
                     BaseAllUpper = FALSE;
             }
             else if (c > 0x7f)
             {
                 needLong = TRUE;
                 break;
             }
             
             if (c == L'.')
             {
                 InExtension = TRUE;
             }
         }
 
         if ((!BaseAllLower && !BaseAllUpper) ||
             (!ExtensionAllLower && !ExtensionAllUpper))
         {
             needLong = TRUE;
         }
 
         RtlUpcaseUnicodeString(&DirContext.ShortNameU, &DirContext.LongNameU, FALSE);
         DirContext.ShortNameU.Buffer[DirContext.ShortNameU.Length / sizeof(WCHAR)] = 0;
     }
     aName[NameA.Length] = 0;
     DPRINT("'%s', '%wZ', needTilde=%u, needLong=%u\n",
            aName, &DirContext.LongNameU, needTilde, needLong);
     memset(DirContext.DirEntry.Fat.ShortName, ' ', 11);
     for (i = 0; i < 8 && aName[i] && aName[i] != '.'; i++)
     {
         DirContext.DirEntry.Fat.Filename[i] = aName[i];
     }
     if (aName[i] == '.')
     {
         i++;
         for (j = 0; j < 3 && aName[i]; j++, i++)
         {
             DirContext.DirEntry.Fat.Ext[j] = aName[i];
         }
     }
     if (DirContext.DirEntry.Fat.Filename[0] == 0xe5)
     {
         DirContext.DirEntry.Fat.Filename[0] = 0x05;
     }
 
     if (needLong)
     {
         RtlCopyMemory(LongNameBuffer, DirContext.LongNameU.Buffer, DirContext.LongNameU.Length);
         DirContext.LongNameU.Buffer = LongNameBuffer;
         DirContext.LongNameU.MaximumLength = sizeof(LongNameBuffer);
         DirContext.LongNameU.Buffer[DirContext.LongNameU.Length / sizeof(WCHAR)] = 0;
         memset(DirContext.LongNameU.Buffer + DirContext.LongNameU.Length / sizeof(WCHAR) + 1, 0xff,
                DirContext.LongNameU.MaximumLength - DirContext.LongNameU.Length - sizeof(WCHAR));
     }
     else
     {
         nbSlots = 1;
         if (BaseAllLower && !BaseAllUpper)
         {
             DirContext.DirEntry.Fat.lCase |= VFAT_CASE_LOWER_BASE;
         }
         if (ExtensionAllLower && !ExtensionAllUpper)
         {
             DirContext.DirEntry.Fat.lCase |= VFAT_CASE_LOWER_EXT;
         }
     }
 
     DPRINT ("dos name=%11.11s\n", DirContext.DirEntry.Fat.Filename);
 
     /* set attributes */
     DirContext.DirEntry.Fat.Attrib = ReqAttr;
     if (IsDirectory)
     {
         DirContext.DirEntry.Fat.Attrib |= FILE_ATTRIBUTE_DIRECTORY;
     }
     /* set dates and times */
     KeQuerySystemTime(&SystemTime);
     FsdSystemTimeToDosDateTime(DeviceExt, &SystemTime, &DirContext.DirEntry.Fat.CreationDate,
                                &DirContext.DirEntry.Fat.CreationTime);
     DirContext.DirEntry.Fat.UpdateDate = DirContext.DirEntry.Fat.CreationDate;
     DirContext.DirEntry.Fat.UpdateTime = DirContext.DirEntry.Fat.CreationTime;
     DirContext.DirEntry.Fat.AccessDate = DirContext.DirEntry.Fat.CreationDate;
     /* If it's moving, preserve creation time and file size */
     if (MoveContext != NULL)
     {
         DirContext.DirEntry.Fat.CreationDate = MoveContext->CreationDate;
         DirContext.DirEntry.Fat.CreationTime = MoveContext->CreationTime;
         DirContext.DirEntry.Fat.FileSize = MoveContext->FileSize;
     }
 
     if (needLong)
     {
         /* calculate checksum for 8.3 name */
         for (pSlots[0].alias_checksum = 0, i = 0; i < 11; i++)
         {
             pSlots[0].alias_checksum = (((pSlots[0].alias_checksum & 1) << 7
                                      | ((pSlots[0].alias_checksum & 0xfe) >> 1))
                                      + DirContext.DirEntry.Fat.ShortName[i]);
         }
         /* construct slots and entry */
         for (i = nbSlots - 2; i >= 0; i--)
         {
             DPRINT("construct slot %d\n", i);
             pSlots[i].attr = 0xf;
             if (i)
             {
                 pSlots[i].id = (unsigned char)(nbSlots - i - 1);
             }
             else
             {
                 pSlots[i].id = (unsigned char)(nbSlots - i - 1 + 0x40);
             }
             pSlots[i].alias_checksum = pSlots[0].alias_checksum;
             RtlCopyMemory(pSlots[i].name0_4, DirContext.LongNameU.Buffer + (nbSlots - i - 2) * 13, 10);
             RtlCopyMemory(pSlots[i].name5_10, DirContext.LongNameU.Buffer + (nbSlots - i - 2) * 13 + 5, 12);
             RtlCopyMemory(pSlots[i].name11_12, DirContext.LongNameU.Buffer + (nbSlots - i - 2) * 13 + 11, 4);
         }
     }
     /* try to find nbSlots contiguous entries frees in directory */
     if (!vfatFindDirSpace(DeviceExt, ParentFcb, nbSlots, &DirContext.StartIndex))
     {
         ExFreePoolWithTag(Buffer, TAG_DIRENT);
         return STATUS_DISK_FULL;
     }
     DirContext.DirIndex = DirContext.StartIndex + nbSlots - 1;
     if (IsDirectory)
     {
         /* If we aren't moving, use next */
         if (MoveContext == NULL)
         {
             CurrentCluster = 0;
             Status = NextCluster(DeviceExt, 0, &CurrentCluster, TRUE);
             if (CurrentCluster == 0xffffffff || !NT_SUCCESS(Status))
             {
                 ExFreePoolWithTag(Buffer, TAG_DIRENT);
                 if (!NT_SUCCESS(Status))
                 {
                     return Status;
                 }
                 return STATUS_DISK_FULL;
             }
 
             if (DeviceExt->FatInfo.FatType == FAT32)
             {
                 FAT32UpdateFreeClustersCount(DeviceExt);
             }
         }
         else
         {
             CurrentCluster = MoveContext->FirstCluster;
         }
 
         if (DeviceExt->FatInfo.FatType == FAT32)
         {
             DirContext.DirEntry.Fat.FirstClusterHigh = (unsigned short)(CurrentCluster >> 16);
         }
         DirContext.DirEntry.Fat.FirstCluster = (unsigned short)CurrentCluster;
     }
     else if (MoveContext != NULL)
     {
         CurrentCluster = MoveContext->FirstCluster;
 
         if (DeviceExt->FatInfo.FatType == FAT32)
         {
             DirContext.DirEntry.Fat.FirstClusterHigh = (unsigned short)(CurrentCluster >> 16);
         }
         DirContext.DirEntry.Fat.FirstCluster = (unsigned short)CurrentCluster;
     }
 
     /* No need to init cache here, vfatFindDirSpace() will have done it for us */
     ASSERT(BooleanFlagOn(ParentFcb->Flags, FCB_CACHE_INITIALIZED));
 
     i = DeviceExt->FatInfo.BytesPerCluster / sizeof(FAT_DIR_ENTRY);
     FileOffset.u.HighPart = 0;
     FileOffset.u.LowPart = DirContext.StartIndex * sizeof(FAT_DIR_ENTRY);
     if (DirContext.StartIndex / i == DirContext.DirIndex / i)
     {
         /* one cluster */
         _SEH2_TRY
         {
             CcPinRead(ParentFcb->FileObject, &FileOffset, nbSlots * sizeof(FAT_DIR_ENTRY), PIN_WAIT, &Context, (PVOID*)&pFatEntry);
         }
         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
         {
             ExFreePoolWithTag(Buffer, TAG_DIRENT);
             _SEH2_YIELD(return _SEH2_GetExceptionCode());
         }
         _SEH2_END;
 
         if (nbSlots > 1)
         {
             RtlCopyMemory(pFatEntry, Buffer, (nbSlots - 1) * sizeof(FAT_DIR_ENTRY));
         }
         RtlCopyMemory(pFatEntry + (nbSlots - 1), &DirContext.DirEntry.Fat, sizeof(FAT_DIR_ENTRY));
     }
     else
     {
         /* two clusters */
         size = DeviceExt->FatInfo.BytesPerCluster -
                (DirContext.StartIndex * sizeof(FAT_DIR_ENTRY)) % DeviceExt->FatInfo.BytesPerCluster;
         i = size / sizeof(FAT_DIR_ENTRY);
         _SEH2_TRY
         {
             CcPinRead(ParentFcb->FileObject, &FileOffset, size, PIN_WAIT, &Context, (PVOID*)&pFatEntry);
         }
         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
         {
             ExFreePoolWithTag(Buffer, TAG_DIRENT);
             _SEH2_YIELD(return _SEH2_GetExceptionCode());
         }
         _SEH2_END;
         RtlCopyMemory(pFatEntry, Buffer, size);
         CcSetDirtyPinnedData(Context, NULL);
         CcUnpinData(Context);
         FileOffset.u.LowPart += size;
         _SEH2_TRY
         {
             CcPinRead(ParentFcb->FileObject, &FileOffset, nbSlots * sizeof(FAT_DIR_ENTRY) - size, PIN_WAIT, &Context, (PVOID*)&pFatEntry);
         }
         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
         {
             ExFreePoolWithTag(Buffer, TAG_DIRENT);
             _SEH2_YIELD(return _SEH2_GetExceptionCode());
         }
         _SEH2_END;
         if (nbSlots - 1 > i)
         {
             RtlCopyMemory(pFatEntry, (PVOID)(Buffer + size), (nbSlots - 1 - i) * sizeof(FAT_DIR_ENTRY));
         }
         RtlCopyMemory(pFatEntry + nbSlots - 1 - i, &DirContext.DirEntry.Fat, sizeof(FAT_DIR_ENTRY));
     }
     CcSetDirtyPinnedData(Context, NULL);
     CcUnpinData(Context);
 
     if (MoveContext != NULL)
     {
         /* We're modifying an existing FCB - likely rename/move */
         Status = vfatUpdateFCB(DeviceExt, *Fcb, &DirContext, ParentFcb);
     }
     else
     {
         Status = vfatMakeFCBFromDirEntry(DeviceExt, ParentFcb, &DirContext, Fcb);
     }
     if (!NT_SUCCESS(Status))
     {
         ExFreePoolWithTag(Buffer, TAG_DIRENT);
         return Status;
     }
 
     DPRINT("new : entry=%11.11s\n", (*Fcb)->entry.Fat.Filename);
     DPRINT("new : entry=%11.11s\n", DirContext.DirEntry.Fat.Filename);
 
     if (IsDirectory)
     {
         Status = vfatFCBInitializeCacheFromVolume(DeviceExt, (*Fcb));
         if (!NT_SUCCESS(Status))
         {
             ExFreePoolWithTag(Buffer, TAG_DIRENT);
             return Status;
         }
 
         FileOffset.QuadPart = 0;
         _SEH2_TRY
         {
             CcPinRead((*Fcb)->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster, PIN_WAIT, &Context, (PVOID*)&pFatEntry);
         }
         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
         {
             ExFreePoolWithTag(Buffer, TAG_DIRENT);
             _SEH2_YIELD(return _SEH2_GetExceptionCode());
         }
         _SEH2_END;
         /* clear the new directory cluster if not moving */
         if (MoveContext == NULL)
         {
             RtlZeroMemory(pFatEntry, DeviceExt->FatInfo.BytesPerCluster);
             /* create '.' and '..' */
             pFatEntry[0] = DirContext.DirEntry.Fat;
             RtlCopyMemory(pFatEntry[0].ShortName, ".          ", 11);
             pFatEntry[1] = DirContext.DirEntry.Fat;
             RtlCopyMemory(pFatEntry[1].ShortName, "..         ", 11);
         }
 
         pFatEntry[1].FirstCluster = ParentFcb->entry.Fat.FirstCluster;
         pFatEntry[1].FirstClusterHigh = ParentFcb->entry.Fat.FirstClusterHigh;
         if (vfatFCBIsRoot(ParentFcb))
         {
             pFatEntry[1].FirstCluster = 0;
             pFatEntry[1].FirstClusterHigh = 0;
         }
         CcSetDirtyPinnedData(Context, NULL);
         CcUnpinData(Context);
     }
     ExFreePoolWithTag(Buffer, TAG_DIRENT);
     DPRINT("addentry ok\n");
     return STATUS_SUCCESS;
 }

◆ FATDelEntry()

static NTSTATUS FATDelEntry	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN PVFATFCB	pFcb,
		OUT PVFAT_MOVE_CONTEXT	MoveContext
	)

static

Definition at line 958 of file dirwr.c.

 {
     ULONG CurrentCluster = 0, NextCluster, i;
     PVOID Context = NULL;
     LARGE_INTEGER Offset;
     PFAT_DIR_ENTRY pDirEntry = NULL;
     NTSTATUS Status;
 
     ASSERT(pFcb);
     ASSERT(pFcb->parentFcb);
 
     Status = vfatFCBInitializeCacheFromVolume(DeviceExt, pFcb->parentFcb);
     if (!NT_SUCCESS(Status))
     {
         return Status;
     }
 
     DPRINT("delEntry PathName \'%wZ\'\n", &pFcb->PathNameU);
     DPRINT("delete entry: %u to %u\n", pFcb->startIndex, pFcb->dirIndex);
     Offset.u.HighPart = 0;
     for (i = pFcb->startIndex; i <= pFcb->dirIndex; i++)
     {
         if (Context == NULL || ((i * sizeof(FAT_DIR_ENTRY)) % PAGE_SIZE) == 0)
         {
             if (Context)
             {
                 CcSetDirtyPinnedData(Context, NULL);
                 CcUnpinData(Context);
             }
             Offset.u.LowPart = (i * sizeof(FAT_DIR_ENTRY) / PAGE_SIZE) * PAGE_SIZE;
             _SEH2_TRY
             {
                 CcPinRead(pFcb->parentFcb->FileObject, &Offset, PAGE_SIZE, PIN_WAIT, &Context, (PVOID*)&pDirEntry);
             }
             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
             {
                 _SEH2_YIELD(return _SEH2_GetExceptionCode());
             }
             _SEH2_END;
         }
         pDirEntry[i % (PAGE_SIZE / sizeof(FAT_DIR_ENTRY))].Filename[0] = 0xe5;
         if (i == pFcb->dirIndex)
         {
             CurrentCluster =
             vfatDirEntryGetFirstCluster(DeviceExt,
                                         (PDIR_ENTRY)&pDirEntry[i % (PAGE_SIZE / sizeof(FAT_DIR_ENTRY))]);
         }
     }
 
     /* In case of moving, save properties */
     if (MoveContext != NULL)
     {
         pDirEntry = &pDirEntry[pFcb->dirIndex % (PAGE_SIZE / sizeof(FAT_DIR_ENTRY))];
         MoveContext->FirstCluster = CurrentCluster;
         MoveContext->FileSize = pDirEntry->FileSize;
         MoveContext->CreationTime = pDirEntry->CreationTime;
         MoveContext->CreationDate = pDirEntry->CreationDate;
     }
 
     if (Context)
     {
         CcSetDirtyPinnedData(Context, NULL);
         CcUnpinData(Context);
     }
 
     /* In case of moving, don't delete data */
     if (MoveContext == NULL)
     {
         while (CurrentCluster && CurrentCluster != 0xffffffff)
         {
             GetNextCluster(DeviceExt, CurrentCluster, &NextCluster);
             /* FIXME: check status */
             WriteCluster(DeviceExt, CurrentCluster, 0);
             CurrentCluster = NextCluster;
         }
 
         if (DeviceExt->FatInfo.FatType == FAT32)
         {
             FAT32UpdateFreeClustersCount(DeviceExt);
         }
     }
 
     return STATUS_SUCCESS;
 }

◆ FATGetNextDirEntry()

NTSTATUS FATGetNextDirEntry	(	PVOID *	pContext,
		PVOID *	pPage,
		PVFATFCB	pDirFcb,
		PVFAT_DIRENTRY_CONTEXT	DirContext,
		BOOLEAN	First
	)

◆ FATIsDirectoryEmpty()

BOOLEAN FATIsDirectoryEmpty	(	PDEVICE_EXTENSION	DeviceExt,
		PVFATFCB	Fcb
	)

Definition at line 43 of file direntry.c.

 {
     LARGE_INTEGER FileOffset;
     PVOID Context = NULL;
     PFAT_DIR_ENTRY FatDirEntry;
     ULONG Index, MaxIndex;
     NTSTATUS Status;
 
     if (vfatFCBIsRoot(Fcb))
     {
         Index = 0;
     }
     else
     {
         Index = 2;
     }
 
     FileOffset.QuadPart = 0;
     MaxIndex = Fcb->RFCB.FileSize.u.LowPart / sizeof(FAT_DIR_ENTRY);
 
     Status = vfatFCBInitializeCacheFromVolume(DeviceExt, Fcb);
     if (!NT_SUCCESS(Status))
     {
         return FALSE;
     }
 
     while (Index < MaxIndex)
     {
         if (Context == NULL || (Index % FAT_ENTRIES_PER_PAGE) == 0)
         {
             if (Context != NULL)
             {
                 CcUnpinData(Context);
             }
 
             _SEH2_TRY
             {
                 CcMapData(Fcb->FileObject, &FileOffset, sizeof(FAT_DIR_ENTRY), MAP_WAIT, &Context, (PVOID*)&FatDirEntry);
             }
             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
             {
                 _SEH2_YIELD(return TRUE);
             }
             _SEH2_END;
 
             FatDirEntry += Index % FAT_ENTRIES_PER_PAGE;
             FileOffset.QuadPart += PAGE_SIZE;
         }
 
         if (FAT_ENTRY_END(FatDirEntry))
         {
             CcUnpinData(Context);
             return TRUE;
         }
 
         if (!FAT_ENTRY_DELETED(FatDirEntry))
         {
             CcUnpinData(Context);
             return FALSE;
         }
 
         Index++;
         FatDirEntry++;
     }
 
     if (Context)
     {
         CcUnpinData(Context);
     }
 
     return TRUE;
 }

◆ FATXAddEntry()

static NTSTATUS FATXAddEntry	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN PUNICODE_STRING	NameU,
		IN PVFATFCB *	Fcb,
		IN PVFATFCB	ParentFcb,
		IN ULONG	RequestedOptions,
		IN UCHAR	ReqAttr,
		IN PVFAT_MOVE_CONTEXT	MoveContext
	)

static

Definition at line 834 of file dirwr.c.

 {
     PVOID Context = NULL;
     LARGE_INTEGER SystemTime, FileOffset;
     OEM_STRING NameA;
     VFAT_DIRENTRY_CONTEXT DirContext;
     PFATX_DIR_ENTRY pFatXDirEntry;
     ULONG Index;
 
     DPRINT("addEntry: Name='%wZ', Dir='%wZ'\n", NameU, &ParentFcb->PathNameU);
 
     DirContext.LongNameU = *NameU;
 
     if (DirContext.LongNameU.Length / sizeof(WCHAR) > 42)
     {
         /* name too long */
         return STATUS_NAME_TOO_LONG;
     }
 
     /* try to find 1 entry free in directory */
     if (!vfatFindDirSpace(DeviceExt, ParentFcb, 1, &DirContext.StartIndex))
     {
         return STATUS_DISK_FULL;
     }
     Index = DirContext.DirIndex = DirContext.StartIndex;
     if (!vfatFCBIsRoot(ParentFcb))
     {
         DirContext.DirIndex += 2;
         DirContext.StartIndex += 2;
     }
 
     DirContext.ShortNameU.Buffer = 0;
     DirContext.ShortNameU.Length = 0;
     DirContext.ShortNameU.MaximumLength = 0;
     DirContext.DeviceExt = DeviceExt;
     RtlZeroMemory(&DirContext.DirEntry.FatX, sizeof(FATX_DIR_ENTRY));
     memset(DirContext.DirEntry.FatX.Filename, 0xff, 42);
     /* Use cluster, if moving */
     if (MoveContext != NULL)
     {
         DirContext.DirEntry.FatX.FirstCluster = MoveContext->FirstCluster;
     }
     else
     {
         DirContext.DirEntry.FatX.FirstCluster = 0;
     }
     DirContext.DirEntry.FatX.FileSize = 0;
 
     /* set file name */
     NameA.Buffer = (PCHAR)DirContext.DirEntry.FatX.Filename;
     NameA.Length = 0;
     NameA.MaximumLength = 42;
     RtlUnicodeStringToOemString(&NameA, &DirContext.LongNameU, FALSE);
     DirContext.DirEntry.FatX.FilenameLength = (unsigned char)NameA.Length;
 
     /* set attributes */
     DirContext.DirEntry.FatX.Attrib = ReqAttr;
     if (BooleanFlagOn(RequestedOptions, FILE_DIRECTORY_FILE))
     {
         DirContext.DirEntry.FatX.Attrib |= FILE_ATTRIBUTE_DIRECTORY;
     }
 
     /* set dates and times */
     KeQuerySystemTime(&SystemTime);
     FsdSystemTimeToDosDateTime(DeviceExt, &SystemTime, &DirContext.DirEntry.FatX.CreationDate,
                                &DirContext.DirEntry.FatX.CreationTime);
     DirContext.DirEntry.FatX.UpdateDate = DirContext.DirEntry.FatX.CreationDate;
     DirContext.DirEntry.FatX.UpdateTime = DirContext.DirEntry.FatX.CreationTime;
     DirContext.DirEntry.FatX.AccessDate = DirContext.DirEntry.FatX.CreationDate;
     DirContext.DirEntry.FatX.AccessTime = DirContext.DirEntry.FatX.CreationTime;
     /* If it's moving, preserve creation time and file size */
     if (MoveContext != NULL)
     {
         DirContext.DirEntry.FatX.CreationDate = MoveContext->CreationDate;
         DirContext.DirEntry.FatX.CreationTime = MoveContext->CreationTime;
         DirContext.DirEntry.FatX.FileSize = MoveContext->FileSize;
     }
 
     /* No need to init cache here, vfatFindDirSpace() will have done it for us */
     ASSERT(BooleanFlagOn(ParentFcb->Flags, FCB_CACHE_INITIALIZED));
 
     /* add entry into parent directory */
     FileOffset.u.HighPart = 0;
     FileOffset.u.LowPart = Index * sizeof(FATX_DIR_ENTRY);
     _SEH2_TRY
     {
         CcPinRead(ParentFcb->FileObject, &FileOffset, sizeof(FATX_DIR_ENTRY), PIN_WAIT, &Context, (PVOID*)&pFatXDirEntry);
     }
     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
     {
         _SEH2_YIELD(return _SEH2_GetExceptionCode());
     }
     _SEH2_END;
     RtlCopyMemory(pFatXDirEntry, &DirContext.DirEntry.FatX, sizeof(FATX_DIR_ENTRY));
     CcSetDirtyPinnedData(Context, NULL);
     CcUnpinData(Context);
 
     if (MoveContext != NULL)
     {
         /* We're modifying an existing FCB - likely rename/move */
         /* FIXME: check status */
         vfatUpdateFCB(DeviceExt, *Fcb, &DirContext, ParentFcb);
     }
     else
     {
         /* FIXME: check status */
         vfatMakeFCBFromDirEntry(DeviceExt, ParentFcb, &DirContext, Fcb);
     }
 
     DPRINT("addentry ok\n");
     return STATUS_SUCCESS;
 }

◆ FATXDelEntry()

static NTSTATUS FATXDelEntry	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN PVFATFCB	pFcb,
		OUT PVFAT_MOVE_CONTEXT	MoveContext
	)

static

Definition at line 1050 of file dirwr.c.

 {
     ULONG CurrentCluster = 0, NextCluster;
     PVOID Context = NULL;
     LARGE_INTEGER Offset;
     PFATX_DIR_ENTRY pDirEntry;
     ULONG StartIndex;
     NTSTATUS Status;
 
     ASSERT(pFcb);
     ASSERT(pFcb->parentFcb);
     ASSERT(vfatVolumeIsFatX(DeviceExt));
 
     StartIndex = pFcb->startIndex;
 
     Status = vfatFCBInitializeCacheFromVolume(DeviceExt, pFcb->parentFcb);
     if (!NT_SUCCESS(Status))
     {
         return Status;
     }
 
     DPRINT("delEntry PathName \'%wZ\'\n", &pFcb->PathNameU);
     DPRINT("delete entry: %u\n", StartIndex);
     Offset.u.HighPart = 0;
     Offset.u.LowPart = (StartIndex * sizeof(FATX_DIR_ENTRY) / PAGE_SIZE) * PAGE_SIZE;
     _SEH2_TRY
     {
         CcPinRead(pFcb->parentFcb->FileObject, &Offset, PAGE_SIZE, PIN_WAIT, &Context, (PVOID*)&pDirEntry);
     }
     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
     {
         DPRINT1("CcPinRead(Offset %x:%x, Length %d) failed\n", Offset.u.HighPart, Offset.u.LowPart, PAGE_SIZE);
         _SEH2_YIELD(return _SEH2_GetExceptionCode());
     }
     _SEH2_END;
     pDirEntry = &pDirEntry[StartIndex % (PAGE_SIZE / sizeof(FATX_DIR_ENTRY))];
     pDirEntry->FilenameLength = 0xe5;
     CurrentCluster = vfatDirEntryGetFirstCluster(DeviceExt,
                                                  (PDIR_ENTRY)pDirEntry);
 
     /* In case of moving, save properties */
     if (MoveContext != NULL)
     {
         MoveContext->FirstCluster = CurrentCluster;
         MoveContext->FileSize = pDirEntry->FileSize;
         MoveContext->CreationTime = pDirEntry->CreationTime;
         MoveContext->CreationDate = pDirEntry->CreationDate;
     }
 
     CcSetDirtyPinnedData(Context, NULL);
     CcUnpinData(Context);
 
     /* In case of moving, don't delete data */
     if (MoveContext == NULL)
     {
         while (CurrentCluster && CurrentCluster != 0xffffffff)
         {
             GetNextCluster(DeviceExt, CurrentCluster, &NextCluster);
             /* FIXME: check status */
             WriteCluster(DeviceExt, CurrentCluster, 0);
             CurrentCluster = NextCluster;
         }
     }
 
     return STATUS_SUCCESS;
 }

◆ FATXGetNextDirEntry()

NTSTATUS FATXGetNextDirEntry	(	PVOID *	pContext,
		PVOID *	pPage,
		PVFATFCB	pDirFcb,
		PVFAT_DIRENTRY_CONTEXT	DirContext,
		BOOLEAN	First
	)

◆ FATXIsDirectoryEmpty()

BOOLEAN FATXIsDirectoryEmpty	(	PDEVICE_EXTENSION	DeviceExt,
		PVFATFCB	Fcb
	)

Definition at line 119 of file direntry.c.

 {
     LARGE_INTEGER FileOffset;
     PVOID Context = NULL;
     PFATX_DIR_ENTRY FatXDirEntry;
     ULONG Index = 0, MaxIndex;
     NTSTATUS Status;
 
     FileOffset.QuadPart = 0;
     MaxIndex = Fcb->RFCB.FileSize.u.LowPart / sizeof(FATX_DIR_ENTRY);
 
     Status = vfatFCBInitializeCacheFromVolume(DeviceExt, Fcb);
     if (!NT_SUCCESS(Status))
     {
         return FALSE;
     }
 
     while (Index < MaxIndex)
     {
         if (Context == NULL || (Index % FATX_ENTRIES_PER_PAGE) == 0)
         {
             if (Context != NULL)
             {
                 CcUnpinData(Context);
             }
 
             _SEH2_TRY
             {
                 CcMapData(Fcb->FileObject, &FileOffset, sizeof(FATX_DIR_ENTRY), MAP_WAIT, &Context, (PVOID*)&FatXDirEntry);
             }
             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
             {
                 _SEH2_YIELD(return TRUE);
             }
             _SEH2_END;
 
             FatXDirEntry += Index % FATX_ENTRIES_PER_PAGE;
             FileOffset.QuadPart += PAGE_SIZE;
         }
 
         if (FATX_ENTRY_END(FatXDirEntry))
         {
             CcUnpinData(Context);
             return TRUE;
         }
 
         if (!FATX_ENTRY_DELETED(FatXDirEntry))
         {
             CcUnpinData(Context);
             return FALSE;
         }
 
         Index++;
         FatXDirEntry++;
     }
 
     if (Context)
     {
         CcUnpinData(Context);
     }
 
     return TRUE;
 }

◆ vfatFCBInitializeCacheFromVolume()

NTSTATUS vfatFCBInitializeCacheFromVolume	(	PVCB	vcb,
		PVFATFCB	fcb
	)

Definition at line 24 of file dirwr.c.

 {
     PFILE_OBJECT fileObject;
     PVFATCCB newCCB;
     NTSTATUS status;
     BOOLEAN Acquired;
 
     /* Don't re-initialize if already done */
     if (BooleanFlagOn(fcb->Flags, FCB_CACHE_INITIALIZED))
     {
         return STATUS_SUCCESS;
     }
 
     ASSERT(vfatFCBIsDirectory(fcb));
     ASSERT(fcb->FileObject == NULL);
 
     Acquired = FALSE;
     if (!ExIsResourceAcquiredExclusive(&vcb->DirResource))
     {
         ExAcquireResourceExclusiveLite(&vcb->DirResource, TRUE);
         Acquired = TRUE;
     }
 
     fileObject = IoCreateStreamFileObject (NULL, vcb->StorageDevice);
     if (fileObject == NULL)
     {
         status = STATUS_INSUFFICIENT_RESOURCES;
         goto Quit;
     }
 
 #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)
     {
         status = STATUS_INSUFFICIENT_RESOURCES;
         ObDereferenceObject(fileObject);
         goto Quit;
     }
     RtlZeroMemory(newCCB, sizeof (VFATCCB));
 
     fileObject->SectionObjectPointer = &fcb->SectionObjectPointers;
     fileObject->FsContext = fcb;
     fileObject->FsContext2 = newCCB;
     fileObject->Vpb = vcb->IoVPB;
     fcb->FileObject = fileObject;
 
     _SEH2_TRY
     {
         CcInitializeCacheMap(fileObject,
                              (PCC_FILE_SIZES)(&fcb->RFCB.AllocationSize),
                              TRUE,
                              &VfatGlobalData->CacheMgrCallbacks,
                              fcb);
     }
     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
     {
         status = _SEH2_GetExceptionCode();
         fcb->FileObject = NULL;
         ExFreeToNPagedLookasideList(&VfatGlobalData->CcbLookasideList, newCCB);
         ObDereferenceObject(fileObject);
         if (Acquired)
         {
             ExReleaseResourceLite(&vcb->DirResource);
         }
         return status;
     }
     _SEH2_END;
 
     vfatGrabFCB(vcb, fcb);
     SetFlag(fcb->Flags, FCB_CACHE_INITIALIZED);
     status = STATUS_SUCCESS;
 
 Quit:
     if (Acquired)
     {
         ExReleaseResourceLite(&vcb->DirResource);
     }
 
     return status;
 }

Referenced by FATAddEntry(), FATDelEntry(), FATGetNextDirEntry(), FATIsDirectoryEmpty(), FATXDelEntry(), FATXGetNextDirEntry(), FATXIsDirectoryEmpty(), FsdSetFsLabelInformation(), vfatFindDirSpace(), vfatMakeRootFCB(), vfatRenameEntry(), and VfatUpdateEntry().

◆ vfatFindDirSpace()

BOOLEAN vfatFindDirSpace	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN PVFATFCB	pDirFcb,
		IN ULONG	nbSlots,
		OUT PULONG	start
	)

Definition at line 260 of file dirwr.c.

 {
     LARGE_INTEGER FileOffset;
     ULONG i, count, size, nbFree = 0;
     PDIR_ENTRY pFatEntry = NULL;
     PVOID Context = NULL;
     NTSTATUS Status;
     ULONG SizeDirEntry;
     BOOLEAN IsFatX = vfatVolumeIsFatX(DeviceExt);
     FileOffset.QuadPart = 0;
 
     if (IsFatX)
         SizeDirEntry = sizeof(FATX_DIR_ENTRY);
     else
         SizeDirEntry = sizeof(FAT_DIR_ENTRY);
 
     Status = vfatFCBInitializeCacheFromVolume(DeviceExt, pDirFcb);
     if (!NT_SUCCESS(Status))
     {
         return FALSE;
     }
 
     count = pDirFcb->RFCB.FileSize.u.LowPart / SizeDirEntry;
     size = DeviceExt->FatInfo.BytesPerCluster / SizeDirEntry;
     for (i = 0; i < count; i++, pFatEntry = (PDIR_ENTRY)((ULONG_PTR)pFatEntry + SizeDirEntry))
     {
         if (Context == NULL || (i % size) == 0)
         {
             if (Context)
             {
                 CcUnpinData(Context);
             }
             _SEH2_TRY
             {
                 CcPinRead(pDirFcb->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster, PIN_WAIT, &Context, (PVOID*)&pFatEntry);
             }
             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
             {
                 _SEH2_YIELD(return FALSE);
             }
             _SEH2_END;
 
             FileOffset.u.LowPart += DeviceExt->FatInfo.BytesPerCluster;
         }
         if (ENTRY_END(IsFatX, pFatEntry))
         {
             break;
         }
         if (ENTRY_DELETED(IsFatX, pFatEntry))
         {
             nbFree++;
         }
         else
         {
             nbFree = 0;
         }
         if (nbFree == nbSlots)
         {
             break;
         }
     }
     if (Context)
     {
         CcUnpinData(Context);
         Context = NULL;
     }
     if (nbFree == nbSlots)
     {
         /* found enough contiguous free slots */
         *start = i - nbSlots + 1;
     }
     else
     {
         *start = i - nbFree;
         if (*start + nbSlots > count)
         {
             LARGE_INTEGER AllocationSize;
             /* extend the directory */
             if (vfatFCBIsRoot(pDirFcb) && DeviceExt->FatInfo.FatType != FAT32)
             {
                 /* We can't extend a root directory on a FAT12/FAT16/FATX partition */
                 return FALSE;
             }
             AllocationSize.QuadPart = pDirFcb->RFCB.FileSize.u.LowPart + DeviceExt->FatInfo.BytesPerCluster;
             Status = VfatSetAllocationSizeInformation(pDirFcb->FileObject, pDirFcb,
                                                       DeviceExt, &AllocationSize);
             if (!NT_SUCCESS(Status))
             {
                 return FALSE;
             }
             /* clear the new dir cluster */
             FileOffset.u.LowPart = (ULONG)(pDirFcb->RFCB.FileSize.QuadPart -
                                            DeviceExt->FatInfo.BytesPerCluster);
             _SEH2_TRY
             {
                 CcPinRead(pDirFcb->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster, PIN_WAIT, &Context, (PVOID*)&pFatEntry);
             }
             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
             {
                 _SEH2_YIELD(return FALSE);
             }
             _SEH2_END;
 
             if (IsFatX)
                 memset(pFatEntry, 0xff, DeviceExt->FatInfo.BytesPerCluster);
             else
                 RtlZeroMemory(pFatEntry, DeviceExt->FatInfo.BytesPerCluster);
         }
         else if (*start + nbSlots < count)
         {
             /* clear the entry after the last new entry */
             FileOffset.u.LowPart = (*start + nbSlots) * SizeDirEntry;
             _SEH2_TRY
             {
                 CcPinRead(pDirFcb->FileObject, &FileOffset, SizeDirEntry, PIN_WAIT, &Context, (PVOID*)&pFatEntry);
             }
             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
             {
                 _SEH2_YIELD(return FALSE);
             }
             _SEH2_END;
 
             if (IsFatX)
                 memset(pFatEntry, 0xff, SizeDirEntry);
             else
                 RtlZeroMemory(pFatEntry, SizeDirEntry);
         }
         if (Context)
         {
             CcSetDirtyPinnedData(Context, NULL);
             CcUnpinData(Context);
         }
     }
     DPRINT("nbSlots %u nbFree %u, entry number %u\n", nbSlots, nbFree, *start);
     return TRUE;
 }

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

◆ VfatMoveEntry()

NTSTATUS VfatMoveEntry	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN PVFATFCB	pFcb,
		IN PUNICODE_STRING	FileName,
		IN PVFATFCB	ParentFcb
	)

Definition at line 1124 of file dirwr.c.

 {
     NTSTATUS Status;
     PVFATFCB OldParent;
     VFAT_MOVE_CONTEXT MoveContext;
 
     DPRINT("VfatMoveEntry(%p, %p, %wZ, %p)\n", DeviceExt, pFcb, FileName, ParentFcb);
 
     /* Delete old entry while keeping data */
     Status = VfatDelEntry(DeviceExt, pFcb, &MoveContext);
     if (!NT_SUCCESS(Status))
     {
         return Status;
     }
 
     OldParent = pFcb->parentFcb;
     CcFlushCache(&OldParent->SectionObjectPointers, NULL, 0, NULL);
     MoveContext.InPlace = (OldParent == ParentFcb);
 
     /* Add our new entry with our cluster */
     Status = VfatAddEntry(DeviceExt,
                           FileName,
                           &pFcb,
                           ParentFcb,
                           (vfatFCBIsDirectory(pFcb) ? FILE_DIRECTORY_FILE : 0),
                           *pFcb->Attributes,
                           &MoveContext);
 
     CcFlushCache(&pFcb->parentFcb->SectionObjectPointers, NULL, 0, NULL);
 
     return Status;
 }

Referenced by vfatRenameEntry(), and VfatSetRenameInformation().

◆ vfatRenameEntry()

NTSTATUS vfatRenameEntry	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN PVFATFCB	pFcb,
		IN PUNICODE_STRING	FileName,
		IN BOOLEAN	CaseChangeOnly
	)

Definition at line 180 of file dirwr.c.

 {
     OEM_STRING NameA;
     ULONG StartIndex;
     PVOID Context = NULL;
     LARGE_INTEGER Offset;
     PFATX_DIR_ENTRY pDirEntry;
     NTSTATUS Status;
 
     DPRINT("vfatRenameEntry(%p, %p, %wZ, %d)\n", DeviceExt, pFcb, FileName, CaseChangeOnly);
 
     Status = vfatFCBInitializeCacheFromVolume(DeviceExt, pFcb->parentFcb);
     if (!NT_SUCCESS(Status))
     {
         return Status;
     }
 
     if (vfatVolumeIsFatX(DeviceExt))
     {
         VFAT_DIRENTRY_CONTEXT DirContext;
 
         /* Open associated dir entry */
         StartIndex = pFcb->startIndex;
         Offset.u.HighPart = 0;
         Offset.u.LowPart = (StartIndex * sizeof(FATX_DIR_ENTRY) / PAGE_SIZE) * PAGE_SIZE;
         _SEH2_TRY
         {
             CcPinRead(pFcb->parentFcb->FileObject, &Offset, PAGE_SIZE, PIN_WAIT, &Context, (PVOID*)&pDirEntry);
         }
         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
         {
             DPRINT1("CcPinRead(Offset %x:%x, Length %d) failed\n", Offset.u.HighPart, Offset.u.LowPart, PAGE_SIZE);
             _SEH2_YIELD(return _SEH2_GetExceptionCode());
         }
         _SEH2_END;
 
         pDirEntry = &pDirEntry[StartIndex % (PAGE_SIZE / sizeof(FATX_DIR_ENTRY))];
 
         /* Set file name */
         NameA.Buffer = (PCHAR)pDirEntry->Filename;
         NameA.Length = 0;
         NameA.MaximumLength = 42;
         RtlUnicodeStringToOemString(&NameA, FileName, FALSE);
         pDirEntry->FilenameLength = (unsigned char)NameA.Length;
 
         /* Update FCB */
         DirContext.DeviceExt = DeviceExt;
         DirContext.ShortNameU.Length = 0;
         DirContext.ShortNameU.MaximumLength = 0;
         DirContext.ShortNameU.Buffer = NULL;
         DirContext.LongNameU = *FileName;
         DirContext.DirEntry.FatX = *pDirEntry;
 
         CcSetDirtyPinnedData(Context, NULL);
         CcUnpinData(Context);
 
         Status = vfatUpdateFCB(DeviceExt, pFcb, &DirContext, pFcb->parentFcb);
         if (NT_SUCCESS(Status))
         {
             CcFlushCache(&pFcb->parentFcb->SectionObjectPointers, NULL, 0, NULL);
         }
 
         return Status;
     }
     else
     {
         /* This we cannot handle properly, move file - would likely need love */
         return VfatMoveEntry(DeviceExt, pFcb, FileName, pFcb->parentFcb);
     }
 }

Referenced by VfatSetRenameInformation().

◆ VfatUpdateEntry()

NTSTATUS VfatUpdateEntry	(	IN PDEVICE_EXTENSION	DeviceExt,
		IN PVFATFCB	pFcb
	)

Definition at line 117 of file dirwr.c.

 {
     PVOID Context;
     PDIR_ENTRY PinEntry;
     LARGE_INTEGER Offset;
     ULONG SizeDirEntry;
     ULONG dirIndex;
     NTSTATUS Status;
 
     ASSERT(pFcb);
 
     if (vfatVolumeIsFatX(DeviceExt))
     {
         SizeDirEntry = sizeof(FATX_DIR_ENTRY);
         dirIndex = pFcb->startIndex;
     }
     else
     {
         SizeDirEntry = sizeof(FAT_DIR_ENTRY);
         dirIndex = pFcb->dirIndex;
     }
 
     DPRINT("updEntry dirIndex %u, PathName \'%wZ\'\n", dirIndex, &pFcb->PathNameU);
 
     if (vfatFCBIsRoot(pFcb) || BooleanFlagOn(pFcb->Flags, FCB_IS_FAT | FCB_IS_VOLUME))
     {
         return STATUS_SUCCESS;
     }
 
     ASSERT(pFcb->parentFcb);
 
     Status = vfatFCBInitializeCacheFromVolume(DeviceExt, pFcb->parentFcb);
     if (!NT_SUCCESS(Status))
     {
         return Status;
     }
 
     Offset.u.HighPart = 0;
     Offset.u.LowPart = dirIndex * SizeDirEntry;
     _SEH2_TRY
     {
         CcPinRead(pFcb->parentFcb->FileObject, &Offset, SizeDirEntry, PIN_WAIT, &Context, (PVOID*)&PinEntry);
     }
     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
     {
         DPRINT1("Failed write to \'%wZ\'.\n", &pFcb->parentFcb->PathNameU);
         _SEH2_YIELD(return _SEH2_GetExceptionCode());
     }
     _SEH2_END;
 
     pFcb->Flags &= ~FCB_IS_DIRTY;
     RtlCopyMemory(PinEntry, &pFcb->entry, SizeDirEntry);
     CcSetDirtyPinnedData(Context, NULL);
     CcUnpinData(Context);
     return STATUS_SUCCESS;
 }

Referenced by VfatCleanupFile(), VfatCreateFile(), VfatFlushFile(), VfatSetAllocationSizeInformation(), and VfatSetBasicInformation().

Variable Documentation

◆ FatDispatch

VFAT_DISPATCH FatDispatch

Initial value:

= {
    FATIsDirectoryEmpty,    
    FATAddEntry,            
    FATDelEntry,            
    FATGetNextDirEntry,     
}

Definition at line 1173 of file dirwr.c.

Referenced by VfatMount().

◆ FatXDispatch

VFAT_DISPATCH FatXDispatch

Initial value:

= {
    FATXIsDirectoryEmpty,   
    FATXAddEntry,           
    FATXDelEntry,           
    FATXGetNextDirEntry,    
}

Definition at line 1166 of file dirwr.c.

Referenced by VfatMount().

Macros

Functions

Variables

Macro Definition Documentation

◆ NDEBUG

Function Documentation

◆ FATAddEntry()

◆ FATDelEntry()

◆ FATGetNextDirEntry()

◆ FATIsDirectoryEmpty()

◆ FATXAddEntry()

◆ FATXDelEntry()

◆ FATXGetNextDirEntry()

◆ FATXIsDirectoryEmpty()

◆ vfatFCBInitializeCacheFromVolume()

◆ vfatFindDirSpace()

◆ VfatMoveEntry()

◆ vfatRenameEntry()

◆ VfatUpdateEntry()

Variable Documentation

◆ FatDispatch

◆ FatXDispatch