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

Changed the cache access from CcRos...CacheSegment() to Cc...Data().

Browse source 
svn path=/trunk/; revision=2287
This commit is contained in:
Hartmut Birr 2001-10-10 22:16:46 +00:00
parent 068a4a38d5
commit 6df323c21b
1 changed files with 226 additions and 505 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

731
reactos/drivers/fs/vfat/fat.c
View file

@ -1,5 +1,5 @@
/* /*
* $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 * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -39,43 +39,23 @@ Fat32GetNextCluster(PDEVICE_EXTENSION DeviceExt,
*/ */
{ {
PVOID BaseAddress; PVOID BaseAddress;
BOOLEAN Valid;
PCACHE_SEGMENT CacheSeg;
NTSTATUS Status; NTSTATUS Status;
ULONG FATOffset; ULONG FATOffset;
ULONG ChunkSize; ULONG ChunkSize;
PVOID Context;
LARGE_INTEGER Offset;
ChunkSize=CACHEPAGESIZE(DeviceExt); ChunkSize = CACHEPAGESIZE(DeviceExt);
FATOffset = CurrentCluster * sizeof(ULONG);
FATOffset = (DeviceExt->FATStart * BLOCKSIZE) + Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
(CurrentCluster * sizeof(ULONG)); if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
{
Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb, return STATUS_UNSUCCESSFUL;
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);
}
}
CurrentCluster = (*(PULONG)(BaseAddress + (FATOffset % ChunkSize))) & 0x0fffffff; CurrentCluster = (*(PULONG)(BaseAddress + (FATOffset % ChunkSize))) & 0x0fffffff;
if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff) if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff)
CurrentCluster = 0xffffffff; CurrentCluster = 0xffffffff;
CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE); CcUnpinData(Context);
*NextCluster = CurrentCluster; *NextCluster = CurrentCluster;
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
@ -89,42 +69,23 @@ Fat16GetNextCluster(PDEVICE_EXTENSION DeviceExt,
*/ */
{ {
PVOID BaseAddress; PVOID BaseAddress;
BOOLEAN Valid;
PCACHE_SEGMENT CacheSeg;
NTSTATUS Status; NTSTATUS Status;
ULONG FATOffset; ULONG FATOffset;
ULONG ChunkSize; ULONG ChunkSize;
PVOID Context;
LARGE_INTEGER Offset;
ChunkSize = CACHEPAGESIZE(DeviceExt); ChunkSize = CACHEPAGESIZE(DeviceExt);
FATOffset = CurrentCluster * 2;
FATOffset = (DeviceExt->FATStart * BLOCKSIZE) + (CurrentCluster * 2); Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb, {
ROUND_DOWN(FATOffset, ChunkSize), return STATUS_UNSUCCESSFUL;
&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);
}
}
CurrentCluster = *((PUSHORT)(BaseAddress + (FATOffset % ChunkSize))); CurrentCluster = *((PUSHORT)(BaseAddress + (FATOffset % ChunkSize)));
if (CurrentCluster >= 0xfff8 && CurrentCluster <= 0xffff) if (CurrentCluster >= 0xfff8 && CurrentCluster <= 0xffff)
CurrentCluster = 0xffffffff; CurrentCluster = 0xffffffff;
CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE); CcUnpinData(Context);
*NextCluster = CurrentCluster; *NextCluster = CurrentCluster;
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
@ -140,36 +101,21 @@ Fat12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
PUCHAR CBlock; PUCHAR CBlock;
ULONG FATOffset; ULONG FATOffset;
ULONG Entry; ULONG Entry;
BOOLEAN Valid;
PCACHE_SEGMENT CacheSeg;
NTSTATUS Status; NTSTATUS Status;
PVOID BaseAddress; PVOID BaseAddress;
PVOID Context;
LARGE_INTEGER Offset;
*NextCluster = 0; *NextCluster = 0;
Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb, Offset.QuadPart = 0;
0, if(!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->Boot->FATSectors * BLOCKSIZE, 1, &Context, &BaseAddress))
&BaseAddress, {
&Valid, return STATUS_UNSUCCESSFUL;
&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);
}
}
CBlock = (PUCHAR)BaseAddress; CBlock = (PUCHAR)BaseAddress;
FATOffset = (CurrentCluster * 12) / 8; /* first byte containing value */ FATOffset = (CurrentCluster * 12) / 8; /* first byte containing value */
if ((CurrentCluster % 2) == 0) if ((CurrentCluster % 2) == 0)
{ {
@ -186,7 +132,7 @@ Fat12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
Entry = 0xffffffff; Entry = 0xffffffff;
// DPRINT("Returning %x\n",Entry); // DPRINT("Returning %x\n",Entry);
*NextCluster = Entry; *NextCluster = Entry;
CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE); CcUnpinData(Context);
// return Entry == 0xffffffff ? STATUS_END_OF_FILE : STATUS_SUCCESS; // return Entry == 0xffffffff ? STATUS_END_OF_FILE : STATUS_SUCCESS;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -202,60 +148,39 @@ FAT16FindAvailableCluster(PDEVICE_EXTENSION DeviceExt,
ULONG i; ULONG i;
NTSTATUS Status; NTSTATUS Status;
PVOID BaseAddress; PVOID BaseAddress;
PCACHE_SEGMENT CacheSeg;
BOOLEAN Valid;
ULONG FatStart;
ULONG ChunkSize; ULONG ChunkSize;
PVOID Context = 0;
LARGE_INTEGER Offset;
ChunkSize = CACHEPAGESIZE(DeviceExt); ChunkSize = CACHEPAGESIZE(DeviceExt);
FatStart = DeviceExt->FATStart * BLOCKSIZE;
FatLength = (((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2)*2; FatLength = (((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2)*2;
CacheSeg = NULL;
*Cluster = 0; *Cluster = 0;
for (i = 2; i < FatLength; i+=2) for (i = 2; i < FatLength; i+=2)
{ {
if (((FatStart + i) % ChunkSize) == 0 || CacheSeg == NULL) if ((i % ChunkSize) == 0 || Context ==0)
{ {
if (CacheSeg != NULL) Offset.QuadPart = ROUND_DOWN(i, ChunkSize);
{ if (Context != NULL)
CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE); {
} CcUnpinData(Context);
Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb, }
ROUND_DOWN(FatStart + i, ChunkSize), if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
&BaseAddress, {
&Valid, return STATUS_UNSUCCESSFUL;
&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);
}
}
} }
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; *Cluster = i / 2;
CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE); CcUnpinData(Context);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
}
CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE); }
CcUnpinData(Context);
return(STATUS_DISK_FULL); return(STATUS_DISK_FULL);
} }
@ -270,34 +195,17 @@ FAT12FindAvailableCluster(PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
PUCHAR CBlock; PUCHAR CBlock;
ULONG i; ULONG i;
PVOID BaseAddress; PVOID BaseAddress;
BOOLEAN Valid;
PCACHE_SEGMENT CacheSeg;
NTSTATUS Status; NTSTATUS Status;
ULONG numberofclusters; ULONG numberofclusters;
PVOID Context;
LARGE_INTEGER Offset;
*Cluster = 0; *Cluster = 0;
Offset.QuadPart = 0;
Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb, if(!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->Boot->FATSectors * BLOCKSIZE, 1, &Context, &BaseAddress))
0, {
&BaseAddress, return STATUS_UNSUCCESSFUL;
&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);
}
}
CBlock = (PUCHAR)BaseAddress; CBlock = (PUCHAR)BaseAddress;
numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2; numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2;
@ -319,11 +227,11 @@ FAT12FindAvailableCluster(PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
{ {
DPRINT("Found available cluster 0x%x\n", i); DPRINT("Found available cluster 0x%x\n", i);
*Cluster = i; *Cluster = i;
CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE); CcUnpinData(Context);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
} }
CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE); CcUnpinData(Context);
return (STATUS_DISK_FULL); return (STATUS_DISK_FULL);
} }
@ -337,103 +245,38 @@ FAT32FindAvailableCluster (PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
ULONG i; ULONG i;
NTSTATUS Status; NTSTATUS Status;
PVOID BaseAddress; PVOID BaseAddress;
PCACHE_SEGMENT CacheSeg;
BOOLEAN Valid;
ULONG FatStart;
ULONG ChunkSize; ULONG ChunkSize;
PVOID Context = NULL;
LARGE_INTEGER Offset;
ChunkSize = CACHEPAGESIZE(DeviceExt); ChunkSize = CACHEPAGESIZE(DeviceExt);
FatStart = DeviceExt->FATStart * BLOCKSIZE;
FatLength = (((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2)*4; FatLength = (((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2)*4;
CacheSeg = NULL;
*Cluster = 0; *Cluster = 0;
for (i = 4; i < FatLength; i+=4) for (i = 4; i < FatLength; i+=4)
{ {
if (((FatStart + i) % ChunkSize) == 0 || CacheSeg == NULL) if ((i % ChunkSize) == 0 || Context == NULL)
{ {
if (CacheSeg != NULL) Offset.QuadPart = ROUND_DOWN(i, ChunkSize);
{ if (Context != NULL)
CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE); {
} CcUnpinData(Context);
Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb, }
ROUND_DOWN(FatStart + i, ChunkSize), if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
&BaseAddress, {
&Valid, return STATUS_UNSUCCESSFUL;
&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);
}
}
} }
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); DPRINT("Found available cluster 0x%x\n", i / 4);
*Cluster = i / 4; *Cluster = i / 4;
CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE); CcUnpinData(Context);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
} }
CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE); CcUnpinData(Context);
#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
return (STATUS_DISK_FULL); return (STATUS_DISK_FULL);
} }
@ -451,38 +294,21 @@ FAT12CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
ULONG ulCount = 0; ULONG ulCount = 0;
ULONG i; ULONG i;
PVOID BaseAddress; PVOID BaseAddress;
BOOLEAN Valid;
PCACHE_SEGMENT CacheSeg;
NTSTATUS Status; NTSTATUS Status;
ULONG numberofclusters; ULONG numberofclusters;
LARGE_INTEGER Offset;
PVOID Context;
ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE); ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE);
Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb, Offset.QuadPart = 0;
0, if(!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->Boot->FATSectors * BLOCKSIZE, 1, &Context, &BaseAddress))
&BaseAddress, {
&Valid, ExReleaseResourceLite (&DeviceExt->FatResource);
&CacheSeg); return STATUS_UNSUCCESSFUL;
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);
}
}
CBlock = (PUCHAR)BaseAddress; CBlock = (PUCHAR)BaseAddress;
numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2; numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2;
for (i = 2; i < numberofclusters; i++) for (i = 2; i < numberofclusters; i++)
{ {
FATOffset = (i * 12) / 8; FATOffset = (i * 12) / 8;
@ -500,7 +326,7 @@ FAT12CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
ulCount++; ulCount++;
} }
CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE); CcUnpinData(Context);
ExReleaseResourceLite (&DeviceExt->FatResource); ExReleaseResourceLite (&DeviceExt->FatResource);
Clusters->QuadPart = ulCount; Clusters->QuadPart = ulCount;
@ -559,6 +385,7 @@ FAT16CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
ExReleaseResourceLite (&DeviceExt->FatResource); ExReleaseResourceLite (&DeviceExt->FatResource);
Clusters->QuadPart = ulCount; Clusters->QuadPart = ulCount;
ExFreePool(Block);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -605,7 +432,7 @@ FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
forto=128; forto=128;
for (i = 0; i < forto; i++) for (i = 0; i < forto; i++)
{ {
if (Block[i] & 0x0fffffff == 0) if ((Block[i] & 0x0fffffff) == 0)
ulCount++; ulCount++;
} }
} }
@ -631,30 +458,14 @@ FAT12WriteCluster(PDEVICE_EXTENSION DeviceExt,
int i; int i;
NTSTATUS Status; NTSTATUS Status;
PVOID BaseAddress; PVOID BaseAddress;
BOOLEAN Valid; PVOID Context;
PCACHE_SEGMENT CacheSeg; LARGE_INTEGER Offset;
Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb, Offset.QuadPart = 0;
0, if(!CcMapData(DeviceExt->FATFileObject, &Offset, DeviceExt->Boot->FATSectors * BLOCKSIZE, 1, &Context, &BaseAddress))
&BaseAddress, {
&Valid, return STATUS_UNSUCCESSFUL;
&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);
}
}
CBlock = (PUCHAR)BaseAddress; CBlock = (PUCHAR)BaseAddress;
FATOffset = (ClusterToWrite * 12) / 8; FATOffset = (ClusterToWrite * 12) / 8;
@ -674,26 +485,8 @@ FAT12WriteCluster(PDEVICE_EXTENSION DeviceExt,
} }
/* Write the changed FAT sector(s) to disk */ /* Write the changed FAT sector(s) to disk */
FATsector = FATOffset / BLOCKSIZE; FATsector = FATOffset / BLOCKSIZE;
for (i = 0; i < DeviceExt->Boot->FATCount; i++) CcSetDirtyPinnedData(Context, NULL);
{ CcUnpinData(Context);
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);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -706,58 +499,25 @@ FAT16WriteCluster(PDEVICE_EXTENSION DeviceExt,
*/ */
{ {
PVOID BaseAddress; PVOID BaseAddress;
BOOLEAN Valid;
PCACHE_SEGMENT CacheSeg;
NTSTATUS Status; NTSTATUS Status;
ULONG FATOffset; ULONG FATOffset;
ULONG Start;
ULONG i; ULONG i;
ULONG ChunkSize; ULONG ChunkSize;
PVOID Context;
ChunkSize = CACHEPAGESIZE(DeviceExt); LARGE_INTEGER Offset;
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,
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;
}
ChunkSize = CACHEPAGESIZE(DeviceExt);
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;
CcSetDirtyPinnedData(Context, NULL);
CcUnpinData(Context);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -770,57 +530,30 @@ FAT32WriteCluster(PDEVICE_EXTENSION DeviceExt,
*/ */
{ {
PVOID BaseAddress; PVOID BaseAddress;
BOOLEAN Valid;
PCACHE_SEGMENT CacheSeg;
NTSTATUS Status; NTSTATUS Status;
ULONG FATOffset; ULONG FATOffset;
ULONG Start;
ULONG i; ULONG i;
ULONG ChunkSize; ULONG ChunkSize;
PVOID Context;
LARGE_INTEGER Offset;
ChunkSize = CACHEPAGESIZE(DeviceExt); ChunkSize = CACHEPAGESIZE(DeviceExt);
Start = DeviceExt->FATStart; FATOffset = (ClusterToWrite * 4);
Offset.QuadPart = ROUND_DOWN(FATOffset, ChunkSize);
FATOffset = (Start * BLOCKSIZE) + (ClusterToWrite * 4); if(!CcMapData(DeviceExt->FATFileObject, &Offset, ChunkSize, 1, &Context, &BaseAddress))
{
for (i = 0; i < DeviceExt->Boot->FATCount; i++) return STATUS_UNSUCCESSFUL;
{ }
Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb, DPRINT("Writing 0x%x for offset 0x%x 0x%x\n", NewValue, FATOffset,
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); ClusterToWrite);
*((PULONG)(BaseAddress + (FATOffset % ChunkSize))) = NewValue & 0x0fffffff; *((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", CcSetDirtyPinnedData(Context, NULL);
CcUnpinData(Context);
DPRINT("DeviceExt->Boot->FATSectors %d\n",
((struct _BootSector32 *)DeviceExt->Boot)->FATSectors32); ((struct _BootSector32 *)DeviceExt->Boot)->FATSectors32);
FATOffset += ((struct _BootSector32 *)DeviceExt->Boot)->FATSectors32 * BLOCKSIZE;
}
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -866,41 +599,34 @@ NTSTATUS
VfatRawReadCluster(PDEVICE_EXTENSION DeviceExt, VfatRawReadCluster(PDEVICE_EXTENSION DeviceExt,
ULONG FirstCluster, ULONG FirstCluster,
PVOID Buffer, 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) if (FirstCluster == 1)
{ {
Status = VfatReadSectors(DeviceExt->StorageDevice, return VfatReadSectors(DeviceExt->StorageDevice, Cluster,
Cluster, DeviceExt->Boot->SectorsPerCluster * Count, Buffer);
DeviceExt->Boot->SectorsPerCluster, }
Buffer);
return(Status);
}
else else
{ {
ULONG Sector; ULONG Sector;
Sector = ClusterToSector(DeviceExt, Cluster);
Status = VfatReadSectors(DeviceExt->StorageDevice, Sector = ClusterToSector(DeviceExt, Cluster);
Sector, return VfatReadSectors(DeviceExt->StorageDevice, Sector,
DeviceExt->Boot->SectorsPerCluster, DeviceExt->Boot->SectorsPerCluster * Count, Buffer);
Buffer); }
return(Status);
}
} }
NTSTATUS NTSTATUS
VfatRawWriteCluster(PDEVICE_EXTENSION DeviceExt, VfatRawWriteCluster(PDEVICE_EXTENSION DeviceExt,
ULONG FirstCluster, ULONG FirstCluster,
PVOID Buffer, PVOID Buffer,
ULONG Cluster) ULONG Cluster,
ULONG Count)
/* /*
* FUNCTION: Write a cluster to the physical device * FUNCTION: Write a cluster to the physical device
*/ */
@ -912,22 +638,17 @@ VfatRawWriteCluster(PDEVICE_EXTENSION DeviceExt,
DeviceExt, Buffer, Cluster); DeviceExt, Buffer, Cluster);
if (FirstCluster == 1) if (FirstCluster == 1)
{ {
Status = VfatWriteSectors(DeviceExt->StorageDevice, Status = VfatWriteSectors(DeviceExt->StorageDevice, Cluster,
Cluster, DeviceExt->Boot->SectorsPerCluster * Count, Buffer);
DeviceExt->Boot->SectorsPerCluster, }
Buffer);
}
else else
{ {
Sector = ClusterToSector(DeviceExt, Sector = ClusterToSector(DeviceExt, Cluster);
Cluster);
Status = VfatWriteSectors(DeviceExt->StorageDevice, Status = VfatWriteSectors(DeviceExt->StorageDevice, Sector,
Sector, DeviceExt->Boot->SectorsPerCluster * Count, Buffer);
DeviceExt->Boot->SectorsPerCluster, }
Buffer);
}
return(Status); return(Status);
} }
@ -946,113 +667,113 @@ GetNextCluster(PDEVICE_EXTENSION DeviceExt,
// DeviceExt, CurrentCluster); // DeviceExt, CurrentCluster);
if (!Extend) if (!Extend)
{ {
ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE); ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE);
} }
else else
{ {
ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE); ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
} }
/* /*
* If the file hasn't any clusters allocated then we need special * If the file hasn't any clusters allocated then we need special
* handling * handling
*/ */
if (CurrentCluster == 0 && Extend) if (CurrentCluster == 0 && Extend)
{ {
ULONG NewCluster; ULONG NewCluster;
if (DeviceExt->FatType == FAT16) if (DeviceExt->FatType == FAT16)
{ {
Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster); Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{
ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status);
}
}
else if (DeviceExt->FatType == FAT32)
{
Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster);
if (!NT_SUCCESS(Status))
{ {
ExReleaseResourceLite(&DeviceExt->FatResource); ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status); return(Status);
} }
} }
else if (DeviceExt->FatType == FAT32) else
{ {
Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster); Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ExReleaseResourceLite(&DeviceExt->FatResource); ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status); return(Status);
} }
} }
else /* Mark the new AU as the EOF */
{ WriteCluster (DeviceExt, NewCluster, 0xFFFFFFFF);
Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster); *NextCluster = NewCluster;
if (!NT_SUCCESS(Status)) ExReleaseResourceLite(&DeviceExt->FatResource);
{ return(STATUS_SUCCESS);
ExReleaseResourceLite(&DeviceExt->FatResource); }
return(Status);
}
}
/* Mark the new AU as the EOF */
WriteCluster (DeviceExt, NewCluster, 0xFFFFFFFF);
*NextCluster = NewCluster;
ExReleaseResourceLite(&DeviceExt->FatResource);
return(STATUS_SUCCESS);
}
else if (CurrentCluster == 0) else if (CurrentCluster == 0)
{ {
ExReleaseResourceLite(&DeviceExt->FatResource); ExReleaseResourceLite(&DeviceExt->FatResource);
return(STATUS_UNSUCCESSFUL); return(STATUS_UNSUCCESSFUL);
} }
if (DeviceExt->FatType == FAT16) if (DeviceExt->FatType == FAT16)
{ {
Status = Fat16GetNextCluster(DeviceExt, CurrentCluster, NextCluster); Status = Fat16GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
} }
else if (DeviceExt->FatType == FAT32) else if (DeviceExt->FatType == FAT32)
{ {
Status = Fat32GetNextCluster(DeviceExt, CurrentCluster, NextCluster); Status = Fat32GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
} }
else else
{ {
Status = Fat12GetNextCluster(DeviceExt, CurrentCluster, NextCluster); Status = Fat12GetNextCluster(DeviceExt, CurrentCluster, NextCluster);
} }
if (Extend && (*NextCluster) == 0xFFFFFFFF) if (Extend && (*NextCluster) == 0xFFFFFFFF)
{ {
ULONG NewCluster; ULONG NewCluster;
/* We are after last existing cluster, we must add one to file */ /* We are after last existing cluster, we must add one to file */
/* Firstly, find the next available open allocation unit */ /* Firstly, find the next available open allocation unit */
if (DeviceExt->FatType == FAT16) if (DeviceExt->FatType == FAT16)
{ {
Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster); Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ExReleaseResourceLite(&DeviceExt->FatResource); ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status); return(Status);
} }
} }
else if (DeviceExt->FatType == FAT32) else if (DeviceExt->FatType == FAT32)
{ {
Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster); Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ExReleaseResourceLite(&DeviceExt->FatResource); ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status); return(Status);
} }
} }
else else
{ {
Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster); Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
ExReleaseResourceLite(&DeviceExt->FatResource); ExReleaseResourceLite(&DeviceExt->FatResource);
return(Status); return(Status);
} }
} }
/* Mark the new AU as the EOF */ /* Mark the new AU as the EOF */
WriteCluster(DeviceExt, NewCluster, 0xFFFFFFFF); WriteCluster(DeviceExt, NewCluster, 0xFFFFFFFF);
/* Now, write the AU of the LastCluster with the value of the newly /* Now, write the AU of the LastCluster with the value of the newly
found AU */ found AU */
WriteCluster(DeviceExt, CurrentCluster, NewCluster); WriteCluster(DeviceExt, CurrentCluster, NewCluster);
*NextCluster = NewCluster; *NextCluster = NewCluster;
} }
ExReleaseResourceLite(&DeviceExt->FatResource); ExReleaseResourceLite(&DeviceExt->FatResource);