Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 04:43:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

[FASTFAT]

Browse source 
Fix coding style and indentation. No code changes!

svn path=/trunk/; revision=61252
This commit is contained in:
Eric Kohl 2013-12-09 10:35:15 +00:00
parent 5a02327fd0
commit 3f339ec7b9
15 changed files with 3195 additions and 3051 deletions
Download patch file Download diff file Expand all files Collapse all files

47
reactos/drivers/filesystems/fastfat/blockdev.c
View file

@ -15,8 +15,12 @@
/* FUNCTIONS ***************************************************************/
static IO_COMPLETION_ROUTINE VfatReadWritePartialCompletion;
static NTSTATUS NTAPI
VfatReadWritePartialCompletion (IN PDEVICE_OBJECT DeviceObject,
static
NTSTATUS
NTAPI
VfatReadWritePartialCompletion(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context)
{
@ -34,6 +38,7 @@ VfatReadWritePartialCompletion (IN PDEVICE_OBJECT DeviceObject,
Irp->MdlAddress = Mdl->Next;
IoFreeMdl(Mdl);
}
if (Irp->PendingReturned)
{
IrpContext->Flags |= IRPCONTEXT_PENDINGRETURNED;
@ -42,15 +47,18 @@ VfatReadWritePartialCompletion (IN PDEVICE_OBJECT DeviceObject,
{
IrpContext->Flags &= ~IRPCONTEXT_PENDINGRETURNED;
}
if (!NT_SUCCESS(Irp->IoStatus.Status))
{
IrpContext->Irp->IoStatus.Status = Irp->IoStatus.Status;
}
if (0 == InterlockedDecrement((PLONG)&IrpContext->RefCount) &&
IrpContext->Flags & IRPCONTEXT_PENDINGRETURNED)
{
KeSetEvent(&IrpContext->Event, IO_NO_INCREMENT, FALSE);
}
IoFreeIrp(Irp);
DPRINT("VfatReadWritePartialCompletion() done\n");
@ -59,7 +67,8 @@ VfatReadWritePartialCompletion (IN PDEVICE_OBJECT DeviceObject,
}
NTSTATUS
VfatReadDisk (IN PDEVICE_OBJECT pDeviceObject,
VfatReadDisk(
IN PDEVICE_OBJECT pDeviceObject,
IN PLARGE_INTEGER ReadOffset,
IN ULONG ReadLength,
IN OUT PUCHAR Buffer,
@ -68,11 +77,11 @@ VfatReadDisk (IN PDEVICE_OBJECT pDeviceObject,
PIO_STACK_LOCATION Stack;
PIRP Irp;
IO_STATUS_BLOCK IoStatus;
KEVENT event;
KEVENT Event;
NTSTATUS Status;
again:
KeInitializeEvent (&event, NotificationEvent, FALSE);
KeInitializeEvent(&Event, NotificationEvent, FALSE);
DPRINT("VfatReadDisk(pDeviceObject %p, Offset %I64x, Length %u, Buffer %p)\n",
pDeviceObject, ReadOffset->QuadPart, ReadLength, Buffer);
@ -83,12 +92,12 @@ again:
Buffer,
ReadLength,
ReadOffset,
&event,
&Event,
&IoStatus);
if (Irp == NULL)
{
DPRINT("IoBuildSynchronousFsdRequest failed\n");
return(STATUS_UNSUCCESSFUL);
return STATUS_UNSUCCESSFUL;
}
if (Override)
@ -104,7 +113,7 @@ again:
if (Status == STATUS_PENDING)
{
DPRINT("Operation pending\n");
KeWaitForSingleObject (&event, Suspended, KernelMode, FALSE, NULL);
KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
DPRINT("Getting IO Status... for %p\n", Irp);
Status = IoStatus.Status;
}
@ -120,7 +129,6 @@ again:
IoSetDeviceToVerify(PsGetCurrentThread(), NULL);
Status = IoVerifyVolume(DeviceToVerify,
FALSE);
if (NT_SUCCESS(Status))
{
DPRINT1("Volume verification successful; Reissuing read request\n");
@ -133,14 +141,15 @@ again:
DPRINT("IO failed!!! VfatReadDisk : Error code: %x\n", Status);
DPRINT("(pDeviceObject %p, Offset %I64x, Size %u, Buffer %p\n",
pDeviceObject, ReadOffset->QuadPart, ReadLength, Buffer);
return (Status);
return Status;
}
DPRINT("Block request succeeded for %p\n", Irp);
return (STATUS_SUCCESS);
return STATUS_SUCCESS;
}
NTSTATUS
VfatReadDiskPartial (IN PVFAT_IRP_CONTEXT IrpContext,
VfatReadDiskPartial(
IN PVFAT_IRP_CONTEXT IrpContext,
IN PLARGE_INTEGER ReadOffset,
IN ULONG ReadLength,
ULONG BufferOffset,
@ -163,7 +172,7 @@ again:
if (Irp == NULL)
{
DPRINT("IoAllocateIrp failed\n");
return(STATUS_UNSUCCESSFUL);
return STATUS_UNSUCCESSFUL;
}
Irp->UserIosb = NULL;
@ -226,7 +235,6 @@ again:
IoSetDeviceToVerify(PsGetCurrentThread(), NULL);
Status = IoVerifyVolume(DeviceToVerify,
FALSE);
if (NT_SUCCESS(Status))
{
DPRINT1("Volume verification successful; Reissuing read request\n");
@ -240,7 +248,8 @@ again:
NTSTATUS
VfatWriteDiskPartial (IN PVFAT_IRP_CONTEXT IrpContext,
VfatWriteDiskPartial(
IN PVFAT_IRP_CONTEXT IrpContext,
IN PLARGE_INTEGER WriteOffset,
IN ULONG WriteLength,
IN ULONG BufferOffset,
@ -262,7 +271,7 @@ again:
if (Irp == NULL)
{
DPRINT("IoAllocateIrp failed\n");
return(STATUS_UNSUCCESSFUL);
return STATUS_UNSUCCESSFUL;
}
Irp->UserIosb = NULL;
@ -285,6 +294,7 @@ again:
IoFreeIrp(Irp);
return STATUS_UNSUCCESSFUL;
}
IoBuildPartialMdl(IrpContext->Irp->MdlAddress, Irp->MdlAddress, Buffer, WriteLength);
IoSetCompletionRoutine(Irp,
@ -304,7 +314,6 @@ again:
InterlockedIncrement((PLONG)&IrpContext->RefCount);
}
DPRINT("Calling IO Driver...\n");
Status = IoCallDriver(IrpContext->DeviceExt->StorageDevice, Irp);
if (Wait && Status == STATUS_PENDING)
@ -324,7 +333,6 @@ again:
IoSetDeviceToVerify(PsGetCurrentThread(), NULL);
Status = IoVerifyVolume(DeviceToVerify,
FALSE);
if (NT_SUCCESS(Status))
{
DPRINT1("Volume verification successful; Reissuing write request\n");
@ -336,7 +344,8 @@ again:
}
NTSTATUS
VfatBlockDeviceIoControl (IN PDEVICE_OBJECT DeviceObject,
VfatBlockDeviceIoControl(
IN PDEVICE_OBJECT DeviceObject,
IN ULONG CtlCode,
IN PVOID InputBuffer OPTIONAL,
IN ULONG InputBufferSize,

13
reactos/drivers/filesystems/fastfat/close.c
View file

@ -13,11 +13,13 @@
/* FUNCTIONS ****************************************************************/
NTSTATUS
VfatCloseFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
/*
* FUNCTION: Closes a file
*/
NTSTATUS
VfatCloseFile(
PDEVICE_EXTENSION DeviceExt,
PFILE_OBJECT FileObject)
{
PVFATFCB pFcb;
PVFATCCB pCcb;
@ -54,6 +56,7 @@ VfatCloseFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
Status = STATUS_DELETE_PENDING;
}
}
vfatReleaseFCB (DeviceExt, pFcb);
}
@ -69,10 +72,12 @@ VfatCloseFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject)
return Status;
}
NTSTATUS VfatClose (PVFAT_IRP_CONTEXT IrpContext)
/*
* FUNCTION: Closes a file
*/
NTSTATUS
VfatClose(
PVFAT_IRP_CONTEXT IrpContext)
{
NTSTATUS Status;
@ -104,7 +109,7 @@ ByeBye:
IoCompleteRequest (IrpContext->Irp, IO_NO_INCREMENT);
VfatFreeIrpContext(IrpContext);
return (Status);
return Status;
}
/* EOF */

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

@ -30,8 +30,10 @@
/* FUNCTIONS *****************************************************************/
void
vfat8Dot3ToString (PFAT_DIR_ENTRY pEntry, PUNICODE_STRING NameU)
VOID
vfat8Dot3ToString(
PFAT_DIR_ENTRY pEntry,
PUNICODE_STRING NameU)
{
OEM_STRING StringA;
USHORT Length;
@ -56,6 +58,7 @@ vfat8Dot3ToString (PFAT_DIR_ENTRY pEntry, PUNICODE_STRING NameU)
{
RtlDowncaseUnicodeString(NameU, NameU, FALSE);
}
if (cString[8] != ' ')
{
Length = NameU->Length;
@ -83,6 +86,7 @@ vfat8Dot3ToString (PFAT_DIR_ENTRY pEntry, PUNICODE_STRING NameU)
NameU->Length += Length;
NameU->MaximumLength += Length;
}
NameU->Buffer[NameU->Length / sizeof(WCHAR)] = 0;
DPRINT("'%wZ'\n", NameU);
}

6
reactos/drivers/filesystems/fastfat/ea.c
View file

@ -21,7 +21,6 @@
* FILE: drivers/fs/vfat/ea.c
* PURPOSE: VFAT Filesystem
* PROGRAMMER: Jason Filby (jasonfilby@yahoo.com)
*/
/* INCLUDES *****************************************************************/
@ -32,7 +31,8 @@
/* FUNCTIONS *****************************************************************/
NTSTATUS
VfatSetExtendedAttributes(PFILE_OBJECT FileObject,
VfatSetExtendedAttributes(
PFILE_OBJECT FileObject,
PVOID Ea,
ULONG EaLength)
{
@ -40,5 +40,5 @@ VfatSetExtendedAttributes(PFILE_OBJECT FileObject,
UNREFERENCED_PARAMETER(Ea);
UNREFERENCED_PARAMETER(EaLength);
return(STATUS_EAS_NOT_SUPPORTED);
return STATUS_EAS_NOT_SUPPORTED;
}

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

@ -19,14 +19,15 @@
/* FUNCTIONS ****************************************************************/
NTSTATUS
FAT32GetNextCluster(PDEVICE_EXTENSION DeviceExt,
ULONG CurrentCluster,
PULONG NextCluster)
/*
* FUNCTION: Retrieve the next FAT32 cluster from the FAT table via a physical
* disk read
*/
NTSTATUS
FAT32GetNextCluster(
PDEVICE_EXTENSION DeviceExt,
ULONG CurrentCluster,
PULONG NextCluster)
{
PVOID BaseAddress;
ULONG FATOffset;
@ -41,21 +42,24 @@ FAT32GetNextCluster(PDEVICE_EXTENSION DeviceExt,
{
return STATUS_UNSUCCESSFUL;
}
CurrentCluster = (*(PULONG)((char*)BaseAddress + (FATOffset % ChunkSize))) & 0x0fffffff;
if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff)
CurrentCluster = 0xffffffff;
CcUnpinData(Context);
*NextCluster = CurrentCluster;
return (STATUS_SUCCESS);
return STATUS_SUCCESS;
}
NTSTATUS
FAT16GetNextCluster(PDEVICE_EXTENSION DeviceExt,
ULONG CurrentCluster,
PULONG NextCluster)
/*
* FUNCTION: Retrieve the next FAT16 cluster from the FAT table
*/
NTSTATUS
FAT16GetNextCluster(
PDEVICE_EXTENSION DeviceExt,
ULONG CurrentCluster,
PULONG NextCluster)
{
PVOID BaseAddress;
ULONG FATOffset;
@ -70,21 +74,23 @@ FAT16GetNextCluster(PDEVICE_EXTENSION DeviceExt,
{
return STATUS_UNSUCCESSFUL;
}
CurrentCluster = *((PUSHORT)((char*)BaseAddress + (FATOffset % ChunkSize)));
if (CurrentCluster >= 0xfff8 && CurrentCluster <= 0xffff)
CurrentCluster = 0xffffffff;
CcUnpinData(Context);
*NextCluster = CurrentCluster;
return (STATUS_SUCCESS);
return STATUS_SUCCESS;
}
NTSTATUS
FAT12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
ULONG CurrentCluster,
PULONG NextCluster)
/*
* FUNCTION: Retrieve the next FAT12 cluster from the FAT table
*/
NTSTATUS
FAT12GetNextCluster(
PDEVICE_EXTENSION DeviceExt,
ULONG CurrentCluster,
PULONG NextCluster)
{
PUSHORT CBlock;
ULONG Entry;
@ -92,7 +98,6 @@ FAT12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
PVOID Context;
LARGE_INTEGER Offset;
*NextCluster = 0;
Offset.QuadPart = 0;
@ -100,6 +105,7 @@ FAT12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
{
return STATUS_UNSUCCESSFUL;
}
CBlock = (PUSHORT)((char*)BaseAddress + (CurrentCluster * 12) / 8);
if ((CurrentCluster % 2) == 0)
{
@ -109,9 +115,11 @@ FAT12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
{
Entry = *CBlock >> 4;
}
// DPRINT("Entry %x\n",Entry);
if (Entry >= 0xff8 && Entry <= 0xfff)
Entry = 0xffffffff;
// DPRINT("Returning %x\n",Entry);
*NextCluster = Entry;
CcUnpinData(Context);
@ -119,12 +127,13 @@ FAT12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
return STATUS_SUCCESS;
}
NTSTATUS
FAT16FindAndMarkAvailableCluster(PDEVICE_EXTENSION DeviceExt,
PULONG Cluster)
/*
* FUNCTION: Finds the first available cluster in a FAT16 table
*/
NTSTATUS
FAT16FindAndMarkAvailableCluster(
PDEVICE_EXTENSION DeviceExt,
PULONG Cluster)
{
ULONG FatLength;
ULONG StartCluster;
@ -151,6 +160,7 @@ FAT16FindAndMarkAvailableCluster(PDEVICE_EXTENSION DeviceExt,
DPRINT1("CcMapData(Offset %x, Length %u) failed\n", (ULONG)Offset.QuadPart, ChunkSize);
return STATUS_UNSUCCESSFUL;
}
Block = (PUSHORT)((ULONG_PTR)BaseAddress + (i * 2) % ChunkSize);
BlockEnd = (PUSHORT)((ULONG_PTR)BaseAddress + ChunkSize);
@ -166,7 +176,7 @@ FAT16FindAndMarkAvailableCluster(PDEVICE_EXTENSION DeviceExt,
CcUnpinData(Context);
if (DeviceExt->AvailableClustersValid)
InterlockedDecrement((PLONG)&DeviceExt->AvailableClusters);
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
Block++;
@ -175,10 +185,12 @@ FAT16FindAndMarkAvailableCluster(PDEVICE_EXTENSION DeviceExt,
CcUnpinData(Context);
}
FatLength = StartCluster;
StartCluster = 2;
}
return(STATUS_DISK_FULL);
return STATUS_DISK_FULL;
}
NTSTATUS

157
reactos/drivers/filesystems/fastfat/finfo.c
View file

@ -63,15 +63,16 @@ const char* FileInformationClassNames[] =
/* FUNCTIONS ****************************************************************/
static NTSTATUS
VfatGetStandardInformation(PVFATFCB FCB,
PFILE_STANDARD_INFORMATION StandardInfo,
PULONG BufferLength)
/*
* FUNCTION: Retrieve the standard file information
*/
static
NTSTATUS
VfatGetStandardInformation(
PVFATFCB FCB,
PFILE_STANDARD_INFORMATION StandardInfo,
PULONG BufferLength)
{
if (*BufferLength < sizeof(FILE_STANDARD_INFORMATION))
return STATUS_BUFFER_OVERFLOW;
@ -95,11 +96,13 @@ VfatGetStandardInformation(PVFATFCB FCB,
StandardInfo->DeletePending = FCB->Flags & FCB_DELETE_PENDING ? TRUE : FALSE;
*BufferLength -= sizeof(FILE_STANDARD_INFORMATION);
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
static NTSTATUS
VfatSetPositionInformation(PFILE_OBJECT FileObject,
static
NTSTATUS
VfatSetPositionInformation(
PFILE_OBJECT FileObject,
PFILE_POSITION_INFORMATION PositionInfo)
{
DPRINT("FsdSetPositionInformation()\n");
@ -110,11 +113,13 @@ VfatSetPositionInformation(PFILE_OBJECT FileObject,
FileObject->CurrentByteOffset.QuadPart =
PositionInfo->CurrentByteOffset.QuadPart;
return (STATUS_SUCCESS);
return STATUS_SUCCESS;
}
static NTSTATUS
VfatGetPositionInformation(PFILE_OBJECT FileObject,
static
NTSTATUS
VfatGetPositionInformation(
PFILE_OBJECT FileObject,
PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject,
PFILE_POSITION_INFORMATION PositionInfo,
@ -136,11 +141,13 @@ VfatGetPositionInformation(PFILE_OBJECT FileObject,
PositionInfo->CurrentByteOffset.QuadPart);
*BufferLength -= sizeof(FILE_POSITION_INFORMATION);
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
static NTSTATUS
VfatSetBasicInformation(PFILE_OBJECT FileObject,
static
NTSTATUS
VfatSetBasicInformation(
PFILE_OBJECT FileObject,
PVFATFCB FCB,
PDEVICE_EXTENSION DeviceExt,
PFILE_BASIC_INFORMATION BasicInfo)
@ -221,11 +228,13 @@ VfatSetBasicInformation(PFILE_OBJECT FileObject,
VfatUpdateEntry(FCB);
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
static NTSTATUS
VfatGetBasicInformation(PFILE_OBJECT FileObject,
static
NTSTATUS
VfatGetBasicInformation(
PFILE_OBJECT FileObject,
PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject,
PFILE_BASIC_INFORMATION BasicInfo,
@ -289,12 +298,14 @@ VfatGetBasicInformation(PFILE_OBJECT FileObject,
DPRINT("Getting attributes 0x%02x\n", BasicInfo->FileAttributes);
*BufferLength -= sizeof(FILE_BASIC_INFORMATION);
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
static NTSTATUS
VfatSetDispositionInformation(PFILE_OBJECT FileObject,
static
NTSTATUS
VfatSetDispositionInformation(
PFILE_OBJECT FileObject,
PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject,
PFILE_DISPOSITION_INFORMATION DispositionInfo)
@ -360,15 +371,17 @@ VfatSetDispositionInformation(PFILE_OBJECT FileObject,
return STATUS_SUCCESS;
}
static NTSTATUS
VfatGetNameInformation(PFILE_OBJECT FileObject,
/*
* FUNCTION: Retrieve the file name information
*/
static
NTSTATUS
VfatGetNameInformation(
PFILE_OBJECT FileObject,
PVFATFCB FCB,
PDEVICE_OBJECT DeviceObject,
PFILE_NAME_INFORMATION NameInfo,
PULONG BufferLength)
/*
* FUNCTION: Retrieve the file name information
*/
{
ULONG BytesToCopy;
@ -406,8 +419,10 @@ VfatGetNameInformation(PFILE_OBJECT FileObject,
return STATUS_SUCCESS;
}
static NTSTATUS
VfatGetInternalInformation(PVFATFCB Fcb,
static
NTSTATUS
VfatGetInternalInformation(
PVFATFCB Fcb,
PFILE_INTERNAL_INFORMATION InternalInfo,
PULONG BufferLength)
{
@ -423,14 +438,16 @@ VfatGetInternalInformation(PVFATFCB Fcb,
}
static NTSTATUS
VfatGetNetworkOpenInformation(PVFATFCB Fcb,
PDEVICE_EXTENSION DeviceExt,
PFILE_NETWORK_OPEN_INFORMATION NetworkInfo,
PULONG BufferLength)
/*
* FUNCTION: Retrieve the file network open information
*/
static
NTSTATUS
VfatGetNetworkOpenInformation(
PVFATFCB Fcb,
PDEVICE_EXTENSION DeviceExt,
PFILE_NETWORK_OPEN_INFORMATION NetworkInfo,
PULONG BufferLength)
{
ASSERT(NetworkInfo);
ASSERT(Fcb);
@ -470,6 +487,7 @@ VfatGetNetworkOpenInformation(PVFATFCB Fcb,
&NetworkInfo->LastWriteTime);
NetworkInfo->ChangeTime.QuadPart = NetworkInfo->LastWriteTime.QuadPart;
}
if (vfatFCBIsDirectory(Fcb))
{
NetworkInfo->EndOfFile.QuadPart = 0L;
@ -480,6 +498,7 @@ VfatGetNetworkOpenInformation(PVFATFCB Fcb,
NetworkInfo->AllocationSize = Fcb->RFCB.AllocationSize;
NetworkInfo->EndOfFile = Fcb->RFCB.FileSize;
}
NetworkInfo->FileAttributes = *Fcb->Attributes & 0x3f;
/* Synthesize FILE_ATTRIBUTE_NORMAL */
if (0 == (NetworkInfo->FileAttributes & (FILE_ATTRIBUTE_DIRECTORY |
@ -497,8 +516,10 @@ VfatGetNetworkOpenInformation(PVFATFCB Fcb,
}
static NTSTATUS
VfatGetEaInformation(PFILE_OBJECT FileObject,
static
NTSTATUS
VfatGetEaInformation(
PFILE_OBJECT FileObject,
PVFATFCB Fcb,
PDEVICE_OBJECT DeviceObject,
PFILE_EA_INFORMATION Info,
@ -522,15 +543,17 @@ VfatGetEaInformation(PFILE_OBJECT FileObject,
}
static NTSTATUS
VfatGetAllInformation(PFILE_OBJECT FileObject,
/*
* FUNCTION: Retrieve the all file information
*/
static
NTSTATUS
VfatGetAllInformation(
PFILE_OBJECT FileObject,
PVFATFCB Fcb,
PDEVICE_OBJECT DeviceObject,
PFILE_ALL_INFORMATION Info,
PULONG BufferLength)
/*
* FUNCTION: Retrieve the all file information
*/
{
NTSTATUS Status;
ULONG InitialBufferLength = *BufferLength;
@ -567,7 +590,13 @@ VfatGetAllInformation(PFILE_OBJECT FileObject,
return STATUS_SUCCESS;
}
static VOID UpdateFileSize(PFILE_OBJECT FileObject, PVFATFCB Fcb, ULONG Size, ULONG ClusterSize)
static
VOID
UpdateFileSize(
PFILE_OBJECT FileObject,
PVFATFCB Fcb,
ULONG Size,
ULONG ClusterSize)
{
if (Size > 0)
{
@ -591,7 +620,8 @@ static VOID UpdateFileSize(PFILE_OBJECT FileObject, PVFATFCB Fcb, ULONG Size, UL
}
NTSTATUS
VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
VfatSetAllocationSizeInformation(
PFILE_OBJECT FileObject,
PVFATFCB Fcb,
PDEVICE_EXTENSION DeviceExt,
PLARGE_INTEGER AllocationSize)
@ -605,20 +635,22 @@ VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
ULONG NCluster;
BOOLEAN AllocSizeChanged = FALSE;
DPRINT("VfatSetAllocationSizeInformation(File <%wZ>, AllocationSize %d %u)\n", &Fcb->PathNameU,
AllocationSize->HighPart, AllocationSize->LowPart);
DPRINT("VfatSetAllocationSizeInformation(File <%wZ>, AllocationSize %d %u)\n",
&Fcb->PathNameU, AllocationSize->HighPart, AllocationSize->LowPart);
if (Fcb->Flags & FCB_IS_FATX_ENTRY)
OldSize = Fcb->entry.FatX.FileSize;
else
OldSize = Fcb->entry.Fat.FileSize;
if (AllocationSize->u.HighPart > 0)
{
return STATUS_INVALID_PARAMETER;
}
if (OldSize == NewSize)
{
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
FirstCluster = vfatDirEntryGetFirstCluster(DeviceExt, &Fcb->entry);
@ -635,10 +667,12 @@ VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
DPRINT1("NextCluster failed. Status = %x\n", Status);
return Status;
}
if (FirstCluster == 0xffffffff)
{
return STATUS_DISK_FULL;
}
Status = OffsetToCluster(DeviceExt, FirstCluster,
ROUND_DOWN(NewSize - 1, ClusterSize),
&NCluster, TRUE);
@ -655,6 +689,7 @@ VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
}
return STATUS_DISK_FULL;
}
if (Fcb->Flags & FCB_IS_FATX_ENTRY)
{
Fcb->entry.FatX.FirstCluster = FirstCluster;
@ -695,6 +730,7 @@ VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
Fcb->RFCB.AllocationSize.u.LowPart - ClusterSize,
&Cluster, FALSE);
}
if (!NT_SUCCESS(Status))
{
return Status;
@ -728,10 +764,8 @@ VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
}
else if (NewSize + ClusterSize <= Fcb->RFCB.AllocationSize.u.LowPart)
{
DPRINT("Check for the ability to set file size\n");
if (!MmCanFileBeTruncated
(FileObject->SectionObjectPointer,
if (!MmCanFileBeTruncated(FileObject->SectionObjectPointer,
(PLARGE_INTEGER)AllocationSize))
{
DPRINT("Couldn't set file size!\n");
@ -776,6 +810,7 @@ VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
NCluster = Cluster = FirstCluster;
Status = STATUS_SUCCESS;
}
while (NT_SUCCESS(Status) && 0xffffffff != Cluster && Cluster > 1)
{
Status = NextCluster(DeviceExt, FirstCluster, &NCluster, FALSE);
@ -787,6 +822,7 @@ VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
{
UpdateFileSize(FileObject, Fcb, NewSize, ClusterSize);
}
/* Update the on-disk directory entry */
Fcb->Flags |= FCB_IS_DIRTY;
if (AllocSizeChanged)
@ -796,10 +832,12 @@ VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
return STATUS_SUCCESS;
}
NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
/*
* FUNCTION: Retrieve the specified file information
*/
NTSTATUS
VfatQueryInformation(
PVFAT_IRP_CONTEXT IrpContext)
{
FILE_INFORMATION_CLASS FileInformationClass;
PVFATFCB FCB = NULL;
@ -831,7 +869,6 @@ NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
}
}
switch (FileInformationClass)
{
case FileStandardInformation:
@ -839,6 +876,7 @@ NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
SystemBuffer,
&BufferLength);
break;
case FilePositionInformation:
Status = VfatGetPositionInformation(IrpContext->FileObject,
FCB,
@ -846,6 +884,7 @@ NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
SystemBuffer,
&BufferLength);
break;
case FileBasicInformation:
Status = VfatGetBasicInformation(IrpContext->FileObject,
FCB,
@ -853,6 +892,7 @@ NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
SystemBuffer,
&BufferLength);
break;
case FileNameInformation:
Status = VfatGetNameInformation(IrpContext->FileObject,
FCB,
@ -860,17 +900,20 @@ NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
SystemBuffer,
&BufferLength);
break;
case FileInternalInformation:
Status = VfatGetInternalInformation(FCB,
SystemBuffer,
&BufferLength);
break;
case FileNetworkOpenInformation:
Status = VfatGetNetworkOpenInformation(FCB,
IrpContext->DeviceExt,
SystemBuffer,
&BufferLength);
break;
case FileAllInformation:
Status = VfatGetAllInformation(IrpContext->FileObject,
FCB,
@ -890,6 +933,7 @@ NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
case FileAlternateNameInformation:
Status = STATUS_NOT_IMPLEMENTED;
break;
default:
Status = STATUS_INVALID_PARAMETER;
}
@ -898,6 +942,7 @@ NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
{
ExReleaseResourceLite(&FCB->MainResource);
}
IrpContext->Irp->IoStatus.Status = Status;
if (NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW)
IrpContext->Irp->IoStatus.Information =
@ -910,10 +955,12 @@ NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
return Status;
}
NTSTATUS VfatSetInformation(PVFAT_IRP_CONTEXT IrpContext)
/*
* FUNCTION: Retrieve the specified file information
*/
NTSTATUS
VfatSetInformation(
PVFAT_IRP_CONTEXT IrpContext)
{
FILE_INFORMATION_CLASS FileInformationClass;
PVFATFCB FCB = NULL;
@ -944,8 +991,7 @@ NTSTATUS VfatSetInformation(PVFAT_IRP_CONTEXT IrpContext)
if (FileInformationClass == FileEndOfFileInformation)
{
DPRINT("Check for the ability to set file size\n");
if (!MmCanFileBeTruncated
(IrpContext->FileObject->SectionObjectPointer,
if (!MmCanFileBeTruncated(IrpContext->FileObject->SectionObjectPointer,
(PLARGE_INTEGER)SystemBuffer))
{
DPRINT("Couldn't set file size!\n");
@ -963,7 +1009,7 @@ NTSTATUS VfatSetInformation(PVFAT_IRP_CONTEXT IrpContext)
if (!ExAcquireResourceExclusiveLite(&FCB->MainResource,
(BOOLEAN)CanWait))
{
return(VfatQueueRequest (IrpContext));
return VfatQueueRequest(IrpContext);
}
}
@ -973,12 +1019,14 @@ NTSTATUS VfatSetInformation(PVFAT_IRP_CONTEXT IrpContext)
RC = VfatSetPositionInformation(IrpContext->FileObject,
SystemBuffer);
break;
case FileDispositionInformation:
RC = VfatSetDispositionInformation(IrpContext->FileObject,
FCB,
IrpContext->DeviceObject,
SystemBuffer);
break;
case FileAllocationInformation:
case FileEndOfFileInformation:
RC = VfatSetAllocationSizeInformation(IrpContext->FileObject,
@ -986,15 +1034,18 @@ NTSTATUS VfatSetInformation(PVFAT_IRP_CONTEXT IrpContext)
IrpContext->DeviceExt,
(PLARGE_INTEGER)SystemBuffer);
break;
case FileBasicInformation:
RC = VfatSetBasicInformation(IrpContext->FileObject,
FCB,
IrpContext->DeviceExt,
SystemBuffer);
break;
case FileRenameInformation:
RC = STATUS_NOT_IMPLEMENTED;
break;
default:
RC = STATUS_NOT_SUPPORTED;
}

24
reactos/drivers/filesystems/fastfat/flush.c
View file

@ -13,7 +13,11 @@
/* FUNCTIONS ****************************************************************/
static NTSTATUS VfatFlushFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb)
static
NTSTATUS
VfatFlushFile(
PDEVICE_EXTENSION DeviceExt,
PVFATFCB Fcb)
{
IO_STATUS_BLOCK IoStatus;
NTSTATUS Status;
@ -26,6 +30,7 @@ static NTSTATUS VfatFlushFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb)
/* FIXME: Caching was possible not initialized */
IoStatus.Status = STATUS_SUCCESS;
}
if (Fcb->Flags & FCB_IS_DIRTY)
{
Status = VfatUpdateEntry(Fcb);
@ -37,7 +42,10 @@ static NTSTATUS VfatFlushFile(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb)
return IoStatus.Status;
}
NTSTATUS VfatFlushVolume(PDEVICE_EXTENSION DeviceExt, PVFATFCB VolumeFcb)
NTSTATUS
VfatFlushVolume(
PDEVICE_EXTENSION DeviceExt,
PVFATFCB VolumeFcb)
{
PLIST_ENTRY ListEntry;
PVFATFCB Fcb;
@ -63,6 +71,7 @@ NTSTATUS VfatFlushVolume(PDEVICE_EXTENSION DeviceExt, PVFATFCB VolumeFcb)
}
/* FIXME: Stop flushing if this is a removable media and the media was removed */
}
ListEntry = DeviceExt->FcbListHead.Flink;
while (ListEntry != &DeviceExt->FcbListHead)
{
@ -99,13 +108,14 @@ NTSTATUS VfatFlushVolume(PDEVICE_EXTENSION DeviceExt, PVFATFCB VolumeFcb)
return ReturnStatus;
}
NTSTATUS VfatFlush(PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS
VfatFlush(
PVFAT_IRP_CONTEXT IrpContext)
{
NTSTATUS Status;
PVFATFCB Fcb;
/*
* This request is not allowed on the main device object.
*/
/* This request is not allowed on the main device object. */
if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
{
Status = STATUS_INVALID_DEVICE_REQUEST;
@ -134,7 +144,7 @@ ByeBye:
IoCompleteRequest (IrpContext->Irp, IO_NO_INCREMENT);
VfatFreeIrpContext(IrpContext);
return (Status);
return Status;
}
/* EOF */

12
reactos/drivers/filesystems/fastfat/fsctl.c
View file

@ -33,8 +33,10 @@
#define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGE_SIZE ? \
(pDeviceExt)->FatInfo.BytesPerCluster : PAGE_SIZE)
static NTSTATUS
VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount,
static
NTSTATUS
VfatHasFileSystem(
PDEVICE_OBJECT DeviceToMount,
PBOOLEAN RecognizedFS,
PFATINFO pFatInfo)
{
@ -66,6 +68,7 @@ VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount,
DPRINT("VfatBlockDeviceIoControl faild (%x)\n", Status);
return Status;
}
FatInfo.FixedMedia = DiskGeometry.MediaType == FixedMedia ? TRUE : FALSE;
if (DiskGeometry.MediaType == FixedMedia || DiskGeometry.MediaType == RemovableMedia)
{
@ -83,6 +86,7 @@ VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount,
DPRINT("VfatBlockDeviceIoControl faild (%x)\n", Status);
return Status;
}
PartitionInfoIsValid = TRUE;
DPRINT("Partition Information:\n");
DPRINT("StartingOffset %I64x\n", PartitionInfo.StartingOffset.QuadPart / 512);
@ -128,9 +132,9 @@ VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount,
{
*RecognizedFS = TRUE;
}
if (*RecognizedFS)
{
Boot = ExAllocatePoolWithTag(NonPagedPool, DiskGeometry.BytesPerSector, TAG_VFAT);
if (Boot == NULL)
{
@ -147,6 +151,7 @@ VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount,
{
*RecognizedFS = FALSE;
}
if (*RecognizedFS &&
Boot->BytesPerSector != 512 &&
Boot->BytesPerSector != 1024 &&
@ -236,6 +241,7 @@ VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount,
FatInfo.FatType = FAT16;
FatInfo.RootCluster = FatInfo.rootStart / FatInfo.SectorsPerCluster;
}
if (PartitionInfoIsValid &&
FatInfo.Sectors > PartitionInfo.PartitionLength.QuadPart / FatInfo.BytesPerSector)
{

22
reactos/drivers/filesystems/fastfat/iface.c
View file

@ -34,9 +34,6 @@ PVFAT_GLOBAL_DATA VfatGlobalData;
/* FUNCTIONS ****************************************************************/
NTSTATUS NTAPI
DriverEntry(PDRIVER_OBJECT DriverObject,
PUNICODE_STRING RegistryPath)
/*
* FUNCTION: Called by the system to initialize the driver
* ARGUMENTS:
@ -44,6 +41,11 @@ DriverEntry(PDRIVER_OBJECT DriverObject,
* RegistryPath = path to our configuration entries
* RETURNS: Success or failure
*/
NTSTATUS
NTAPI
DriverEntry(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath)
{
PDEVICE_OBJECT DeviceObject;
UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Fat");
@ -58,7 +60,6 @@ DriverEntry(PDRIVER_OBJECT DriverObject,
0,
FALSE,
&DeviceObject);
if (Status == STATUS_OBJECT_NAME_EXISTS ||
Status == STATUS_OBJECT_NAME_COLLISION)
{
@ -73,11 +74,9 @@ DriverEntry(PDRIVER_OBJECT DriverObject,
&DeviceObject);
}
if (!NT_SUCCESS(Status))
{
return (Status);
return Status;
}
VfatGlobalData = DeviceObject->DeviceExtension;
@ -94,10 +93,8 @@ DriverEntry(PDRIVER_OBJECT DriverObject,
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =
VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] =
VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = VfatShutdown;
DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = VfatBuildRequest;
@ -127,8 +124,7 @@ DriverEntry(PDRIVER_OBJECT DriverObject,
ExInitializeResourceLite(&VfatGlobalData->VolumeListLock);
InitializeListHead(&VfatGlobalData->VolumeListHead);
IoRegisterFileSystem(DeviceObject);
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
/* EOF */

61
reactos/drivers/filesystems/fastfat/misc.c
View file

@ -47,13 +47,14 @@ const char* MajorFunctionNames[] =
"IRP_MJ_MAXIMUM_FUNCTION"
};
/* FUNCTIONS ****************************************************************/
static LONG QueueCount = 0;
static NTSTATUS VfatLockControl(
IN PVFAT_IRP_CONTEXT IrpContext
)
/* FUNCTIONS ****************************************************************/
static
NTSTATUS
VfatLockControl(
IN PVFAT_IRP_CONTEXT IrpContext)
{
PVFATFCB Fcb;
NTSTATUS Status;
@ -78,21 +79,22 @@ static NTSTATUS VfatLockControl(
Status = FsRtlProcessFileLock(&Fcb->FileLock,
IrpContext->Irp,
NULL
);
NULL);
VfatFreeIrpContext(IrpContext);
return Status;
Fail:;
Fail:
IrpContext->Irp->IoStatus.Status = Status;
IoCompleteRequest(IrpContext->Irp, (CCHAR)(NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT));
VfatFreeIrpContext(IrpContext);
return Status;
}
static NTSTATUS
VfatDispatchRequest (IN PVFAT_IRP_CONTEXT IrpContext)
static
NTSTATUS
VfatDispatchRequest(
IN PVFAT_IRP_CONTEXT IrpContext)
{
DPRINT("VfatDispatchRequest (IrpContext %p), is called for %s\n", IrpContext,
IrpContext->MajorFunction >= IRP_MJ_MAXIMUM_FUNCTION ? "????" : MajorFunctionNames[IrpContext->MajorFunction]);
@ -138,7 +140,9 @@ VfatDispatchRequest (IN PVFAT_IRP_CONTEXT IrpContext)
}
}
NTSTATUS NTAPI VfatBuildRequest (
NTSTATUS
NTAPI
VfatBuildRequest(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
@ -149,6 +153,7 @@ NTSTATUS NTAPI VfatBuildRequest (
ASSERT(DeviceObject);
ASSERT(Irp);
IrpContext = VfatAllocateIrpContext(DeviceObject, Irp);
if (IrpContext == NULL)
{
@ -165,17 +170,23 @@ NTSTATUS NTAPI VfatBuildRequest (
return Status;
}
VOID VfatFreeIrpContext (PVFAT_IRP_CONTEXT IrpContext)
VOID
VfatFreeIrpContext(
PVFAT_IRP_CONTEXT IrpContext)
{
ASSERT(IrpContext);
ExFreeToNPagedLookasideList(&VfatGlobalData->IrpContextLookasideList, IrpContext);
}
PVFAT_IRP_CONTEXT VfatAllocateIrpContext(PDEVICE_OBJECT DeviceObject, PIRP Irp)
PVFAT_IRP_CONTEXT
VfatAllocateIrpContext(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PVFAT_IRP_CONTEXT IrpContext;
/*PIO_STACK_LOCATION Stack;*/
UCHAR MajorFunction;
DPRINT("VfatAllocateIrpContext(DeviceObject %p, Irp %p)\n", DeviceObject, Irp);
ASSERT(DeviceObject);
@ -214,17 +225,23 @@ PVFAT_IRP_CONTEXT VfatAllocateIrpContext(PDEVICE_OBJECT DeviceObject, PIRP Irp)
static WORKER_THREAD_ROUTINE VfatDoRequest;
static VOID NTAPI VfatDoRequest (PVOID IrpContext)
static
VOID
NTAPI
VfatDoRequest(
PVOID IrpContext)
{
InterlockedDecrement(&QueueCount);
DPRINT ("VfatDoRequest (IrpContext %p), MajorFunction %x, %d\n", IrpContext, ((PVFAT_IRP_CONTEXT)IrpContext)->MajorFunction, QueueCount);
DPRINT("VfatDoRequest(IrpContext %p), MajorFunction %x, %d\n",
IrpContext, ((PVFAT_IRP_CONTEXT)IrpContext)->MajorFunction, QueueCount);
FsRtlEnterFileSystem();
VfatDispatchRequest((PVFAT_IRP_CONTEXT)IrpContext);
FsRtlExitFileSystem();
}
NTSTATUS VfatQueueRequest(PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS
VfatQueueRequest(
PVFAT_IRP_CONTEXT IrpContext)
{
InterlockedIncrement(&QueueCount);
DPRINT("VfatQueueRequest(IrpContext %p), %d\n", IrpContext, QueueCount);
@ -239,7 +256,9 @@ NTSTATUS VfatQueueRequest(PVFAT_IRP_CONTEXT IrpContext)
return STATUS_PENDING;
}
PVOID VfatGetUserBuffer(IN PIRP Irp)
PVOID
VfatGetUserBuffer(
IN PIRP Irp)
{
ASSERT(Irp);
@ -255,7 +274,11 @@ PVOID VfatGetUserBuffer(IN PIRP Irp)
}
}
NTSTATUS VfatLockUserBuffer(IN PIRP Irp, IN ULONG Length, IN LOCK_OPERATION Operation)
NTSTATUS
VfatLockUserBuffer(
IN PIRP Irp,
IN ULONG Length,
IN LOCK_OPERATION Operation)
{
ASSERT(Irp);

5
reactos/drivers/filesystems/fastfat/pnp.c
View file

@ -14,7 +14,9 @@
/* FUNCTIONS ****************************************************************/
NTSTATUS VfatPnp(PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS
VfatPnp(
PVFAT_IRP_CONTEXT IrpContext)
{
PVCB Vcb = NULL;
NTSTATUS Status;
@ -32,6 +34,7 @@ NTSTATUS VfatPnp(PVFAT_IRP_CONTEXT IrpContext)
IrpContext->Irp->IoStatus.Status = Status;
IoCompleteRequest(IrpContext->Irp, IO_NO_INCREMENT);
break;
default:
IoSkipCurrentIrpStackLocation(IrpContext->Irp);
Vcb = (PVCB)IrpContext->Stack->DeviceObject->DeviceExtension;

115
reactos/drivers/filesystems/fastfat/rw.c
View file

@ -23,20 +23,21 @@
/* FUNCTIONS *****************************************************************/
NTSTATUS
NextCluster(PDEVICE_EXTENSION DeviceExt,
ULONG FirstCluster,
PULONG CurrentCluster,
BOOLEAN Extend)
/*
* Return the next cluster in a FAT chain, possibly extending the chain if
* necessary
*/
NTSTATUS
NextCluster(
PDEVICE_EXTENSION DeviceExt,
ULONG FirstCluster,
PULONG CurrentCluster,
BOOLEAN Extend)
{
if (FirstCluster == 1)
{
(*CurrentCluster) += DeviceExt->FatInfo.SectorsPerCluster;
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
else
{
@ -48,15 +49,12 @@ NextCluster(PDEVICE_EXTENSION DeviceExt,
}
NTSTATUS
OffsetToCluster(PDEVICE_EXTENSION DeviceExt,
OffsetToCluster(
PDEVICE_EXTENSION DeviceExt,
ULONG FirstCluster,
ULONG FileOffset,
PULONG Cluster,
BOOLEAN Extend)
/*
* Return the cluster corresponding to an offset within a file,
* possibly extending the file if necessary
*/
{
ULONG CurrentCluster;
ULONG i;
@ -77,7 +75,7 @@ OffsetToCluster(PDEVICE_EXTENSION DeviceExt,
/* root of FAT16 or FAT12 */
*Cluster = DeviceExt->FatInfo.rootStart + FileOffset
/ (DeviceExt->FatInfo.BytesPerCluster) * DeviceExt->FatInfo.SectorsPerCluster;
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
else
{
@ -88,7 +86,7 @@ OffsetToCluster(PDEVICE_EXTENSION DeviceExt,
{
Status = GetNextClusterExtend (DeviceExt, CurrentCluster, &CurrentCluster);
if (!NT_SUCCESS(Status))
return(Status);
return Status;
}
*Cluster = CurrentCluster;
}
@ -98,22 +96,24 @@ OffsetToCluster(PDEVICE_EXTENSION DeviceExt,
{
Status = GetNextCluster (DeviceExt, CurrentCluster, &CurrentCluster);
if (!NT_SUCCESS(Status))
return(Status);
return Status;
}
*Cluster = CurrentCluster;
}
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
}
}
static NTSTATUS
VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
ULONG Length,
LARGE_INTEGER ReadOffset,
PULONG LengthRead)
/*
* FUNCTION: Reads data from a file
*/
static
NTSTATUS
VfatReadFileData(
PVFAT_IRP_CONTEXT IrpContext,
ULONG Length,
LARGE_INTEGER ReadOffset,
PULONG LengthRead)
{
ULONG CurrentCluster;
ULONG FirstCluster;
@ -168,6 +168,7 @@ VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
}
return Status;
}
/* Is this a read of the Volume ? */
if (Fcb->Flags & FCB_IS_VOLUME)
{
@ -183,23 +184,20 @@ VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
return Status;
}
/*
* Find the first cluster
*/
FirstCluster = CurrentCluster =
vfatDirEntryGetFirstCluster (DeviceExt, &Fcb->entry);
/* Find the first cluster */
FirstCluster =
CurrentCluster = vfatDirEntryGetFirstCluster (DeviceExt, &Fcb->entry);
if (FirstCluster == 1)
{
// Directory of FAT12/16 needs a special handling
/* Directory of FAT12/16 needs a special handling */
if (ReadOffset.u.LowPart + Length > DeviceExt->FatInfo.rootDirectorySectors * BytesPerSector)
{
Length = DeviceExt->FatInfo.rootDirectorySectors * BytesPerSector - ReadOffset.u.LowPart;
}
ReadOffset.u.LowPart += DeviceExt->FatInfo.rootStart * BytesPerSector;
// Fire up the read command
/* Fire up the read command */
Status = VfatReadDiskPartial (IrpContext, &ReadOffset, Length, 0, TRUE);
if (NT_SUCCESS(Status))
{
@ -213,9 +211,7 @@ VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
LastOffset = Fcb->LastOffset;
ExReleaseFastMutex(&Fcb->LastMutex);
/*
* Find the cluster to start the read from
*/
/* Find the cluster to start the read from */
if (LastCluster > 0 && ReadOffset.u.LowPart >= LastOffset)
{
Status = OffsetToCluster(DeviceExt, LastCluster,
@ -240,9 +236,10 @@ VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
ROUND_DOWN(ReadOffset.u.LowPart, BytesPerCluster),
&CurrentCluster, FALSE);
}
if (!NT_SUCCESS(Status))
{
return(Status);
return Status;
}
ExAcquireFastMutex(&Fcb->LastMutex);
@ -291,7 +288,7 @@ VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
Fcb->LastOffset = ROUND_DOWN(ReadOffset.u.LowPart, BytesPerCluster) + (ClusterCount - 1) * BytesPerCluster;
ExReleaseFastMutex(&Fcb->LastMutex);
// Fire up the read command
/* Fire up the read command */
Status = VfatReadDiskPartial (IrpContext, &StartOffset, BytesDone, *LengthRead, FALSE);
if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
{
@ -301,10 +298,12 @@ VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
Length -= BytesDone;
ReadOffset.u.LowPart += BytesDone;
}
if (0 != InterlockedDecrement((PLONG)&IrpContext->RefCount))
if (InterlockedDecrement((PLONG)&IrpContext->RefCount) != 0)
{
KeWaitForSingleObject(&IrpContext->Event, Executive, KernelMode, FALSE, NULL);
}
if (NT_SUCCESS(Status) || Status == STATUS_PENDING)
{
if (Length > 0)
@ -316,11 +315,14 @@ VfatReadFileData (PVFAT_IRP_CONTEXT IrpContext,
Status = IrpContext->Irp->IoStatus.Status;
}
}
return Status;
}
static NTSTATUS
VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
static
NTSTATUS
VfatWriteFileData(
PVFAT_IRP_CONTEXT IrpContext,
ULONG Length,
LARGE_INTEGER WriteOffset)
{
@ -362,7 +364,7 @@ VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
ASSERT(WriteOffset.u.LowPart % BytesPerSector == 0);
ASSERT(Length % BytesPerSector == 0);
// Is this a write of the volume ?
/* Is this a write of the volume? */
if (Fcb->Flags & FCB_IS_VOLUME)
{
Status = VfatWriteDiskPartial(IrpContext, &WriteOffset, Length, 0, TRUE);
@ -373,7 +375,7 @@ VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
return Status;
}
// Is this a write to the FAT ?
/* Is this a write to the FAT? */
if (Fcb->Flags & FCB_IS_FAT)
{
WriteOffset.u.LowPart += DeviceExt->FatInfo.FATStart * BytesPerSector;
@ -388,10 +390,12 @@ VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
}
WriteOffset.u.LowPart += Fcb->RFCB.FileSize.u.LowPart;
}
if (0 != InterlockedDecrement((PLONG)&IrpContext->RefCount))
if (InterlockedDecrement((PLONG)&IrpContext->RefCount) != 0)
{
KeWaitForSingleObject(&IrpContext->Event, Executive, KernelMode, FALSE, NULL);
}
if (NT_SUCCESS(Status) || Status == STATUS_PENDING)
{
Status = IrpContext->Irp->IoStatus.Status;
@ -402,8 +406,8 @@ VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
/*
* Find the first cluster
*/
FirstCluster = CurrentCluster =
vfatDirEntryGetFirstCluster (DeviceExt, &Fcb->entry);
FirstCluster =
CurrentCluster = vfatDirEntryGetFirstCluster (DeviceExt, &Fcb->entry);
if (FirstCluster == 1)
{
@ -450,7 +454,7 @@ VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
if (!NT_SUCCESS(Status))
{
return(Status);
return Status;
}
ExAcquireFastMutex(&Fcb->LastMutex);
@ -509,10 +513,12 @@ VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
Length -= BytesDone;
WriteOffset.u.LowPart += BytesDone;
}
if (0 != InterlockedDecrement((PLONG)&IrpContext->RefCount))
if (InterlockedDecrement((PLONG)&IrpContext->RefCount) != 0)
{
KeWaitForSingleObject(&IrpContext->Event, Executive, KernelMode, FALSE, NULL);
}
if (NT_SUCCESS(Status) || Status == STATUS_PENDING)
{
if (Length > 0)
@ -528,7 +534,8 @@ VfatWriteFileData(PVFAT_IRP_CONTEXT IrpContext,
}
NTSTATUS
VfatRead(PVFAT_IRP_CONTEXT IrpContext)
VfatRead(
PVFAT_IRP_CONTEXT IrpContext)
{
NTSTATUS Status;
PVFATFCB Fcb;
@ -582,7 +589,6 @@ VfatRead(PVFAT_IRP_CONTEXT IrpContext)
goto ByeBye;
}
DPRINT("'%wZ', Offset: %u, Length %u\n", &Fcb->PathNameU, ByteOffset.u.LowPart, Length);
if (ByteOffset.u.HighPart && !(Fcb->Flags & FCB_IS_VOLUME))
@ -590,12 +596,14 @@ VfatRead(PVFAT_IRP_CONTEXT IrpContext)
Status = STATUS_INVALID_PARAMETER;
goto ByeBye;
}
if (ByteOffset.QuadPart >= Fcb->RFCB.FileSize.QuadPart)
{
IrpContext->Irp->IoStatus.Information = 0;
Status = STATUS_END_OF_FILE;
goto ByeBye;
}
if (IrpContext->Irp->Flags & (IRP_PAGING_IO | IRP_NOCACHE) || (Fcb->Flags & FCB_IS_VOLUME))
{
if (ByteOffset.u.LowPart % BytesPerSector != 0 || Length % BytesPerSector != 0)
@ -606,6 +614,7 @@ VfatRead(PVFAT_IRP_CONTEXT IrpContext)
goto ByeBye;
}
}
if (Length == 0)
{
IrpContext->Irp->IoStatus.Information = 0;
@ -625,6 +634,7 @@ VfatRead(PVFAT_IRP_CONTEXT IrpContext)
{
Resource = &Fcb->MainResource;
}
if (!ExAcquireResourceSharedLite(Resource,
IrpContext->Flags & IRPCONTEXT_CANWAIT ? TRUE : FALSE))
{
@ -669,6 +679,7 @@ VfatRead(PVFAT_IRP_CONTEXT IrpContext)
&(VfatGlobalData->CacheMgrCallbacks),
Fcb);
}
if (!CcCopyRead(IrpContext->FileObject, &ByteOffset, Length,
(BOOLEAN)(IrpContext->Flags & IRPCONTEXT_CANWAIT), Buffer,
&IrpContext->Irp->IoStatus))
@ -676,6 +687,7 @@ VfatRead(PVFAT_IRP_CONTEXT IrpContext)
Status = STATUS_PENDING;
goto ByeBye;
}
if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status))
{
Status = IrpContext->Irp->IoStatus.Status;
@ -741,7 +753,9 @@ ByeBye:
return Status;
}
NTSTATUS VfatWrite (PVFAT_IRP_CONTEXT IrpContext)
NTSTATUS
VfatWrite(
PVFAT_IRP_CONTEXT IrpContext)
{
PVFATFCB Fcb;
PERESOURCE Resource = NULL;
@ -807,7 +821,7 @@ NTSTATUS VfatWrite (PVFAT_IRP_CONTEXT IrpContext)
}
if (Fcb->Flags & (FCB_IS_FAT | FCB_IS_VOLUME) ||
1 == vfatDirEntryGetFirstCluster (IrpContext->DeviceExt, &Fcb->entry))
vfatDirEntryGetFirstCluster(IrpContext->DeviceExt, &Fcb->entry) == 1)
{
if (ByteOffset.QuadPart + Length > Fcb->RFCB.FileSize.QuadPart)
{
@ -829,9 +843,7 @@ NTSTATUS VfatWrite (PVFAT_IRP_CONTEXT IrpContext)
if (Length == 0)
{
/* FIXME:
* Update last write time
*/
/* FIXME: Update last write time */
IrpContext->Irp->IoStatus.Information = 0;
Status = STATUS_SUCCESS;
goto ByeBye;
@ -844,6 +856,7 @@ NTSTATUS VfatWrite (PVFAT_IRP_CONTEXT IrpContext)
Status = STATUS_INVALID_PARAMETER;
goto ByeBye;
}
if (ByteOffset.u.LowPart + Length > ROUND_UP(Fcb->RFCB.AllocationSize.u.LowPart, BytesPerSector))
{
Length = ROUND_UP(Fcb->RFCB.FileSize.u.LowPart, BytesPerSector) - ByteOffset.u.LowPart;
@ -940,10 +953,12 @@ NTSTATUS VfatWrite (PVFAT_IRP_CONTEXT IrpContext)
&VfatGlobalData->CacheMgrCallbacks,
Fcb);
}
if (ByteOffset.QuadPart > OldFileSize.QuadPart)
{
CcZeroData(IrpContext->FileObject, &OldFileSize, &ByteOffset, TRUE);
}
if (CcCopyWrite(IrpContext->FileObject, &ByteOffset, Length,
1 /*IrpContext->Flags & IRPCONTEXT_CANWAIT*/, Buffer))
{

19
reactos/drivers/filesystems/fastfat/shutdown.c
View file

@ -13,8 +13,10 @@
/* FUNCTIONS ****************************************************************/
static NTSTATUS
VfatDiskShutDown(PVCB Vcb)
static
NTSTATUS
VfatDiskShutDown(
PVCB Vcb)
{
PIRP Irp;
KEVENT Event;
@ -41,8 +43,12 @@ VfatDiskShutDown(PVCB Vcb)
return Status;
}
NTSTATUS NTAPI
VfatShutdown(PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS
NTAPI
VfatShutdown(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
NTSTATUS Status;
PLIST_ENTRY ListEntry;
@ -77,13 +83,16 @@ VfatShutdown(PDEVICE_OBJECT DeviceObject, PIRP Irp)
DeviceExt->VolumeFcb->Flags &= ~VCB_IS_DIRTY;
}
}
Status = VfatFlushVolume(DeviceExt, DeviceExt->VolumeFcb);
if (NT_SUCCESS(Status))
{
Status = VfatDiskShutDown(DeviceExt);
if (!NT_SUCCESS(Status))
{
DPRINT1("VfatDiskShutDown failed, status = %x\n", Status);
}
}
else
{
DPRINT1("VfatFlushVolume failed, status = %x\n", Status);
@ -112,7 +121,7 @@ VfatShutdown(PDEVICE_OBJECT DeviceObject, PIRP Irp)
FsRtlExitFileSystem();
return(Status);
return Status;
}
/* EOF */

3
reactos/drivers/filesystems/fastfat/string.c
View file

@ -17,7 +17,8 @@
const WCHAR *long_illegals = L"\"*\\<>/?:|";
BOOLEAN
vfatIsLongIllegal(WCHAR c)
vfatIsLongIllegal(
WCHAR c)
{
return wcschr(long_illegals, c) ? TRUE : FALSE;
}

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

@ -341,12 +341,12 @@ FsdSetFsLabelInformation(
}
NTSTATUS
VfatQueryVolumeInformation(
PVFAT_IRP_CONTEXT IrpContext)
/*
* FUNCTION: Retrieve the specified volume information
*/
NTSTATUS
VfatQueryVolumeInformation(
PVFAT_IRP_CONTEXT IrpContext)
{
FS_INFORMATION_CLASS FsInformationClass;
NTSTATUS RC = STATUS_SUCCESS;
@ -416,12 +416,12 @@ VfatQueryVolumeInformation(
}
NTSTATUS
VfatSetVolumeInformation(
PVFAT_IRP_CONTEXT IrpContext)
/*
* FUNCTION: Set the specified volume information
*/
NTSTATUS
VfatSetVolumeInformation(
PVFAT_IRP_CONTEXT IrpContext)
{
FS_INFORMATION_CLASS FsInformationClass;
NTSTATUS Status = STATUS_SUCCESS;