/*
- * $Id: fat.c,v 1.32 2001/10/07 08:58:29 hbirr Exp $
+ * $Id: fat.c,v 1.33 2001/10/10 22:16:46 hbirr Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
*/
{
PVOID BaseAddress;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
NTSTATUS Status;
ULONG FATOffset;
ULONG ChunkSize;
+ PVOID Context;
+ LARGE_INTEGER Offset;
- ChunkSize=CACHEPAGESIZE(DeviceExt);
-
- FATOffset = (DeviceExt->FATStart * BLOCKSIZE) +
- (CurrentCluster * sizeof(ULONG));
-
- Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
- ROUND_DOWN(FATOffset, ChunkSize),
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- ROUND_DOWN(FATOffset, ChunkSize) / BLOCKSIZE,
- ChunkSize / BLOCKSIZE,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
- return(Status);
- }
- }
-
+ ChunkSize = CACHEPAGESIZE(DeviceExt);
+ FATOffset = CurrentCluster * sizeof(ULONG);
+ Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
CurrentCluster = (*(PULONG)(BaseAddress + (FATOffset % ChunkSize))) & 0x0fffffff;
if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff)
CurrentCluster = 0xffffffff;
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcUnpinData(Context);
*NextCluster = CurrentCluster;
return (STATUS_SUCCESS);
}
*/
{
PVOID BaseAddress;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
NTSTATUS Status;
ULONG FATOffset;
ULONG ChunkSize;
+ PVOID Context;
+ LARGE_INTEGER Offset;
ChunkSize = CACHEPAGESIZE(DeviceExt);
-
- FATOffset = (DeviceExt->FATStart * BLOCKSIZE) + (CurrentCluster * 2);
-
- Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
- ROUND_DOWN(FATOffset, ChunkSize),
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- ROUND_DOWN(FATOffset, ChunkSize) / BLOCKSIZE,
- ChunkSize / BLOCKSIZE,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
- return(Status);
- }
- }
-
+ FATOffset = CurrentCluster * 2;
+ Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
CurrentCluster = *((PUSHORT)(BaseAddress + (FATOffset % ChunkSize)));
if (CurrentCluster >= 0xfff8 && CurrentCluster <= 0xffff)
CurrentCluster = 0xffffffff;
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcUnpinData(Context);
*NextCluster = CurrentCluster;
return (STATUS_SUCCESS);
}
PUCHAR CBlock;
ULONG FATOffset;
ULONG Entry;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
NTSTATUS Status;
PVOID BaseAddress;
+ PVOID Context;
+ LARGE_INTEGER Offset;
+
*NextCluster = 0;
- Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
- 0,
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- DeviceExt->FATStart,
- DeviceExt->Boot->FATSectors,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
- return(Status);
- }
- }
+ Offset.QuadPart = 0;
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->Boot->FATSectors * BLOCKSIZE, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
CBlock = (PUCHAR)BaseAddress;
-
+
FATOffset = (CurrentCluster * 12) / 8; /* first byte containing value */
if ((CurrentCluster % 2) == 0)
{
Entry = 0xffffffff;
// DPRINT("Returning %x\n",Entry);
*NextCluster = Entry;
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
+ CcUnpinData(Context);
// return Entry == 0xffffffff ? STATUS_END_OF_FILE : STATUS_SUCCESS;
return STATUS_SUCCESS;
}
ULONG i;
NTSTATUS Status;
PVOID BaseAddress;
- PCACHE_SEGMENT CacheSeg;
- BOOLEAN Valid;
- ULONG FatStart;
ULONG ChunkSize;
-
+ PVOID Context = 0;
+ LARGE_INTEGER Offset;
+
ChunkSize = CACHEPAGESIZE(DeviceExt);
-
- FatStart = DeviceExt->FATStart * BLOCKSIZE;
FatLength = (((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2)*2;
-
- CacheSeg = NULL;
*Cluster = 0;
for (i = 2; i < FatLength; i+=2)
- {
- if (((FatStart + i) % ChunkSize) == 0 || CacheSeg == NULL)
+ {
+ if ((i % ChunkSize) == 0 || Context ==0)
{
- if (CacheSeg != NULL)
- {
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
- }
- Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
- ROUND_DOWN(FatStart + i, ChunkSize),
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- ROUND_DOWN(FatStart + i, ChunkSize)
- / BLOCKSIZE,
- ChunkSize / BLOCKSIZE,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg,
- FALSE);
- return(Status);
- }
- }
+ Offset.QuadPart = ROUND_DOWN(i, ChunkSize);
+ if (Context != NULL)
+ {
+ CcUnpinData(Context);
+ }
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
}
- if (*((PUSHORT)(BaseAddress + ((FatStart + i) % ChunkSize))) == 0)
+
+ if (*((PUSHORT)(BaseAddress + (i % ChunkSize))) == 0)
{
- DPRINT("Found available cluster 0x%x\n", i);
+ DPRINT("Found available cluster 0x%x\n", i / 2);
*Cluster = i / 2;
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcUnpinData(Context);
return(STATUS_SUCCESS);
}
- }
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+
+ }
+ CcUnpinData(Context);
return(STATUS_DISK_FULL);
}
PUCHAR CBlock;
ULONG i;
PVOID BaseAddress;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
NTSTATUS Status;
ULONG numberofclusters;
-
+ PVOID Context;
+ LARGE_INTEGER Offset;
+
*Cluster = 0;
-
- Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
- 0,
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- DeviceExt->FATStart,
- DeviceExt->Boot->FATSectors,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
- return(Status);
- }
- }
+ Offset.QuadPart = 0;
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->Boot->FATSectors * BLOCKSIZE, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
CBlock = (PUCHAR)BaseAddress;
numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2;
{
DPRINT("Found available cluster 0x%x\n", i);
*Cluster = i;
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
+ CcUnpinData(Context);
return(STATUS_SUCCESS);
}
}
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
+ CcUnpinData(Context);
return (STATUS_DISK_FULL);
}
ULONG i;
NTSTATUS Status;
PVOID BaseAddress;
- PCACHE_SEGMENT CacheSeg;
- BOOLEAN Valid;
- ULONG FatStart;
ULONG ChunkSize;
+ PVOID Context = NULL;
+ LARGE_INTEGER Offset;
ChunkSize = CACHEPAGESIZE(DeviceExt);
-
- FatStart = DeviceExt->FATStart * BLOCKSIZE;
FatLength = (((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2)*4;
- CacheSeg = NULL;
*Cluster = 0;
for (i = 4; i < FatLength; i+=4)
- {
- if (((FatStart + i) % ChunkSize) == 0 || CacheSeg == NULL)
+ {
+ if ((i % ChunkSize) == 0 || Context == NULL)
{
- if (CacheSeg != NULL)
- {
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
- }
- Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
- ROUND_DOWN(FatStart + i, ChunkSize),
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- ROUND_DOWN(FatStart + i, ChunkSize) / BLOCKSIZE,
- ChunkSize / BLOCKSIZE,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
- return(Status);
- }
- }
+ Offset.QuadPart = ROUND_DOWN(i, ChunkSize);
+ if (Context != NULL)
+ {
+ CcUnpinData(Context);
+ }
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
}
- if ((*((PULONG)(BaseAddress + ((FatStart + i) % ChunkSize))) & 0x0fffffff) == 0)
+ if ((*((PULONG)(BaseAddress + (/*(FatStart +*/ i/*)*/ % ChunkSize))) & 0x0fffffff) == 0)
{
DPRINT("Found available cluster 0x%x\n", i / 4);
*Cluster = i / 4;
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcUnpinData(Context);
return(STATUS_SUCCESS);
}
- }
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
-#if 0
- ULONG sector;
- PULONG Block;
- int i,forto;
- ULONG numberofclusters;
- NTSTATUS Status;
-
- Block = ExAllocatePool (NonPagedPool, BLOCKSIZE);
- *Cluster = 0;
-
- numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2;
- numberofclusters %= 128;
-
- for (sector = 0;
- sector < ((struct _BootSector32 *) (DeviceExt->Boot))->FATSectors32;
- sector++)
- {
- Status = VfatReadSectors (DeviceExt->StorageDevice,
- (ULONG) (DeviceExt->FATStart + sector), 1,
- (UCHAR *) Block);
-
- if (!NT_SUCCESS(Status))
- {
- ExFreePool (Block);
- return(Status);
- }
-
- if (sector==((struct _BootSector32 *) (DeviceExt->Boot))->FATSectors32-1)
- forto=numberofclusters;
- else
- forto=128;
-
- for (i = 0; i < forto; i++)
- {
- if (Block[i] == 0)
- {
- ExFreePool (Block);
- *Cluster = (i + sector * 128);
- return(STATUS_SUCCESS);
- }
- }
- }
- /* Give an error message (out of disk space) if we reach here) */
- ExFreePool (Block);
-#endif
+ }
+ CcUnpinData(Context);
return (STATUS_DISK_FULL);
}
ULONG ulCount = 0;
ULONG i;
PVOID BaseAddress;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
NTSTATUS Status;
ULONG numberofclusters;
+ LARGE_INTEGER Offset;
+ PVOID Context;
ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE);
- Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
- 0,
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- ExReleaseResourceLite (&DeviceExt->FatResource);
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- DeviceExt->FATStart,
- DeviceExt->Boot->FATSectors,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
- ExReleaseResourceLite (&DeviceExt->FatResource);
- return(Status);
- }
- }
+ Offset.QuadPart = 0;
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->Boot->FATSectors * BLOCKSIZE, 1, &Context, &BaseAddress))
+ {
+ ExReleaseResourceLite (&DeviceExt->FatResource);
+ return STATUS_UNSUCCESSFUL;
+ }
CBlock = (PUCHAR)BaseAddress;
numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2;
-
+
for (i = 2; i < numberofclusters; i++)
{
FATOffset = (i * 12) / 8;
ulCount++;
}
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
+ CcUnpinData(Context);
ExReleaseResourceLite (&DeviceExt->FatResource);
Clusters->QuadPart = ulCount;
ExReleaseResourceLite (&DeviceExt->FatResource);
Clusters->QuadPart = ulCount;
+ ExFreePool(Block);
return(STATUS_SUCCESS);
}
forto=128;
for (i = 0; i < forto; i++)
{
- if (Block[i] & 0x0fffffff == 0)
+ if ((Block[i] & 0x0fffffff) == 0)
ulCount++;
}
}
int i;
NTSTATUS Status;
PVOID BaseAddress;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
-
- Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
- 0,
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- DeviceExt->FATStart,
- DeviceExt->Boot->FATSectors,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
- return(Status);
- }
- }
+ PVOID Context;
+ LARGE_INTEGER Offset;
+
+ Offset.QuadPart = 0;
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->Boot->FATSectors * BLOCKSIZE, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
CBlock = (PUCHAR)BaseAddress;
FATOffset = (ClusterToWrite * 12) / 8;
}
/* Write the changed FAT sector(s) to disk */
FATsector = FATOffset / BLOCKSIZE;
- for (i = 0; i < DeviceExt->Boot->FATCount; i++)
- {
- if ((FATOffset % BLOCKSIZE) == (BLOCKSIZE - 1)) //entry is on 2 sectors
- {
- /* FIXME: Check status */
- VfatWriteSectors (DeviceExt->StorageDevice,
- DeviceExt->FATStart + FATsector
- + i * DeviceExt->Boot->FATSectors,
- 2, CBlock + FATsector * 512);
- }
- else
- {
- /* FIXME: Check status */
- VfatWriteSectors (DeviceExt->StorageDevice,
- DeviceExt->FATStart + FATsector
- + i * DeviceExt->Boot->FATSectors,
- 1, CBlock + FATsector * 512);
- }
- }
- CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
+ CcSetDirtyPinnedData(Context, NULL);
+ CcUnpinData(Context);
return(STATUS_SUCCESS);
}
*/
{
PVOID BaseAddress;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
NTSTATUS Status;
ULONG FATOffset;
- ULONG Start;
ULONG i;
ULONG ChunkSize;
-
+ PVOID Context;
+ LARGE_INTEGER Offset;
+
ChunkSize = CACHEPAGESIZE(DeviceExt);
-
- Start = DeviceExt->FATStart;
-
- FATOffset = (Start * BLOCKSIZE) + (ClusterToWrite * 2);
-
- for (i = 0; i < DeviceExt->Boot->FATCount; i++)
- {
- Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
- ROUND_DOWN(FATOffset, ChunkSize),
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- ROUND_DOWN(FATOffset, ChunkSize) / BLOCKSIZE,
- ChunkSize / BLOCKSIZE,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
- return(Status);
- }
- }
-
- DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
+ FATOffset = ClusterToWrite * 2;
+ Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+ DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
ClusterToWrite);
- *((PUSHORT)(BaseAddress + (FATOffset % ChunkSize))) = NewValue;
- Status = VfatWriteSectors(DeviceExt->StorageDevice,
- ROUND_DOWN(FATOffset,ChunkSize) / BLOCKSIZE,
- ChunkSize / BLOCKSIZE,
- BaseAddress);
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
-
- DPRINT("DeviceExt->Boot->FATSectors %d\n",
- DeviceExt->Boot->FATSectors);
- FATOffset = FATOffset + DeviceExt->Boot->FATSectors * BLOCKSIZE;
- }
-
+ *((PUSHORT)(BaseAddress + (FATOffset % ChunkSize))) = NewValue;
+ CcSetDirtyPinnedData(Context, NULL);
+ CcUnpinData(Context);
return(STATUS_SUCCESS);
}
*/
{
PVOID BaseAddress;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
NTSTATUS Status;
ULONG FATOffset;
- ULONG Start;
ULONG i;
ULONG ChunkSize;
+ PVOID Context;
+ LARGE_INTEGER Offset;
ChunkSize = CACHEPAGESIZE(DeviceExt);
- Start = DeviceExt->FATStart;
+ FATOffset = (ClusterToWrite * 4);
+ Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
+ if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+ DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
+ ClusterToWrite);
+ *((PULONG)(BaseAddress + (FATOffset % ChunkSize))) = NewValue & 0x0fffffff;
- FATOffset = (Start * BLOCKSIZE) + (ClusterToWrite * 4);
+ CcSetDirtyPinnedData(Context, NULL);
+ CcUnpinData(Context);
- for (i = 0; i < DeviceExt->Boot->FATCount; i++)
- {
- Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
- ROUND_DOWN(FATOffset, ChunkSize),
- &BaseAddress,
- &Valid,
- &CacheSeg);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
- }
- if (!Valid)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- ROUND_DOWN(FATOffset, ChunkSize) / BLOCKSIZE,
- ChunkSize / BLOCKSIZE,
- BaseAddress);
- if (!NT_SUCCESS(Status))
- {
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
- return(Status);
- }
- }
-
- DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
- ClusterToWrite);
- *((PULONG)(BaseAddress + (FATOffset % ChunkSize))) = NewValue & 0x0fffffff;
- Status = VfatWriteSectors(DeviceExt->StorageDevice,
- ROUND_DOWN(FATOffset, ChunkSize) / BLOCKSIZE,
- ChunkSize / BLOCKSIZE,
- BaseAddress);
- CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
-
- DPRINT("DeviceExt->Boot->FATSectors %d\n",
+ DPRINT("DeviceExt->Boot->FATSectors %d\n",
((struct _BootSector32 *)DeviceExt->Boot)->FATSectors32);
- FATOffset += ((struct _BootSector32 *)DeviceExt->Boot)->FATSectors32 * BLOCKSIZE;
- }
return(STATUS_SUCCESS);
}
VfatRawReadCluster(PDEVICE_EXTENSION DeviceExt,
ULONG FirstCluster,
PVOID Buffer,
- ULONG Cluster)
+ ULONG Cluster,
+ ULONG Count)
/*
- * FUNCTION: Load a cluster from the physical device
+ * FUNCTION: Load one ore more continus clusters from the physical device
*/
{
- NTSTATUS Status;
if (FirstCluster == 1)
- {
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- Cluster,
- DeviceExt->Boot->SectorsPerCluster,
- Buffer);
- return(Status);
- }
+ {
+ return VfatReadSectors(DeviceExt->StorageDevice, Cluster,
+ DeviceExt->Boot->SectorsPerCluster * Count, Buffer);
+ }
else
- {
- ULONG Sector;
-
- Sector = ClusterToSector(DeviceExt, Cluster);
-
+ {
+ ULONG Sector;
- Status = VfatReadSectors(DeviceExt->StorageDevice,
- Sector,
- DeviceExt->Boot->SectorsPerCluster,
- Buffer);
- return(Status);
- }
+ Sector = ClusterToSector(DeviceExt, Cluster);
+ return VfatReadSectors(DeviceExt->StorageDevice, Sector,
+ DeviceExt->Boot->SectorsPerCluster * Count, Buffer);
+ }
}
NTSTATUS
VfatRawWriteCluster(PDEVICE_EXTENSION DeviceExt,
ULONG FirstCluster,
PVOID Buffer,
- ULONG Cluster)
+ ULONG Cluster,
+ ULONG Count)
/*
* FUNCTION: Write a cluster to the physical device
*/
DeviceExt, Buffer, Cluster);
if (FirstCluster == 1)
- {
- Status = VfatWriteSectors(DeviceExt->StorageDevice,
- Cluster,
- DeviceExt->Boot->SectorsPerCluster,
- Buffer);
- }
+ {
+ Status = VfatWriteSectors(DeviceExt->StorageDevice, Cluster,
+ DeviceExt->Boot->SectorsPerCluster * Count, Buffer);
+ }
else
- {
- Sector = ClusterToSector(DeviceExt,
- Cluster);
+ {
+ Sector = ClusterToSector(DeviceExt, Cluster);
- Status = VfatWriteSectors(DeviceExt->StorageDevice,
- Sector,
- DeviceExt->Boot->SectorsPerCluster,
- Buffer);
- }
+ Status = VfatWriteSectors(DeviceExt->StorageDevice, Sector,
+ DeviceExt->Boot->SectorsPerCluster * Count, Buffer);
+ }
return(Status);
}
// DeviceExt, CurrentCluster);
if (!Extend)
- {
- ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE);
- }
+ {
+ ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE);
+ }
else
- {
- ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
- }
+ {
+ ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
+ }
/*
* If the file hasn't any clusters allocated then we need special
* handling
*/
if (CurrentCluster == 0 && Extend)
- {
- ULONG NewCluster;
-
- if (DeviceExt->FatType == FAT16)
- {
- Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster);
- if (!NT_SUCCESS(Status))
- {
+ {
+ ULONG NewCluster;
+
+ if (DeviceExt->FatType == FAT16)
+ {
+ Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster);
+ if (!NT_SUCCESS(Status))
+ {
ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status);
- }
- }
- else if (DeviceExt->FatType == FAT32)
- {
- Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster);
- if (!NT_SUCCESS(Status))
+ }
+ }
+ else if (DeviceExt->FatType == FAT32)
+ {
+ Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster);
+ if (!NT_SUCCESS(Status))
{
ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status);
}
- }
- else
- {
- Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster);
- if (!NT_SUCCESS(Status))
+ }
+ else
+ {
+ Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster);
+ if (!NT_SUCCESS(Status))
{
ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status);
}
- }
- /* Mark the new AU as the EOF */
- WriteCluster (DeviceExt, NewCluster, 0xFFFFFFFF);
- *NextCluster = NewCluster;
- ExReleaseResourceLite(&DeviceExt->FatResource);
- return(STATUS_SUCCESS);
- }
+ }
+ /* Mark the new AU as the EOF */
+ WriteCluster (DeviceExt, NewCluster, 0xFFFFFFFF);
+ *NextCluster = NewCluster;
+ ExReleaseResourceLite(&DeviceExt->FatResource);
+ return(STATUS_SUCCESS);
+ }
else if (CurrentCluster == 0)
- {
- ExReleaseResourceLite(&DeviceExt->FatResource);
- return(STATUS_UNSUCCESSFUL);
- }
+ {
+ ExReleaseResourceLite(&DeviceExt->FatResource);
+ return(STATUS_UNSUCCESSFUL);
+ }
if (DeviceExt->FatType == FAT16)
- {
- Status = Fat16GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
- }
+ {
+ Status = Fat16GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
+ }
else if (DeviceExt->FatType == FAT32)
- {
- Status = Fat32GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
- }
+ {
+ Status = Fat32GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
+ }
else
- {
- Status = Fat12GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
- }
+ {
+ Status = Fat12GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
+ }
if (Extend && (*NextCluster) == 0xFFFFFFFF)
- {
- ULONG NewCluster;
-
- /* We are after last existing cluster, we must add one to file */
- /* Firstly, find the next available open allocation unit */
- if (DeviceExt->FatType == FAT16)
- {
- Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster);
- if (!NT_SUCCESS(Status))
+ {
+ ULONG NewCluster;
+
+ /* We are after last existing cluster, we must add one to file */
+ /* Firstly, find the next available open allocation unit */
+ if (DeviceExt->FatType == FAT16)
+ {
+ Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster);
+ if (!NT_SUCCESS(Status))
{
- ExReleaseResourceLite(&DeviceExt->FatResource);
+ ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status);
}
- }
- else if (DeviceExt->FatType == FAT32)
- {
- Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster);
- if (!NT_SUCCESS(Status))
+ }
+ else if (DeviceExt->FatType == FAT32)
+ {
+ Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster);
+ if (!NT_SUCCESS(Status))
{
- ExReleaseResourceLite(&DeviceExt->FatResource);
+ ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status);
}
- }
- else
- {
- Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster);
- if (!NT_SUCCESS(Status))
+ }
+ else
+ {
+ Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster);
+ if (!NT_SUCCESS(Status))
{
- ExReleaseResourceLite(&DeviceExt->FatResource);
+ ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status);
}
- }
- /* Mark the new AU as the EOF */
- WriteCluster(DeviceExt, NewCluster, 0xFFFFFFFF);
- /* Now, write the AU of the LastCluster with the value of the newly
- found AU */
- WriteCluster(DeviceExt, CurrentCluster, NewCluster);
- *NextCluster = NewCluster;
- }
+ }
+ /* Mark the new AU as the EOF */
+ WriteCluster(DeviceExt, NewCluster, 0xFFFFFFFF);
+ /* Now, write the AU of the LastCluster with the value of the newly
+ found AU */
+ WriteCluster(DeviceExt, CurrentCluster, NewCluster);
+ *NextCluster = NewCluster;
+ }
ExReleaseResourceLite(&DeviceExt->FatResource);
projects / reactos.git / commitdiff