Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-06-11 15:05:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

[FASTFAT][CDFS]

Browse source 
Call CcMapData(), CcPinRead() inside a SEH block
This allows returning more significant error codes on failure

[NTOSKRNL]
Enable Thomas code for raising exceptions

CORE-9848

svn path=/trunk/; revision=71888
This commit is contained in:
Pierre Schweitzer 2016-07-10 17:14:33 +00:00
parent 7320b9bca3
commit e8028606cf
8 changed files with 352 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
reactos/drivers/filesystems/cdfs/dirctl.c
View file

@ -75,14 +75,16 @@ CdfsGetEntryName(PDEVICE_EXTENSION DeviceExt,
CcUnpinData(*Context);
StreamOffset->QuadPart += BLOCKSIZE;
*CurrentOffset = ROUND_UP(*CurrentOffset, BLOCKSIZE);
if (!CcMapData(DeviceExt->StreamFileObject,
StreamOffset,
BLOCKSIZE, TRUE,
Context, Block))
_SEH2_TRY
{
CcMapData(DeviceExt->StreamFileObject, StreamOffset, BLOCKSIZE, TRUE, Context, Block);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT("CcMapData() failed\n");
return(STATUS_UNSUCCESSFUL);
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
*Ptr = *Block;
Record = (PDIR_RECORD)*Ptr;
}
@ -99,14 +101,16 @@ CdfsGetEntryName(PDEVICE_EXTENSION DeviceExt,
CcUnpinData(*Context);
StreamOffset->QuadPart += BLOCKSIZE;
*CurrentOffset = ROUND_UP(*CurrentOffset, BLOCKSIZE);
if (!CcMapData(DeviceExt->StreamFileObject,
StreamOffset,
BLOCKSIZE, TRUE,
Context, Block))
_SEH2_TRY
{
CcMapData(DeviceExt->StreamFileObject, StreamOffset, BLOCKSIZE, TRUE, Context, Block);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT("CcMapData() failed\n");
return(STATUS_UNSUCCESSFUL);
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
*Ptr = *Block;
Record = (PDIR_RECORD)*Ptr;
}
@ -231,12 +235,16 @@ CdfsFindFile(PDEVICE_EXTENSION DeviceExt,
StreamOffset.QuadPart += ROUND_DOWN(Offset, BLOCKSIZE);
}
if (!CcMapData(DeviceExt->StreamFileObject, &StreamOffset,
BLOCKSIZE, TRUE, &Context, &Block))
_SEH2_TRY
{
CcMapData(DeviceExt->StreamFileObject, &StreamOffset, BLOCKSIZE, TRUE, &Context, &Block);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT("CcMapData() failed\n");
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
Record = (PDIR_RECORD) ((ULONG_PTR)Block + Offset % BLOCKSIZE);
if (Offset)

26
reactos/drivers/filesystems/cdfs/fcb.c
View file

@ -489,16 +489,16 @@ CdfsDirFindFile(PDEVICE_EXTENSION DeviceExt,
DirSize = DirectoryFcb->Entry.DataLengthL;
StreamOffset.QuadPart = (LONGLONG)DirectoryFcb->Entry.ExtentLocationL * (LONGLONG)BLOCKSIZE;
if (!CcMapData(DeviceExt->StreamFileObject,
&StreamOffset,
BLOCKSIZE,
TRUE,
&Context,
&Block))
_SEH2_TRY
{
CcMapData(DeviceExt->StreamFileObject, &StreamOffset, BLOCKSIZE, TRUE, &Context, &Block);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT("CcMapData() failed\n");
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
Offset = 0;
BlockOffset = 0;
@ -575,15 +575,17 @@ CdfsDirFindFile(PDEVICE_EXTENSION DeviceExt,
Offset = ROUND_UP(Offset, BLOCKSIZE);
BlockOffset = 0;
if (!CcMapData(DeviceExt->StreamFileObject,
&StreamOffset,
BLOCKSIZE, TRUE,
&Context, &Block))
_SEH2_TRY
{
CcMapData(DeviceExt->StreamFileObject, &StreamOffset, BLOCKSIZE, TRUE, &Context, &Block);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT("CcMapData() failed\n");
RtlFreeUnicodeString(&FileToFindUpcase);
return(STATUS_UNSUCCESSFUL);
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
Record = (PDIR_RECORD)((ULONG_PTR)Block + BlockOffset);
}

23
reactos/drivers/filesystems/fastfat/create.c
View file

@ -111,6 +111,7 @@ ReadVolumeLabel(
ULONG SizeDirEntry;
ULONG EntriesPerPage;
OEM_STRING StringO;
NTSTATUS Status = STATUS_SUCCESS;
NameU.Buffer = Vpb->VolumeLabel;
NameU.Length = 0;
@ -134,7 +135,16 @@ ReadVolumeLabel(
ExReleaseResourceLite(&DeviceExt->DirResource);
FileOffset.QuadPart = 0;
if (CcMapData(pFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry))
_SEH2_TRY
{
CcMapData(pFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
if (NT_SUCCESS(Status))
{
while (TRUE)
{
@ -164,7 +174,16 @@ ReadVolumeLabel(
{
CcUnpinData(Context);
FileOffset.u.LowPart += PAGE_SIZE;
if (!CcMapData(pFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry))
_SEH2_TRY
{
CcMapData(pFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
if (!NT_SUCCESS(Status))
{
Context = NULL;
break;

103
reactos/drivers/filesystems/fastfat/direntry.c
View file

@ -70,10 +70,15 @@ FATIsDirectoryEmpty(
CcUnpinData(Context);
}
if (!CcMapData(Fcb->FileObject, &FileOffset, sizeof(FAT_DIR_ENTRY), TRUE, &Context, (PVOID*)&FatDirEntry))
_SEH2_TRY
{
return TRUE;
CcMapData(Fcb->FileObject, &FileOffset, sizeof(FAT_DIR_ENTRY), TRUE, &Context, (PVOID*)&FatDirEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return TRUE);
}
_SEH2_END;
FatDirEntry += Index % FAT_ENTRIES_PER_PAGE;
FileOffset.QuadPart += PAGE_SIZE;
@ -125,10 +130,15 @@ FATXIsDirectoryEmpty(
CcUnpinData(Context);
}
if (!CcMapData(Fcb->FileObject, &FileOffset, sizeof(FATX_DIR_ENTRY), TRUE, &Context, (PVOID*)&FatXDirEntry))
_SEH2_TRY
{
return TRUE;
CcMapData(Fcb->FileObject, &FileOffset, sizeof(FATX_DIR_ENTRY), TRUE, &Context, (PVOID*)&FatXDirEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return TRUE);
}
_SEH2_END;
FatXDirEntry += Index % FATX_ENTRIES_PER_PAGE;
FileOffset.QuadPart += PAGE_SIZE;
@ -201,12 +211,22 @@ FATGetNextDirEntry(
CcUnpinData(*pContext);
}
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart ||
!CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage))
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart)
{
*pContext = NULL;
return STATUS_NO_MORE_ENTRIES;
}
_SEH2_TRY
{
CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
*pContext = NULL;
_SEH2_YIELD(return STATUS_NO_MORE_ENTRIES);
}
_SEH2_END;
}
fatDirEntry = (PFAT_DIR_ENTRY)(*pPage) + DirContext->DirIndex % FAT_ENTRIES_PER_PAGE;
@ -232,13 +252,23 @@ FATGetNextDirEntry(
CcUnpinData(*pContext);
FileOffset.u.LowPart -= PAGE_SIZE;
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart ||
!CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage))
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart)
{
*pContext = NULL;
return STATUS_NO_MORE_ENTRIES;
}
_SEH2_TRY
{
CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
*pContext = NULL;
_SEH2_YIELD(return STATUS_NO_MORE_ENTRIES);
}
_SEH2_END;
fatDirEntry = (PFAT_DIR_ENTRY)(*pPage) + DirContext->DirIndex % FAT_ENTRIES_PER_PAGE;
longNameEntry = (slot*) fatDirEntry;
}
@ -259,13 +289,23 @@ FATGetNextDirEntry(
CcUnpinData(*pContext);
FileOffset.u.LowPart += PAGE_SIZE;
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart ||
!CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage))
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart)
{
*pContext = NULL;
return STATUS_NO_MORE_ENTRIES;
}
_SEH2_TRY
{
CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
*pContext = NULL;
_SEH2_YIELD(return STATUS_NO_MORE_ENTRIES);
}
_SEH2_END;
fatDirEntry = (PFAT_DIR_ENTRY)*pPage;
longNameEntry = (slot*) *pPage;
}
@ -379,13 +419,23 @@ FATGetNextDirEntry(
CcUnpinData(*pContext);
FileOffset.u.LowPart += PAGE_SIZE;
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart ||
!CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage))
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart)
{
*pContext = NULL;
return STATUS_NO_MORE_ENTRIES;
}
_SEH2_TRY
{
CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
*pContext = NULL;
_SEH2_YIELD(return STATUS_NO_MORE_ENTRIES);
}
_SEH2_END;
fatDirEntry = (PFAT_DIR_ENTRY)*pPage;
longNameEntry = (slot*) *pPage;
}
@ -467,12 +517,22 @@ FATXGetNextDirEntry(
CcUnpinData(*pContext);
}
FileOffset.u.LowPart = ROUND_DOWN(DirIndex * sizeof(FATX_DIR_ENTRY), PAGE_SIZE);
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart ||
!CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage))
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart)
{
*pContext = NULL;
return STATUS_NO_MORE_ENTRIES;
}
_SEH2_TRY
{
CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
*pContext = NULL;
_SEH2_YIELD(return STATUS_NO_MORE_ENTRIES);
}
_SEH2_END;
}
fatxDirEntry = (PFATX_DIR_ENTRY)(*pPage) + DirIndex % FATX_ENTRIES_PER_PAGE;
@ -500,12 +560,23 @@ FATXGetNextDirEntry(
{
CcUnpinData(*pContext);
FileOffset.u.LowPart += PAGE_SIZE;
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart ||
!CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage))
if (FileOffset.u.LowPart >= pDirFcb->RFCB.FileSize.u.LowPart)
{
*pContext = NULL;
return STATUS_NO_MORE_ENTRIES;
}
_SEH2_TRY
{
CcMapData(pDirFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, pPage);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
*pContext = NULL;
_SEH2_YIELD(return STATUS_NO_MORE_ENTRIES);
}
_SEH2_END;
fatxDirEntry = (PFATX_DIR_ENTRY)*pPage;
}
else

135
reactos/drivers/filesystems/fastfat/dirwr.c
View file

@ -53,20 +53,22 @@ VfatUpdateEntry(
Offset.u.HighPart = 0;
Offset.u.LowPart = dirIndex * SizeDirEntry;
if (CcPinRead(pFcb->parentFcb->FileObject, &Offset, SizeDirEntry,
TRUE, &Context, (PVOID*)&PinEntry))
_SEH2_TRY
{
pFcb->Flags &= ~FCB_IS_DIRTY;
RtlCopyMemory(PinEntry, &pFcb->entry, SizeDirEntry);
CcSetDirtyPinnedData(Context, NULL);
CcUnpinData(Context);
return STATUS_SUCCESS;
CcPinRead(pFcb->parentFcb->FileObject, &Offset, SizeDirEntry, TRUE, &Context, (PVOID*)&PinEntry);
}
else
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT1("Failed write to \'%wZ\'.\n", &pFcb->parentFcb->PathNameU);
return STATUS_UNSUCCESSFUL;
_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;
}
/*
@ -96,12 +98,16 @@ vfatRenameEntry(
StartIndex = pFcb->startIndex;
Offset.u.HighPart = 0;
Offset.u.LowPart = (StartIndex * sizeof(FATX_DIR_ENTRY) / PAGE_SIZE) * PAGE_SIZE;
if (!CcPinRead(pFcb->parentFcb->FileObject, &Offset, sizeof(FATX_DIR_ENTRY), TRUE,
&Context, (PVOID*)&pDirEntry))
_SEH2_TRY
{
CcPinRead(pFcb->parentFcb->FileObject, &Offset, sizeof(FATX_DIR_ENTRY), TRUE, &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);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
pDirEntry = &pDirEntry[StartIndex % (PAGE_SIZE / sizeof(FATX_DIR_ENTRY))];
@ -170,11 +176,16 @@ vfatFindDirSpace(
{
CcUnpinData(Context);
}
if (!CcPinRead(pDirFcb->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster,
TRUE, &Context, (PVOID*)&pFatEntry))
_SEH2_TRY
{
return FALSE;
CcPinRead(pDirFcb->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster, TRUE, &Context, (PVOID*)&pFatEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
FileOffset.u.LowPart += DeviceExt->FatInfo.BytesPerCluster;
}
if (ENTRY_END(DeviceExt, pFatEntry))
@ -226,11 +237,16 @@ vfatFindDirSpace(
/* clear the new dir cluster */
FileOffset.u.LowPart = (ULONG)(pDirFcb->RFCB.FileSize.QuadPart -
DeviceExt->FatInfo.BytesPerCluster);
if (!CcPinRead(pDirFcb->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster,
TRUE, &Context, (PVOID*)&pFatEntry))
_SEH2_TRY
{
return FALSE;
CcPinRead(pDirFcb->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster, TRUE, &Context, (PVOID*)&pFatEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
if (DeviceExt->Flags & VCB_IS_FATX)
memset(pFatEntry, 0xff, DeviceExt->FatInfo.BytesPerCluster);
else
@ -240,11 +256,16 @@ vfatFindDirSpace(
{
/* clear the entry after the last new entry */
FileOffset.u.LowPart = (*start + nbSlots) * SizeDirEntry;
if (!CcPinRead(pDirFcb->FileObject, &FileOffset, SizeDirEntry,
TRUE, &Context, (PVOID*)&pFatEntry))
_SEH2_TRY
{
return FALSE;
CcPinRead(pDirFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&pFatEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return FALSE);
}
_SEH2_END;
if (DeviceExt->Flags & VCB_IS_FATX)
memset(pFatEntry, 0xff, SizeDirEntry);
else
@ -556,12 +577,17 @@ FATAddEntry(
if (DirContext.StartIndex / i == DirContext.DirIndex / i)
{
/* one cluster */
if (!CcPinRead(ParentFcb->FileObject, &FileOffset, nbSlots * sizeof(FAT_DIR_ENTRY),
TRUE, &Context, (PVOID*)&pFatEntry))
_SEH2_TRY
{
CcPinRead(ParentFcb->FileObject, &FileOffset, nbSlots * sizeof(FAT_DIR_ENTRY), TRUE, &Context, (PVOID*)&pFatEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ExFreePoolWithTag(Buffer, TAG_VFAT);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
if (nbSlots > 1)
{
RtlCopyMemory(pFatEntry, Buffer, (nbSlots - 1) * sizeof(FAT_DIR_ENTRY));
@ -574,23 +600,30 @@ FATAddEntry(
size = DeviceExt->FatInfo.BytesPerCluster -
(DirContext.StartIndex * sizeof(FAT_DIR_ENTRY)) % DeviceExt->FatInfo.BytesPerCluster;
i = size / sizeof(FAT_DIR_ENTRY);
if (!CcPinRead(ParentFcb->FileObject, &FileOffset, size, TRUE,
&Context, (PVOID*)&pFatEntry))
_SEH2_TRY
{
CcPinRead(ParentFcb->FileObject, &FileOffset, size, TRUE, &Context, (PVOID*)&pFatEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ExFreePoolWithTag(Buffer, TAG_VFAT);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
RtlCopyMemory(pFatEntry, Buffer, size);
CcSetDirtyPinnedData(Context, NULL);
CcUnpinData(Context);
FileOffset.u.LowPart += size;
if (!CcPinRead(ParentFcb->FileObject, &FileOffset,
nbSlots * sizeof(FAT_DIR_ENTRY) - size,
TRUE, &Context, (PVOID*)&pFatEntry))
_SEH2_TRY
{
CcPinRead(ParentFcb->FileObject, &FileOffset, nbSlots * sizeof(FAT_DIR_ENTRY) - size, TRUE, &Context, (PVOID*)&pFatEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ExFreePoolWithTag(Buffer, TAG_VFAT);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
if (nbSlots - 1 > i)
{
RtlCopyMemory(pFatEntry, (PVOID)(Buffer + size), (nbSlots - 1 - i) * sizeof(FAT_DIR_ENTRY));
@ -623,12 +656,16 @@ FATAddEntry(
if (RequestedOptions & FILE_DIRECTORY_FILE)
{
FileOffset.QuadPart = 0;
if (!CcPinRead((*Fcb)->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster, TRUE,
&Context, (PVOID*)&pFatEntry))
_SEH2_TRY
{
CcPinRead((*Fcb)->FileObject, &FileOffset, DeviceExt->FatInfo.BytesPerCluster, TRUE, &Context, (PVOID*)&pFatEntry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
ExFreePoolWithTag(Buffer, TAG_VFAT);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
/* clear the new directory cluster if not moving */
if (MoveContext == NULL)
{
@ -746,11 +783,15 @@ FATXAddEntry(
/* add entry into parent directory */
FileOffset.u.HighPart = 0;
FileOffset.u.LowPart = Index * sizeof(FATX_DIR_ENTRY);
if (!CcPinRead(ParentFcb->FileObject, &FileOffset, sizeof(FATX_DIR_ENTRY),
TRUE, &Context, (PVOID*)&pFatXDirEntry))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcPinRead(ParentFcb->FileObject, &FileOffset, sizeof(FATX_DIR_ENTRY), TRUE, &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);
@ -819,11 +860,15 @@ FATDelEntry(
CcUnpinData(Context);
}
Offset.u.LowPart = (i * sizeof(FAT_DIR_ENTRY) / PAGE_SIZE) * PAGE_SIZE;
if (!CcPinRead(pFcb->parentFcb->FileObject, &Offset, sizeof(FAT_DIR_ENTRY), TRUE,
&Context, (PVOID*)&pDirEntry))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcPinRead(pFcb->parentFcb->FileObject, &Offset, sizeof(FAT_DIR_ENTRY), TRUE, &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)
@ -887,12 +932,16 @@ FATXDelEntry(
DPRINT("delete entry: %u\n", StartIndex);
Offset.u.HighPart = 0;
Offset.u.LowPart = (StartIndex * sizeof(FATX_DIR_ENTRY) / PAGE_SIZE) * PAGE_SIZE;
if (!CcPinRead(pFcb->parentFcb->FileObject, &Offset, sizeof(FATX_DIR_ENTRY), TRUE,
&Context, (PVOID*)&pDirEntry))
_SEH2_TRY
{
CcPinRead(pFcb->parentFcb->FileObject, &Offset, sizeof(FATX_DIR_ENTRY), TRUE, &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);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
pDirEntry = &pDirEntry[StartIndex % (PAGE_SIZE / sizeof(FATX_DIR_ENTRY))];
pDirEntry->FilenameLength = 0xe5;
CurrentCluster = vfatDirEntryGetFirstCluster(DeviceExt,

108
reactos/drivers/filesystems/fastfat/fat.c
View file

@ -41,10 +41,15 @@ FAT32GetNextCluster(
ChunkSize = CACHEPAGESIZE(DeviceExt);
FATOffset = CurrentCluster * sizeof(ULONG);
Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
if (!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
CurrentCluster = (*(PULONG)((char*)BaseAddress + (FATOffset % ChunkSize))) & 0x0fffffff;
if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff)
@ -81,10 +86,15 @@ FAT16GetNextCluster(
ChunkSize = CACHEPAGESIZE(DeviceExt);
FATOffset = CurrentCluster * 2;
Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
if (!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
CurrentCluster = *((PUSHORT)((char*)BaseAddress + (FATOffset % ChunkSize)));
if (CurrentCluster >= 0xfff8 && CurrentCluster <= 0xffff)
@ -121,10 +131,15 @@ FAT12GetNextCluster(
*NextCluster = 0;
Offset.QuadPart = 0;
if (!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, MAP_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, MAP_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
CBlock = (PUSHORT)((char*)BaseAddress + (CurrentCluster * 12) / 8);
if ((CurrentCluster % 2) == 0)
@ -176,11 +191,16 @@ FAT16FindAndMarkAvailableCluster(
for (i = StartCluster; i < FatLength;)
{
Offset.QuadPart = ROUND_DOWN(i * 2, ChunkSize);
if (!CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT1("CcPinRead(Offset %x, Length %u) failed\n", (ULONG)Offset.QuadPart, ChunkSize);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
Block = (PUSHORT)((ULONG_PTR)BaseAddress + (i * 2) % ChunkSize);
BlockEnd = (PUSHORT)((ULONG_PTR)BaseAddress + ChunkSize);
@ -235,11 +255,16 @@ FAT12FindAndMarkAvailableCluster(
*Cluster = 0;
StartCluster = DeviceExt->LastAvailableCluster;
Offset.QuadPart = 0;
if (!CcPinRead(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, PIN_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
CcPinRead(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, PIN_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT1("CcPinRead(Offset %x, Length %u) failed\n", (ULONG)Offset.QuadPart, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
for (j = 0; j < 2; j++)
{
@ -305,11 +330,16 @@ FAT32FindAndMarkAvailableCluster(
for (i = StartCluster; i < FatLength;)
{
Offset.QuadPart = ROUND_DOWN(i * 4, ChunkSize);
if (!CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT1("CcPinRead(Offset %x, Length %u) failed\n", (ULONG)Offset.QuadPart, ChunkSize);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
Block = (PULONG)((ULONG_PTR)BaseAddress + (i * 4) % ChunkSize);
BlockEnd = (PULONG)((ULONG_PTR)BaseAddress + ChunkSize);
@ -358,10 +388,15 @@ FAT12CountAvailableClusters(
PUSHORT CBlock;
Offset.QuadPart = 0;
if (!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, MAP_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, MAP_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
numberofclusters = DeviceExt->FatInfo.NumberOfClusters + 2;
@ -413,10 +448,15 @@ FAT16CountAvailableClusters(
for (i = 2; i < FatLength; )
{
Offset.QuadPart = ROUND_DOWN(i * 2, ChunkSize);
if (!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
Block = (PUSHORT)((ULONG_PTR)BaseAddress + (i * 2) % ChunkSize);
BlockEnd = (PUSHORT)((ULONG_PTR)BaseAddress + ChunkSize);
@ -463,11 +503,16 @@ FAT32CountAvailableClusters(
for (i = 2; i < FatLength; )
{
Offset.QuadPart = ROUND_DOWN(i * 4, ChunkSize);
if (!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, MAP_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
DPRINT1("CcMapData(Offset %x, Length %u) failed\n", (ULONG)Offset.QuadPart, ChunkSize);
return STATUS_UNSUCCESSFUL;
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
Block = (PULONG)((ULONG_PTR)BaseAddress + (i * 4) % ChunkSize);
BlockEnd = (PULONG)((ULONG_PTR)BaseAddress + ChunkSize);
@ -529,10 +574,15 @@ FAT12WriteCluster(
LARGE_INTEGER Offset;
Offset.QuadPart = 0;
if (!CcPinRead(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, PIN_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcPinRead(DeviceExt->FATFileObject, &Offset, DeviceExt->FatInfo.FATSectors * DeviceExt->FatInfo.BytesPerSector, PIN_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
CBlock = (PUCHAR)BaseAddress;
FATOffset = (ClusterToWrite * 12) / 8;
@ -578,10 +628,15 @@ FAT16WriteCluster(
ChunkSize = CACHEPAGESIZE(DeviceExt);
FATOffset = ClusterToWrite * 2;
Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
if (!CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
ClusterToWrite);
@ -614,10 +669,15 @@ FAT32WriteCluster(
FATOffset = (ClusterToWrite * 4);
Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
if (!CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress))
_SEH2_TRY
{
return STATUS_UNSUCCESSFUL;
CcPinRead(DeviceExt->FATFileObject, &Offset, ChunkSize, PIN_WAIT, &Context, &BaseAddress);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
_SEH2_YIELD(return _SEH2_GetExceptionCode());
}
_SEH2_END;
DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
ClusterToWrite);

39
reactos/drivers/filesystems/fastfat/volume.c
View file

@ -314,7 +314,17 @@ FsdSetFsLabelInformation(
/* Search existing volume entry on disk */
FileOffset.QuadPart = 0;
if (CcPinRead(pRootFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry))
_SEH2_TRY
{
CcPinRead(pRootFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
if (NT_SUCCESS(Status))
{
while (TRUE)
{
@ -339,7 +349,17 @@ FsdSetFsLabelInformation(
{
CcUnpinData(Context);
FileOffset.u.LowPart += PAGE_SIZE;
if (!CcPinRead(pRootFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry))
_SEH2_TRY
{
CcPinRead(pRootFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
if (!NT_SUCCESS(Status))
{
Context = NULL;
break;
@ -362,12 +382,19 @@ FsdSetFsLabelInformation(
{
FileOffset.u.HighPart = 0;
FileOffset.u.LowPart = VolumeLabelDirIndex * SizeDirEntry;
if (!CcPinRead(pRootFcb->FileObject, &FileOffset, SizeDirEntry,
TRUE, &Context, (PVOID*)&Entry))
Status = STATUS_SUCCESS;
_SEH2_TRY
{
Status = STATUS_UNSUCCESSFUL;
CcPinRead(pRootFcb->FileObject, &FileOffset, SizeDirEntry, TRUE, &Context, (PVOID*)&Entry);
}
else
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
if (NT_SUCCESS(Status))
{
RtlCopyMemory(Entry, &VolumeLabelDirEntry, SizeDirEntry);
CcSetDirtyPinnedData(Context, NULL);

14
reactos/ntoskrnl/cc/pin.c
View file

@ -16,8 +16,6 @@
/* GLOBALS *******************************************************************/
//#define RAISE_FROM_CC_MAP_DATA
extern NPAGED_LOOKASIDE_LIST iBcbLookasideList;
/* FUNCTIONS *****************************************************************/
@ -64,11 +62,8 @@ CcMapData (
{
CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
FileObject, FileOffset, Length, Flags);
#ifdef RAISE_FROM_CC_MAP_DATA
ExRaiseStatus(STATUS_INVALID_PARAMETER);
#else
return FALSE;
#endif
}
ROffset = ROUND_DOWN(ReadOffset, VACB_MAPPING_GRANULARITY);
@ -81,11 +76,8 @@ CcMapData (
{
CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
FileObject, FileOffset, Length, Flags);
#ifdef RAISE_FROM_CC_MAP_DATA
ExRaiseStatus(Status);
#else
return FALSE;
#endif
}
if (!Valid)
@ -104,11 +96,8 @@ CcMapData (
CcRosReleaseVacb(SharedCacheMap, Vacb, FALSE, FALSE, FALSE);
CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
FileObject, FileOffset, Length, Flags);
#ifdef RAISE_FROM_CC_MAP_DATA
ExRaiseStatus(Status);
#else
return FALSE;
#endif
}
}
@ -119,11 +108,8 @@ CcMapData (
CcRosReleaseVacb(SharedCacheMap, Vacb, TRUE, FALSE, FALSE);
CCTRACE(CC_API_DEBUG, "FileObject=%p FileOffset=%p Length=%lu Flags=0x%lx -> FALSE\n",
FileObject, FileOffset, Length, Flags);
#ifdef RAISE_FROM_CC_MAP_DATA
ExRaiseStatus(STATUS_INSUFFICIENT_RESOURCES);
#else
return FALSE;
#endif
}
RtlZeroMemory(iBcb, sizeof(*iBcb));