diff --git a/reactos/drivers/fs/vfat/fat.c b/reactos/drivers/fs/vfat/fat.c
index 97bdc3e1163..ef01e27e0c9 100644
--- a/reactos/drivers/fs/vfat/fat.c
+++ b/reactos/drivers/fs/vfat/fat.c
@@ -1,5 +1,5 @@
 /*
- * $Id: fat.c,v 1.28 2001/07/13 10:31:14 ekohl Exp $
+ * $Id: fat.c,v 1.29 2001/07/20 08:00:20 ekohl Exp $
  *
  * COPYRIGHT:        See COPYING in the top level directory
  * PROJECT:          ReactOS kernel
@@ -30,9 +30,9 @@
 /* FUNCTIONS ****************************************************************/
 
 NTSTATUS
-Fat32GetNextCluster (PDEVICE_EXTENSION DeviceExt, 
-		     ULONG CurrentCluster,
-		     PULONG NextCluster)
+Fat32GetNextCluster(PDEVICE_EXTENSION DeviceExt,
+		    ULONG CurrentCluster,
+		    PULONG NextCluster)
 /*
  * FUNCTION: Retrieve the next FAT32 cluster from the FAT table via a physical
  *           disk read
@@ -43,15 +43,18 @@ Fat32GetNextCluster (PDEVICE_EXTENSION DeviceExt,
   PCACHE_SEGMENT CacheSeg;
   NTSTATUS Status;
   ULONG FATOffset;
+  ULONG ChunkSize;
 
-  FATOffset = (DeviceExt->FATStart * BLOCKSIZE) + 
+  ChunkSize=CACHEPAGESIZE(DeviceExt);
+
+  FATOffset = (DeviceExt->FATStart * BLOCKSIZE) +
     (CurrentCluster * sizeof(ULONG));
 
   Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
-				 PAGE_ROUND_DOWN(FATOffset),
-				 &BaseAddress,
-				 &Valid,
-				 &CacheSeg);
+				    ROUND_DOWN(FATOffset, ChunkSize),
+				    &BaseAddress,
+				    &Valid,
+				    &CacheSeg);
   if (!NT_SUCCESS(Status))
     {
       return(Status);
@@ -59,9 +62,9 @@ Fat32GetNextCluster (PDEVICE_EXTENSION DeviceExt,
   if (!Valid)
     {
       Status = VfatReadSectors(DeviceExt->StorageDevice,
-			      PAGE_ROUND_DOWN(FATOffset) / BLOCKSIZE,
-			      PAGESIZE / BLOCKSIZE,
-			      BaseAddress);
+			       ROUND_DOWN(FATOffset, ChunkSize) / BLOCKSIZE,
+			       ChunkSize / BLOCKSIZE,
+			       BaseAddress);
       if (!NT_SUCCESS(Status))
 	{
 	  CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
@@ -69,7 +72,7 @@ Fat32GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 	}
     }
 
-  CurrentCluster = *(PULONG)(BaseAddress + (FATOffset % PAGESIZE));
+  CurrentCluster = *(PULONG)(BaseAddress + (FATOffset % ChunkSize));
   if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff)
     CurrentCluster = 0xffffffff;
   CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
@@ -78,9 +81,9 @@ Fat32GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 }
 
 NTSTATUS
-Fat16GetNextCluster (PDEVICE_EXTENSION DeviceExt, 
-		     ULONG CurrentCluster,
-		     PULONG NextCluster)
+Fat16GetNextCluster(PDEVICE_EXTENSION DeviceExt,
+		    ULONG CurrentCluster,
+		    PULONG NextCluster)
 /*
  * FUNCTION: Retrieve the next FAT16 cluster from the FAT table
  */
@@ -127,28 +130,28 @@ Fat16GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 }
 
 NTSTATUS
-Fat12GetNextCluster (PDEVICE_EXTENSION DeviceExt, 
-		     ULONG CurrentCluster,
-		     PULONG NextCluster)
+Fat12GetNextCluster(PDEVICE_EXTENSION DeviceExt,
+		    ULONG CurrentCluster,
+		    PULONG NextCluster)
 /*
  * FUNCTION: Retrieve the next FAT12 cluster from the FAT table
  */
 {
- unsigned char* CBlock;
- ULONG FATOffset;
- ULONG Entry;
- BOOLEAN Valid;
- PCACHE_SEGMENT CacheSeg;
- NTSTATUS Status;
- PVOID BaseAddress;
+  PUCHAR CBlock;
+  ULONG FATOffset;
+  ULONG Entry;
+  BOOLEAN Valid;
+  PCACHE_SEGMENT CacheSeg;
+  NTSTATUS Status;
+  PVOID BaseAddress;
 
- *NextCluster = 0;
+  *NextCluster = 0;
 
- Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
-				0,
-				&BaseAddress,
-				&Valid,
-				&CacheSeg);
+  Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
+				    0,
+				    &BaseAddress,
+				    &Valid,
+				    &CacheSeg);
   if (!NT_SUCCESS(Status))
     {
       return(Status);
@@ -188,8 +191,8 @@ Fat12GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 }
 
 NTSTATUS
-FAT16FindAvailableCluster (PDEVICE_EXTENSION DeviceExt,
-			   PULONG Cluster)
+FAT16FindAvailableCluster(PDEVICE_EXTENSION DeviceExt,
+			  PULONG Cluster)
 /*
  * FUNCTION: Finds the first available cluster in a FAT16 table
  */
@@ -206,12 +209,13 @@ FAT16FindAvailableCluster (PDEVICE_EXTENSION DeviceExt,
   ChunkSize = CACHEPAGESIZE(DeviceExt);
   
   FatStart = DeviceExt->FATStart * BLOCKSIZE;
-  FatLength = DeviceExt->Boot->FATSectors * 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 (CacheSeg != NULL)
@@ -255,7 +259,7 @@ FAT16FindAvailableCluster (PDEVICE_EXTENSION DeviceExt,
 }
 
 NTSTATUS
-FAT12FindAvailableCluster (PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
+FAT12FindAvailableCluster(PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
 /*
  * FUNCTION: Finds the first available cluster in a FAT12 table
  */
@@ -271,7 +275,7 @@ FAT12FindAvailableCluster (PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
   ULONG numberofclusters;
   
   *Cluster = 0;
-
+  
   Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
 				 0,
 				 &BaseAddress,
@@ -328,6 +332,63 @@ FAT32FindAvailableCluster (PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
  * FUNCTION: Finds the first available cluster in a FAT32 table
  */
 {
+  ULONG FatLength;
+  ULONG i;
+  NTSTATUS Status;
+  PVOID BaseAddress;
+  PCACHE_SEGMENT CacheSeg;
+  BOOLEAN Valid;
+  ULONG FatStart;
+  ULONG ChunkSize;
+
+  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 (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);
+		}
+	    }
+	}
+      if (*((PULONG)(BaseAddress + ((FatStart + i) % ChunkSize))) == 0)
+	{
+	  DPRINT("Found available cluster 0x%x\n", i);
+	  *Cluster = i / 4;
+	  CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+	  return(STATUS_SUCCESS);
+	}
+    }
+  CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+#if 0
   ULONG sector;
   PULONG Block;
   int i,forto;
@@ -371,6 +432,7 @@ FAT32FindAvailableCluster (PDEVICE_EXTENSION DeviceExt, PULONG Cluster)
     }
   /* Give an error message (out of disk space) if we reach here) */
   ExFreePool (Block);
+#endif
   return (STATUS_DISK_FULL);
 }
 
@@ -445,7 +507,7 @@ FAT12CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
   return(STATUS_SUCCESS);
 }
 
-#if 0
+
 NTSTATUS
 FAT16CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
 			    PLARGE_INTEGER Clusters)
@@ -456,23 +518,50 @@ FAT16CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
   PUSHORT Block;
   ULONG ulCount = 0;
   ULONG i;
+  ULONG numberofclusters;
+  ULONG numberofsectors;
+  ULONG sector;
+  ULONG forto;
+  NTSTATUS Status;
 
   ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE);
+  Block = ExAllocatePool (NonPagedPool, BLOCKSIZE);
 
-  Block = (PUSHORT) DeviceExt->FAT;
-  for (i = 2; i < (DeviceExt->Boot->FATSectors * 256); i++)
+  numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2;
+  numberofsectors = (numberofclusters + 255) / 256;
+  numberofclusters %= 256;
+
+  for (sector = 0; sector < numberofsectors; sector++)
     {
-      if (Block[i] == 0)
-	ulCount++;
-    }
+      Status = VfatReadSectors(DeviceExt->StorageDevice,
+			       DeviceExt->FATStart + sector,
+			       1,
+			       (PUCHAR)Block);
+      if (!NT_SUCCESS(Status))
+	{
+	   ExFreePool(Block);
+	   ExReleaseResourceLite(&DeviceExt->FatResource);
+	   return(Status);
+	}
 
+      if (sector == numberofsectors - 1)
+	forto = numberofclusters;
+      else
+	forto = 256;
+
+      for (i = 0; i < forto; i++)
+	{
+	  if (Block[i] == 0)
+	    ulCount++;
+	}
+    }
   ExReleaseResourceLite (&DeviceExt->FatResource);
 
   Clusters->QuadPart = ulCount;
 
   return(STATUS_SUCCESS);
 }
-#endif
+
 
 NTSTATUS
 FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
@@ -486,6 +575,7 @@ FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
   ULONG ulCount = 0;
   ULONG i,forto;
   ULONG numberofclusters;
+  ULONG numberofsectors;
   NTSTATUS Status;
 
   ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE);
@@ -493,11 +583,10 @@ FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
   Block = ExAllocatePool (NonPagedPool, BLOCKSIZE);
 
   numberofclusters = ((DeviceExt->Boot->Sectors ? DeviceExt->Boot->Sectors : DeviceExt->Boot->SectorsHuge)-DeviceExt->dataStart)/DeviceExt->Boot->SectorsPerCluster+2;
+  numberofsectors = (numberofclusters +127) / 128;
   numberofclusters %= 128;
 
-  for (sector = 0;
-       sector < ((struct _BootSector32 *) (DeviceExt->Boot))->FATSectors32;
-       sector++)
+  for (sector = 0; sector < numberofsectors; sector++)
     {
       Status = VfatReadSectors(DeviceExt->StorageDevice,
 			       (ULONG) (DeviceExt->FATStart + sector), 1,
@@ -509,10 +598,10 @@ FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt,
 	  return(Status);
 	}
 
-      if (sector==((struct _BootSector32 *) (DeviceExt->Boot))->FATSectors32-1)
-	 forto=numberofclusters;
-         else
-         forto=128;
+      if (sector == numberofsectors - 1)
+	forto=numberofclusters;
+      else
+	forto=128;
       for (i = 0; i < forto; i++)
 	{
 	  if (Block[i] == 0)
@@ -668,7 +757,7 @@ FAT16WriteCluster(PDEVICE_EXTENSION DeviceExt,
       FATOffset = FATOffset + DeviceExt->Boot->FATSectors * BLOCKSIZE;
     }
 
-  return (STATUS_SUCCESS);
+  return(STATUS_SUCCESS);
 }
 
 NTSTATUS
@@ -679,37 +768,62 @@ FAT32WriteCluster(PDEVICE_EXTENSION DeviceExt,
  * FUNCTION: Writes a cluster to the FAT32 physical tables
  */
 {
-#if 0
-  ULONG FATsector;
-  ULONG FATeis;
-  PUSHORT Block;
+  PVOID BaseAddress;
+  BOOLEAN Valid;
+  PCACHE_SEGMENT CacheSeg;
+  NTSTATUS Status;
+  ULONG FATOffset;
   ULONG Start;
-  int i;
-  struct _BootSector32 *pBoot;
-  DbgPrint ("FAT32WriteCluster %u : %u\n", ClusterToWrite, NewValue);
-  Block = ExAllocatePool (NonPagedPool, BLOCKSIZE);
-  FATsector = ClusterToWrite / 128;
-  FATeis = ClusterToWrite - (FATsector * 128);
-  /* load sector, change value, then rewrite sector */
-  /* FIXME: Check status */
-  VfatReadSectors (DeviceExt->StorageDevice,
-		   DeviceExt->FATStart + FATsector, 1, (UCHAR *) Block);
-  Block[FATeis] = NewValue;
-  /* Write the changed FAT sector to disk (all FAT's) */
-  Start = DeviceExt->FATStart + FATsector;
-  pBoot = (struct _BootSector32 *) DeviceExt->Boot;
-  for (i = 0; i < pBoot->FATCount; i++)
+  ULONG i;
+  ULONG ChunkSize;
+
+  ChunkSize = CACHEPAGESIZE(DeviceExt);
+
+  Start = DeviceExt->FATStart;
+
+  FATOffset = (Start * BLOCKSIZE) + (ClusterToWrite * 4);
+
+  for (i = 0; i < DeviceExt->Boot->FATCount; i++)
     {
-      /* FIXME: Check status */
-      VfatWriteSectors (DeviceExt->StorageDevice, Start, 1, (UCHAR *) Block);
-      Start += pBoot->FATSectors;
+      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;
+      Status = VfatWriteSectors(DeviceExt->StorageDevice,
+				ROUND_DOWN(FATOffset, ChunkSize) / BLOCKSIZE,
+				ChunkSize / BLOCKSIZE,
+				BaseAddress);
+      CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+
+      DPRINT("DeviceExt->Boot->FATSectors %d\n",
+	     ((struct _BootSector32 *)DeviceExt->Boot)->FATSectors32);
+      FATOffset += ((struct _BootSector32 *)DeviceExt->Boot)->FATSectors32 * BLOCKSIZE;
     }
-  ExFreePool (Block);
-#endif
-//  KeBugCheck(0);
   return(STATUS_SUCCESS);
 }
 
+
 NTSTATUS
 WriteCluster(PDEVICE_EXTENSION DeviceExt,
 	     ULONG ClusterToWrite,
@@ -722,21 +836,22 @@ WriteCluster(PDEVICE_EXTENSION DeviceExt,
 
   if (DeviceExt->FatType == FAT16)
     {
-      Status = FAT16WriteCluster (DeviceExt, ClusterToWrite, NewValue);
+      Status = FAT16WriteCluster(DeviceExt, ClusterToWrite, NewValue);
     }
   else if (DeviceExt->FatType == FAT32)
     {
-      Status = FAT32WriteCluster (DeviceExt, ClusterToWrite, NewValue);
+      Status = FAT32WriteCluster(DeviceExt, ClusterToWrite, NewValue);
     }
   else
     {
-      Status = FAT12WriteCluster (DeviceExt, ClusterToWrite, NewValue);
+      Status = FAT12WriteCluster(DeviceExt, ClusterToWrite, NewValue);
     }
   return(Status);
 }
 
 ULONG
-ClusterToSector (PDEVICE_EXTENSION DeviceExt, unsigned long Cluster)
+ClusterToSector(PDEVICE_EXTENSION DeviceExt,
+		ULONG Cluster)
 /*
  * FUNCTION: Converts the cluster number to a sector number for this physical
  *           device
@@ -759,22 +874,23 @@ VfatRawReadCluster(PDEVICE_EXTENSION DeviceExt,
 
   if (FirstCluster == 1)
     {
-      Status = VfatReadSectors (DeviceExt->StorageDevice,
-				Cluster,
-				DeviceExt->Boot->SectorsPerCluster, 
-				Buffer);
+      Status = VfatReadSectors(DeviceExt->StorageDevice,
+			       Cluster,
+			       DeviceExt->Boot->SectorsPerCluster,
+			       Buffer);
       return(Status);
     }
   else
     {
       ULONG Sector;
       
-      Sector = ClusterToSector (DeviceExt, Cluster);
+      Sector = ClusterToSector(DeviceExt, Cluster);
       
 
-      Status = VfatReadSectors (DeviceExt->StorageDevice,
-				Sector, DeviceExt->Boot->SectorsPerCluster, 
-				Buffer);
+      Status = VfatReadSectors(DeviceExt->StorageDevice,
+			       Sector,
+			       DeviceExt->Boot->SectorsPerCluster,
+			       Buffer);
       return(Status);
     }
 }
@@ -791,8 +907,8 @@ VfatRawWriteCluster(PDEVICE_EXTENSION DeviceExt,
   ULONG Sector;
   NTSTATUS Status;
 
-  DPRINT ("VfatWriteCluster(DeviceExt %x, Buffer %x, Cluster %d)\n",
-	  DeviceExt, Buffer, Cluster);
+  DPRINT("VfatWriteCluster(DeviceExt %x, Buffer %x, Cluster %d)\n",
+	 DeviceExt, Buffer, Cluster);
 
   if (FirstCluster == 1)
     {
@@ -815,27 +931,26 @@ VfatRawWriteCluster(PDEVICE_EXTENSION DeviceExt,
 }
 
 NTSTATUS
-GetNextCluster (PDEVICE_EXTENSION DeviceExt, 
-		ULONG CurrentCluster,
-		PULONG NextCluster,
-		BOOLEAN Extend)
+GetNextCluster(PDEVICE_EXTENSION DeviceExt,
+	       ULONG CurrentCluster,
+	       PULONG NextCluster,
+	       BOOLEAN Extend)
 /*
  * FUNCTION: Retrieve the next cluster depending on the FAT type
  */
 {
   NTSTATUS Status;
-
-
+  
 //  DPRINT ("GetNextCluster(DeviceExt %x, CurrentCluster %x)\n",
 //	  DeviceExt, CurrentCluster);
   
   if (Extend)
     {
-      ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE);
+      ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE);
     }
   else
     {
-      ExAcquireResourceExclusiveLite (&DeviceExt->FatResource, TRUE);
+      ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
     }
   
   /*
@@ -848,7 +963,7 @@ GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 
       if (DeviceExt->FatType == FAT16)
 	{
-	  Status = FAT16FindAvailableCluster (DeviceExt, &NewCluster);
+	  Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster);
 	  if (!NT_SUCCESS(Status))
 	    {
 	      return(Status);
@@ -856,7 +971,7 @@ GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 	}
       else if (DeviceExt->FatType == FAT32)
 	{
-	  Status = FAT32FindAvailableCluster (DeviceExt, &NewCluster);
+	  Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster);
 	  if (!NT_SUCCESS(Status))
 	    {
 	      return(Status);
@@ -864,7 +979,7 @@ GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 	}
       else
 	{
-	  Status = FAT12FindAvailableCluster (DeviceExt, &NewCluster);
+	  Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster);
 	  if (!NT_SUCCESS(Status))
 	    {
 	      return(Status);
@@ -884,15 +999,15 @@ GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 
   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)
     {
@@ -902,7 +1017,7 @@ GetNextCluster (PDEVICE_EXTENSION DeviceExt,
       /* Firstly, find the next available open allocation unit */
       if (DeviceExt->FatType == FAT16)
 	{
-	  Status = FAT16FindAvailableCluster (DeviceExt, &NewCluster);
+	  Status = FAT16FindAvailableCluster(DeviceExt, &NewCluster);
 	  if (!NT_SUCCESS(Status))
 	    {
 	      return(Status);
@@ -910,7 +1025,7 @@ GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 	}
       else if (DeviceExt->FatType == FAT32)
 	{
-	  Status = FAT32FindAvailableCluster (DeviceExt, &NewCluster);
+	  Status = FAT32FindAvailableCluster(DeviceExt, &NewCluster);
 	  if (!NT_SUCCESS(Status))
 	    {
 	      return(Status);
@@ -918,60 +1033,63 @@ GetNextCluster (PDEVICE_EXTENSION DeviceExt,
 	}
       else
 	{
-	  Status = FAT12FindAvailableCluster (DeviceExt, &NewCluster);
+	  Status = FAT12FindAvailableCluster(DeviceExt, &NewCluster);
 	  if (!NT_SUCCESS(Status))
 	    {
 	      return(Status);
 	    }
 	}
       /* 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
          found AU */
-      WriteCluster (DeviceExt, CurrentCluster, NewCluster);
+      WriteCluster(DeviceExt, CurrentCluster, NewCluster);
       *NextCluster = NewCluster;
     }
 
-  ExReleaseResourceLite (&DeviceExt->FatResource);
+  ExReleaseResourceLite(&DeviceExt->FatResource);
 
-  return (Status);
+  return(Status);
 }
 
+
 NTSTATUS
-GetNextSector (PDEVICE_EXTENSION DeviceExt,
-		ULONG CurrentSector,
-		PULONG NextSector,
-		BOOLEAN Extend)
+GetNextSector(PDEVICE_EXTENSION DeviceExt,
+	      ULONG CurrentSector,
+	      PULONG NextSector,
+	      BOOLEAN Extend)
 /* Some functions don't have access to the cluster they're really reading from.
    Maybe this is a dirty solution, but it will allow them to handle fragmentation. */
 {
   NTSTATUS Status;
 
-  DPRINT ("GetNextSector(DeviceExt %x, CurrentSector %x)\n",DeviceExt, CurrentSector);
+  DPRINT("GetNextSector(DeviceExt %x, CurrentSector %x)\n",
+	 DeviceExt,
+	 CurrentSector);
   if (CurrentSector<DeviceExt->dataStart || ((CurrentSector - DeviceExt->dataStart + 1) % DeviceExt -> Boot -> SectorsPerCluster))
   /* Basically, if the next sequential sector would be on a cluster border, then we'll need to check in the FAT */
     {
-       (*NextSector)=CurrentSector+1;
-       return (STATUS_SUCCESS);
+      (*NextSector)=CurrentSector+1;
+      return (STATUS_SUCCESS);
     }
   else
-  {
-       CurrentSector = (CurrentSector - DeviceExt->dataStart) / DeviceExt -> Boot -> SectorsPerCluster + 2;
+    {
+      CurrentSector = (CurrentSector - DeviceExt->dataStart) / DeviceExt -> Boot -> SectorsPerCluster + 2;
 
-       Status = GetNextCluster(DeviceExt, CurrentSector, NextSector, Extend);
-       if (!NT_SUCCESS(Status))
-         {
-	   return(Status);
-	 }
-       if ((*NextSector) == 0 || (*NextSector) == 0xffffffff)
-       {
-         /* The caller wants to know a sector. These FAT codes don't correspond to any sector. */
-         return (STATUS_UNSUCCESSFUL);
-       }
+      Status = GetNextCluster(DeviceExt, CurrentSector, NextSector, Extend);
+      if (!NT_SUCCESS(Status))
+	{
+	  return(Status);
+	}
+      if ((*NextSector) == 0 || (*NextSector) == 0xffffffff)
+	{
+	  /* The caller wants to know a sector. These FAT codes don't correspond to any sector. */
+	  return(STATUS_UNSUCCESSFUL);
+	}
 
-       (*NextSector)=ClusterToSector(DeviceExt,(*NextSector));
-       return (STATUS_SUCCESS);
-  }
+      (*NextSector) = ClusterToSector(DeviceExt,(*NextSector));
+      return(STATUS_SUCCESS);
+    }
 }
 
 /* EOF */
diff --git a/reactos/drivers/fs/vfat/fcb.c b/reactos/drivers/fs/vfat/fcb.c
index 72615fb38bc..d5b218d2fe5 100644
--- a/reactos/drivers/fs/vfat/fcb.c
+++ b/reactos/drivers/fs/vfat/fcb.c
@@ -1,4 +1,4 @@
-/* $Id: fcb.c,v 1.5 2001/07/14 18:21:23 ekohl Exp $
+/* $Id: fcb.c,v 1.6 2001/07/20 08:00:20 ekohl Exp $
  *
  *
  * FILE:             fcb.c
@@ -27,7 +27,8 @@
 
 /*  --------------------------------------------------------  PUBLICS  */
 
-PVFATFCB  vfatNewFCB (PWCHAR pFileName)
+PVFATFCB
+vfatNewFCB(PWCHAR pFileName)
 {
   PVFATFCB  rcFCB;
 
@@ -49,24 +50,26 @@ PVFATFCB  vfatNewFCB (PWCHAR pFileName)
   return  rcFCB;
 }
 
-void  vfatDestroyFCB (PVFATFCB  pFCB)
+VOID
+vfatDestroyFCB(PVFATFCB  pFCB)
 {
   ExFreePool (pFCB);
 }
 
 BOOL
-vfatFCBIsDirectory (PDEVICE_EXTENSION pVCB, PVFATFCB FCB)
+vfatFCBIsDirectory(PDEVICE_EXTENSION pVCB, PVFATFCB FCB)
 {
   return  FCB->entry.Attrib & FILE_ATTRIBUTE_DIRECTORY;
 }
 
 BOOL
-vfatFCBIsRoot (PVFATFCB FCB)
+vfatFCBIsRoot(PVFATFCB FCB)
 {
   return  wcscmp (FCB->PathName, L"\\") == 0;
 }
 
-void  vfatGrabFCB (PDEVICE_EXTENSION  pVCB, PVFATFCB  pFCB)
+VOID
+vfatGrabFCB(PDEVICE_EXTENSION  pVCB, PVFATFCB  pFCB)
 {
   KIRQL  oldIrql;
 
@@ -80,7 +83,8 @@ void  vfatGrabFCB (PDEVICE_EXTENSION  pVCB, PVFATFCB  pFCB)
   KeReleaseSpinLock (&pVCB->FcbListLock, oldIrql);
 }
 
-void  vfatReleaseFCB (PDEVICE_EXTENSION  pVCB,  PVFATFCB  pFCB)
+VOID
+vfatReleaseFCB(PDEVICE_EXTENSION  pVCB,  PVFATFCB  pFCB)
 {
   KIRQL  oldIrql;
 
@@ -100,7 +104,8 @@ void  vfatReleaseFCB (PDEVICE_EXTENSION  pVCB,  PVFATFCB  pFCB)
   KeReleaseSpinLock (&pVCB->FcbListLock, oldIrql);
 }
 
-void  vfatAddFCBToTable (PDEVICE_EXTENSION  pVCB,  PVFATFCB  pFCB)
+VOID
+vfatAddFCBToTable(PDEVICE_EXTENSION  pVCB,  PVFATFCB  pFCB)
 {
   KIRQL  oldIrql;
 
@@ -110,8 +115,8 @@ void  vfatAddFCBToTable (PDEVICE_EXTENSION  pVCB,  PVFATFCB  pFCB)
   KeReleaseSpinLock (&pVCB->FcbListLock, oldIrql);
 }
 
-PVFATFCB  
-vfatGrabFCBFromTable (PDEVICE_EXTENSION  pVCB, PWSTR  pFileName)
+PVFATFCB
+vfatGrabFCBFromTable(PDEVICE_EXTENSION  pVCB, PWSTR  pFileName)
 {
   KIRQL  oldIrql;
   PVFATFCB  rcFCB;
@@ -184,12 +189,12 @@ vfatFCBInitializeCache (PVCB  vcb, PVFATFCB  fcb)
 }
 
 NTSTATUS
-vfatRequestAndValidateRegion (PDEVICE_EXTENSION  pDeviceExt, 
-                              PVFATFCB  pFCB, 
-                              ULONG  pOffset,
-                              PVOID * pBuffer,
-                              PCACHE_SEGMENT * pCacheSegment,
-                              BOOL  pExtend)
+vfatRequestAndValidateRegion(PDEVICE_EXTENSION pDeviceExt,
+			     PVFATFCB pFCB,
+			     ULONG  pOffset,
+			     PVOID * pBuffer,
+			     PCACHE_SEGMENT * pCacheSegment,
+			     BOOL pExtend)
 {
   NTSTATUS  status;
   BOOLEAN  valid;
@@ -197,7 +202,7 @@ vfatRequestAndValidateRegion (PDEVICE_EXTENSION  pDeviceExt,
   ULONG  currentCluster;
   ULONG  i;
 
-  status = CcRosRequestCacheSegment(pFCB->RFCB.Bcb, 
+  status = CcRosRequestCacheSegment(pFCB->RFCB.Bcb,
                                     pOffset,
                                     pBuffer,
                                     &valid,
@@ -275,34 +280,34 @@ vfatReleaseRegion (PDEVICE_EXTENSION  pDeviceExt,
   return  CcRosReleaseCacheSegment (pFCB->RFCB.Bcb, pCacheSegment, TRUE);
 }
 
-PVFATFCB  
-vfatMakeRootFCB (PDEVICE_EXTENSION  pVCB)
+PVFATFCB
+vfatMakeRootFCB(PDEVICE_EXTENSION  pVCB)
 {
   PVFATFCB  FCB;
 
-  FCB = vfatNewFCB (L"\\");
-  memset (FCB->entry.Filename, ' ', 11);
+  FCB = vfatNewFCB(L"\\");
+  memset(FCB->entry.Filename, ' ', 11);
   FCB->entry.FileSize = pVCB->rootDirectorySectors * BLOCKSIZE;
   FCB->entry.Attrib = FILE_ATTRIBUTE_DIRECTORY;
   if (pVCB->FatType == FAT32)
-  {
-    FCB->entry.FirstCluster = 2;
-  }
+    {
+      FCB->entry.FirstCluster = ((struct _BootSector32*)(pVCB->Boot))->RootCluster;
+    }
   else
-  {
-    FCB->entry.FirstCluster = 1;
-  }
+    {
+      FCB->entry.FirstCluster = 1;
+    }
   FCB->RefCount = 1;
 
-  vfatFCBInitializeCache (pVCB, FCB);
-  vfatAddFCBToTable (pVCB, FCB);
+  vfatFCBInitializeCache(pVCB, FCB);
+  vfatAddFCBToTable(pVCB, FCB);
   vfatGrabFCB(pVCB, FCB);
 
-  return  FCB;
+  return(FCB);
 }
 
-PVFATFCB  
-vfatOpenRootFCB (PDEVICE_EXTENSION  pVCB)
+PVFATFCB
+vfatOpenRootFCB(PDEVICE_EXTENSION  pVCB)
 {
   PVFATFCB  FCB;
 
@@ -316,16 +321,16 @@ vfatOpenRootFCB (PDEVICE_EXTENSION  pVCB)
 }
 
 NTSTATUS
-vfatMakeFCBFromDirEntry (PVCB  vcb,
-                         PVFATFCB  directoryFCB,
-                         PWSTR  longName,
-                         PFAT_DIR_ENTRY  dirEntry,
-                         PVFATFCB * fileFCB)
+vfatMakeFCBFromDirEntry(PVCB  vcb,
+			PVFATFCB  directoryFCB,
+			PWSTR  longName,
+			PFAT_DIR_ENTRY  dirEntry,
+			PVFATFCB * fileFCB)
 {
   PVFATFCB  rcFCB;
   WCHAR  pathName [MAX_PATH];
 
-  if (longName [0] != 0 && wcslen (directoryFCB->PathName) + 
+  if (longName [0] != 0 && wcslen (directoryFCB->PathName) +
         sizeof(WCHAR) + wcslen (longName) > MAX_PATH)
   {
     return  STATUS_OBJECT_NAME_INVALID;
diff --git a/reactos/drivers/fs/vfat/iface.c b/reactos/drivers/fs/vfat/iface.c
index 18fac831b05..09f0cc67749 100644
--- a/reactos/drivers/fs/vfat/iface.c
+++ b/reactos/drivers/fs/vfat/iface.c
@@ -1,4 +1,4 @@
-/* $Id: iface.c,v 1.56 2001/07/17 07:48:06 ekohl Exp $
+/* $Id: iface.c,v 1.57 2001/07/20 08:00:20 ekohl Exp $
  *
  * COPYRIGHT:        See COPYING in the top level directory
  * PROJECT:          ReactOS kernel
@@ -58,7 +58,7 @@ VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount,
    Status = VfatReadSectors(DeviceToMount, 0, 1, (UCHAR *) Boot);
    if (!NT_SUCCESS(Status))
      {
-	return Status;
+	return(Status);
      }
 
    DPRINT("Boot->SysType %.5s\n", Boot->SysType);
@@ -75,12 +75,13 @@ VfatHasFileSystem(PDEVICE_OBJECT DeviceToMount,
 
    ExFreePool(Boot);
 
-   return STATUS_SUCCESS;
+   return(STATUS_SUCCESS);
 }
 
 
 static NTSTATUS
-VfatMountDevice (PDEVICE_EXTENSION DeviceExt, PDEVICE_OBJECT DeviceToMount)
+VfatMountDevice(PDEVICE_EXTENSION DeviceExt,
+		PDEVICE_OBJECT DeviceToMount)
 /*
  * FUNCTION: Mounts the device
  */
@@ -95,7 +96,7 @@ VfatMountDevice (PDEVICE_EXTENSION DeviceExt, PDEVICE_OBJECT DeviceToMount)
    Status = VfatReadSectors(DeviceToMount, 0, 1, (UCHAR *) DeviceExt->Boot);
    if (!NT_SUCCESS(Status))
      {
-	return Status;
+	return(Status);
      }
 
    DeviceExt->FATStart = DeviceExt->Boot->ReservedSectors;
@@ -136,10 +137,10 @@ VfatMountDevice (PDEVICE_EXTENSION DeviceExt, PDEVICE_OBJECT DeviceToMount)
 	DbgPrint("FAT32\n");
 	DeviceExt->FatType = FAT32;
 	DeviceExt->rootDirectorySectors = DeviceExt->Boot->SectorsPerCluster;
-	DeviceExt->rootStart =
-	  DeviceExt->FATStart + DeviceExt->Boot->FATCount
+	DeviceExt->dataStart = DeviceExt->FATStart + DeviceExt->Boot->FATCount
 	  * ((struct _BootSector32 *) (DeviceExt->Boot))->FATSectors32;
-        DeviceExt->dataStart = DeviceExt->rootStart;
+	DeviceExt->rootStart = ClusterToSector (DeviceExt,
+	  ((struct _BootSector32 *)(DeviceExt->Boot))->RootCluster);
      }
    else
      {
@@ -147,7 +148,7 @@ VfatMountDevice (PDEVICE_EXTENSION DeviceExt, PDEVICE_OBJECT DeviceToMount)
 	DeviceExt->FatType = FAT16;
      }
 
-   return STATUS_SUCCESS;
+   return(STATUS_SUCCESS);
 }
 
 
@@ -157,103 +158,128 @@ VfatMount (PDEVICE_OBJECT DeviceToMount)
  * FUNCTION: Mount the filesystem
  */
 {
-   PDEVICE_OBJECT DeviceObject;
-   PDEVICE_EXTENSION DeviceExt;
-   BOOLEAN RecognizedFS;
-   NTSTATUS Status;
+  PDEVICE_OBJECT DeviceObject;
+  PDEVICE_EXTENSION DeviceExt;
+  BOOLEAN RecognizedFS;
+  NTSTATUS Status;
 
-   Status = VfatHasFileSystem (DeviceToMount, &RecognizedFS);
-   if (!NT_SUCCESS(Status))
-     {
-	return Status;
-     }
+  Status = VfatHasFileSystem (DeviceToMount, &RecognizedFS);
+  if (!NT_SUCCESS(Status))
+    {
+      return(Status);
+    }
 
-   if (RecognizedFS == FALSE)
-     {
-	DPRINT("VFAT: Unrecognized Volume\n");
-	return STATUS_UNRECOGNIZED_VOLUME;
-     }
+  if (RecognizedFS == FALSE)
+    {
+      DPRINT("VFAT: Unrecognized Volume\n");
+      return(STATUS_UNRECOGNIZED_VOLUME);
+    }
 
-   DPRINT("VFAT: Recognized volume\n");
+  DPRINT("VFAT: Recognized volume\n");
 
-   Status = IoCreateDevice(VfatDriverObject,
-			   sizeof (DEVICE_EXTENSION),
-			   NULL,
-			   FILE_DEVICE_FILE_SYSTEM,
-			   0,
-			   FALSE,
-			   &DeviceObject);
-   if (!NT_SUCCESS(Status))
-     {
-	return Status;
-     }
+  Status = IoCreateDevice(VfatDriverObject,
+			  sizeof (DEVICE_EXTENSION),
+			  NULL,
+			  FILE_DEVICE_FILE_SYSTEM,
+			  0,
+			  FALSE,
+			  &DeviceObject);
+  if (!NT_SUCCESS(Status))
+    {
+      return(Status);
+    }
 
-   DeviceObject->Flags = DeviceObject->Flags | DO_DIRECT_IO;
-   DeviceExt = (PVOID) DeviceObject->DeviceExtension;
-   /* use same vpb as device disk */
-   DeviceObject->Vpb = DeviceToMount->Vpb;
-   Status = VfatMountDevice (DeviceExt, DeviceToMount);
-   if (!NT_SUCCESS(Status))
-     {
-	/* FIXME: delete device object */
-	return Status;
-     }
+  DeviceObject->Flags = DeviceObject->Flags | DO_DIRECT_IO;
+  DeviceExt = (PVOID) DeviceObject->DeviceExtension;
+  /* use same vpb as device disk */
+  DeviceObject->Vpb = DeviceToMount->Vpb;
+  Status = VfatMountDevice(DeviceExt,
+			   DeviceToMount);
+  if (!NT_SUCCESS(Status))
+    {
+      /* FIXME: delete device object */
+      return(Status);
+    }
 
-   DeviceObject->Vpb->Flags |= VPB_MOUNTED;
-   DeviceExt->StorageDevice = IoAttachDeviceToDeviceStack(DeviceObject,
-							  DeviceToMount);
-   DeviceExt->StreamStorageDevice = IoCreateStreamFileObject(NULL,
-							     DeviceExt->StorageDevice);
-   if (DeviceExt->FatType == FAT16)
-     Status = CcRosInitializeFileCache(DeviceExt->StreamStorageDevice,
-				       &DeviceExt->StorageBcb,
-				       CACHEPAGESIZE(DeviceExt));
-   else
-     Status = CcRosInitializeFileCache(DeviceExt->StreamStorageDevice,
-				       &DeviceExt->StorageBcb,
-				       PAGESIZE);
-   if (!NT_SUCCESS(Status))
-     {
-	/* FIXME: delete device object */
-	return Status;
-     }
+#if 1
+  DbgPrint("BytesPerSector:     %d\n", DeviceExt->Boot->BytesPerSector);
+  DbgPrint("SectorsPerCluster:  %d\n", DeviceExt->Boot->SectorsPerCluster);
+  DbgPrint("ReservedSectors:    %d\n", DeviceExt->Boot->ReservedSectors);
+  DbgPrint("FATCount:           %d\n", DeviceExt->Boot->FATCount);
+  DbgPrint("RootEntries:        %d\n", DeviceExt->Boot->RootEntries);
+  DbgPrint("Sectors:            %d\n", DeviceExt->Boot->Sectors);
+  DbgPrint("FATSectors:         %d\n", DeviceExt->Boot->FATSectors);
+  DbgPrint("SectorsPerTrack:    %d\n", DeviceExt->Boot->SectorsPerTrack);
+  DbgPrint("Heads:              %d\n", DeviceExt->Boot->Heads);
+  DbgPrint("HiddenSectors:      %d\n", DeviceExt->Boot->HiddenSectors);
+  DbgPrint("SectorsHuge:        %d\n", DeviceExt->Boot->SectorsHuge);
+  DbgPrint("RootStart:          %d\n", DeviceExt->rootStart);
+  DbgPrint("DataStart:          %d\n", DeviceExt->dataStart);
+  if (DeviceExt->FatType == FAT32)
+    {
+      DbgPrint("FATSectors32:       %d\n",
+	       ((struct _BootSector32*)(DeviceExt->Boot))->FATSectors32);
+      DbgPrint("RootCluster:        %d\n",
+	       ((struct _BootSector32*)(DeviceExt->Boot))->RootCluster);
+      DbgPrint("FSInfoSector:       %d\n",
+	       ((struct _BootSector32*)(DeviceExt->Boot))->FSInfoSector);
+      DbgPrint("BootBackup:         %d\n",
+	       ((struct _BootSector32*)(DeviceExt->Boot))->BootBackup);
+    }
+#endif
 
-   if (DeviceExt->FatType == FAT12)
-     {
-	DeviceExt->Fat12StorageDevice = 
-	  IoCreateStreamFileObject(NULL, DeviceExt->StorageDevice);
-	Status = CcRosInitializeFileCache(DeviceExt->Fat12StorageDevice,
-				       &DeviceExt->Fat12StorageBcb,
-				       PAGESIZE * 3);
-	if (!NT_SUCCESS(Status))
-	  {
-	     /* FIXME: delete device object */
-	     return Status;
-	  }
-     }
-   ExInitializeResourceLite (&DeviceExt->DirResource);
-   ExInitializeResourceLite (&DeviceExt->FatResource);
+  DeviceObject->Vpb->Flags |= VPB_MOUNTED;
+  DeviceExt->StorageDevice = IoAttachDeviceToDeviceStack(DeviceObject,
+							 DeviceToMount);
+  DeviceExt->StreamStorageDevice = IoCreateStreamFileObject(NULL,
+							    DeviceExt->StorageDevice);
+  Status = CcRosInitializeFileCache(DeviceExt->StreamStorageDevice,
+				    &DeviceExt->StorageBcb,
+				    CACHEPAGESIZE(DeviceExt));
+  if (!NT_SUCCESS(Status))
+    {
+      /* FIXME: delete device object */
+      return(Status);
+    }
 
-   KeInitializeSpinLock (&DeviceExt->FcbListLock);
-   InitializeListHead (&DeviceExt->FcbListHead);
+  if (DeviceExt->FatType == FAT12)
+    {
+      DeviceExt->Fat12StorageDevice =
+	IoCreateStreamFileObject(NULL, DeviceExt->StorageDevice);
+      Status = CcRosInitializeFileCache(DeviceExt->Fat12StorageDevice,
+				        &DeviceExt->Fat12StorageBcb,
+				        PAGESIZE * 3);
+      if (!NT_SUCCESS(Status))
+	{
+	  /* FIXME: delete device object */
+	  return(Status);
+	}
+    }
+  ExInitializeResourceLite(&DeviceExt->DirResource);
+  ExInitializeResourceLite(&DeviceExt->FatResource);
 
-   /* read serial number */
-   if (DeviceExt->FatType == FAT12 || DeviceExt->FatType == FAT16)
-     DeviceObject->Vpb->SerialNumber =
-       ((struct _BootSector *) (DeviceExt->Boot))->VolumeID;
-   else if (DeviceExt->FatType == FAT32)
-     DeviceObject->Vpb->SerialNumber =
-       ((struct _BootSector32 *) (DeviceExt->Boot))->VolumeID;
+  KeInitializeSpinLock(&DeviceExt->FcbListLock);
+  InitializeListHead(&DeviceExt->FcbListHead);
 
-   /* read volume label */
-   ReadVolumeLabel(DeviceExt, DeviceObject->Vpb);
+  /* read serial number */
+  if (DeviceExt->FatType == FAT12 || DeviceExt->FatType == FAT16)
+    DeviceObject->Vpb->SerialNumber =
+      ((struct _BootSector *) (DeviceExt->Boot))->VolumeID;
+  else if (DeviceExt->FatType == FAT32)
+    DeviceObject->Vpb->SerialNumber =
+      ((struct _BootSector32 *) (DeviceExt->Boot))->VolumeID;
 
-   return STATUS_SUCCESS;
+  /* read volume label */
+  ReadVolumeLabel(DeviceExt,
+		  DeviceObject->Vpb);
+
+  return(STATUS_SUCCESS);
 }
 
 
 NTSTATUS STDCALL
-VfatFileSystemControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
+VfatFileSystemControl(PDEVICE_OBJECT DeviceObject,
+		      PIRP Irp)
 /*
  * FUNCTION: File system control
  */
diff --git a/reactos/drivers/fs/vfat/rw.c b/reactos/drivers/fs/vfat/rw.c
index 7b537ec75a1..bf64f5c8091 100644
--- a/reactos/drivers/fs/vfat/rw.c
+++ b/reactos/drivers/fs/vfat/rw.c
@@ -1,5 +1,5 @@
 
-/* $Id: rw.c,v 1.24 2001/05/04 01:21:45 rex Exp $
+/* $Id: rw.c,v 1.25 2001/07/20 08:00:20 ekohl Exp $
  *
  * COPYRIGHT:        See COPYING in the top level directory
  * PROJECT:          ReactOS kernel
@@ -369,9 +369,11 @@ VfatReadFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
   assert (FileObject != NULL);
   assert (FileObject->FsContext != NULL);
 
-  DPRINT ("VfatReadFile(DeviceExt %x, FileObject %x, Buffer %x, "
-	  "Length %d, ReadOffset 0x%x)\n", DeviceExt, FileObject, Buffer,
-	  Length, ReadOffset);
+  DPRINT("VfatReadFile(DeviceExt %x, FileObject %x, Buffer %x, "
+	 "Length %d, ReadOffset 0x%x)\n", DeviceExt, FileObject, Buffer,
+	 Length, ReadOffset);
+
+  *LengthRead = 0;
 
   Fcb = ((PVFATCCB)FileObject->FsContext2)->pFcb;
 
@@ -379,7 +381,7 @@ VfatReadFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
    * Find the first cluster
    */
   if (DeviceExt->FatType == FAT32)
-    CurrentCluster = Fcb->entry.FirstCluster 
+    CurrentCluster = Fcb->entry.FirstCluster
       + Fcb->entry.FirstClusterHigh * 65536;
   else
     CurrentCluster = Fcb->entry.FirstCluster;
@@ -412,15 +414,13 @@ VfatReadFile (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
       ChunkSize = PAGESIZE;
     }
 
-  *LengthRead = 0;  
-
   /*
    * Find the cluster to start the read from
    * FIXME: Optimize by remembering the last cluster read and using if 
    * possible.
    */
-  Status = OffsetToCluster(DeviceExt, 
-			   FirstCluster, 
+  Status = OffsetToCluster(DeviceExt,
+			   FirstCluster,
 			   ROUND_DOWN(ReadOffset, ChunkSize),
 			   &CurrentCluster,
 			   FALSE);
diff --git a/reactos/drivers/fs/vfat/vfat.h b/reactos/drivers/fs/vfat/vfat.h
index 05f9b18ebfc..7c86ff1ddaa 100644
--- a/reactos/drivers/fs/vfat/vfat.h
+++ b/reactos/drivers/fs/vfat/vfat.h
@@ -1,8 +1,9 @@
-/* $Id: vfat.h,v 1.32 2001/07/05 01:51:53 rex Exp $ */
+/* $Id: vfat.h,v 1.33 2001/07/20 08:00:21 ekohl Exp $ */
 
 #include <ddk/ntifs.h>
 
-struct _BootSector { 
+struct _BootSector
+{
   unsigned char  magic0, res0, magic1;
   unsigned char  OEMName[8];
   unsigned short BytesPerSector;
@@ -19,22 +20,43 @@ struct _BootSector {
   unsigned char  Res2[450];
 } __attribute__((packed));
 
-struct _BootSector32 {
-  unsigned char  magic0, res0, magic1;
-  unsigned char  OEMName[8];
-  unsigned short BytesPerSector;
-  unsigned char  SectorsPerCluster;
-  unsigned short ReservedSectors;
-  unsigned char  FATCount;
-  unsigned short RootEntries, Sectors;
-  unsigned char  Media;
-  unsigned short FATSectors, SectorsPerTrack, Heads;
-  unsigned long  HiddenSectors, SectorsHuge;
-  unsigned long  FATSectors32;
-  unsigned char  x[27];
-  unsigned long  VolumeID;
-  unsigned char  VolumeLabel[11], SysType[8];
-  unsigned char  Res2[422];
+struct _BootSector32
+{
+  unsigned char  magic0, res0, magic1;			// 0
+  unsigned char  OEMName[8];				// 3
+  unsigned short BytesPerSector;			// 11
+  unsigned char  SectorsPerCluster;			// 13
+  unsigned short ReservedSectors;			// 14
+  unsigned char  FATCount;				// 16
+  unsigned short RootEntries, Sectors;			// 17
+  unsigned char  Media;					// 21
+  unsigned short FATSectors, SectorsPerTrack, Heads;	// 22
+  unsigned long  HiddenSectors, SectorsHuge;		// 28
+  unsigned long  FATSectors32;				// 36
+  unsigned short ExtFlag;				// 40
+  unsigned short FSVersion;				// 42
+  unsigned long  RootCluster;				// 44
+  unsigned short FSInfoSector;				// 48
+  unsigned long  BootBackup;				// 50
+  unsigned char  Res3[10];				// 54
+  unsigned char  Drive;					// 64
+  unsigned char  Res4;					// 65
+  unsigned char  ExtBootSignature;			// 66
+  unsigned long  VolumeID;				// 67
+  unsigned char  VolumeLabel[11], SysType[8];		// 71
+  unsigned char  Res2[418];				// 90
+  unsigned long  Signature1;				// 508
+} __attribute__((packed));
+
+struct _BootBackupSector
+{
+  unsigned long  ExtBootSignature2;			// 0
+  unsigned char  Res6[480];				// 4
+  unsigned long  FSINFOSignature;			// 484
+  unsigned long  FreeCluster;				// 488
+  unsigned long  NextCluster;				// 492
+  unsigned char  Res7[12];				// 496
+  unsigned long  Signatur2;				// 508
 } __attribute__((packed));
 
 typedef struct _BootSector BootSector;
diff --git a/reactos/drivers/fs/vfat/volume.c b/reactos/drivers/fs/vfat/volume.c
index a922e115f5d..907b9c27828 100644
--- a/reactos/drivers/fs/vfat/volume.c
+++ b/reactos/drivers/fs/vfat/volume.c
@@ -1,4 +1,4 @@
-/* $Id: volume.c,v 1.10 2001/06/14 10:02:59 ekohl Exp $
+/* $Id: volume.c,v 1.11 2001/07/20 08:00:21 ekohl Exp $
  *
  * COPYRIGHT:        See COPYING in the top level directory
  * PROJECT:          ReactOS kernel
@@ -124,15 +124,8 @@ FsdGetFsSizeInformation(PDEVICE_OBJECT DeviceObject,
       FsSizeInfo->TotalAllocationUnits.QuadPart = ((BootSect->Sectors ? BootSect->Sectors : BootSect->SectorsHuge)-DeviceExt->dataStart)/BootSect->SectorsPerCluster;
 
       if (DeviceExt->FatType == FAT16)
-#if 0
 	Status = FAT16CountAvailableClusters(DeviceExt,
 					     &FsSizeInfo->AvailableAllocationUnits);
-#else
-	{
-	  FsSizeInfo->AvailableAllocationUnits.QuadPart = 0;
-	  Status = STATUS_SUCCESS;
-	}
-#endif
       else
 	Status = FAT12CountAvailableClusters(DeviceExt,
 					     &FsSizeInfo->AvailableAllocationUnits);
@@ -177,9 +170,9 @@ static NTSTATUS
 FsdSetFsLabelInformation(PDEVICE_OBJECT DeviceObject,
 			 PFILE_FS_LABEL_INFORMATION FsLabelInfo)
 {
-   DPRINT("FsdSetFsLabelInformation()\n");
-   
-   return STATUS_NOT_IMPLEMENTED;
+  DPRINT("FsdSetFsLabelInformation()\n");
+  
+  return(STATUS_NOT_IMPLEMENTED);
 }
 
 
@@ -268,50 +261,50 @@ VfatSetVolumeInformation(PDEVICE_OBJECT DeviceObject,
  * FUNCTION: Set the specified volume information
  */
 {
-   PIO_STACK_LOCATION Stack;
-   FS_INFORMATION_CLASS FsInformationClass;
-//   PFILE_OBJECT FileObject = NULL;
-//   PVFATFCB FCB = NULL;
-   NTSTATUS Status = STATUS_SUCCESS;
-   PVOID SystemBuffer;
-   ULONG BufferLength;
+  PIO_STACK_LOCATION Stack;
+  FS_INFORMATION_CLASS FsInformationClass;
+//  PFILE_OBJECT FileObject = NULL;
+//  PVFATFCB FCB = NULL;
+  NTSTATUS Status = STATUS_SUCCESS;
+  PVOID SystemBuffer;
+  ULONG BufferLength;
 
-   /* PRECONDITION */
-   assert(DeviceObject != NULL);
-   assert(Irp != NULL);
+  /* PRECONDITION */
+  assert(DeviceObject != NULL);
+  assert(Irp != NULL);
 
-   DPRINT("FsdSetVolumeInformation(DeviceObject %x, Irp %x)\n",
-	  DeviceObject,
-	  Irp);
+  DPRINT("FsdSetVolumeInformation(DeviceObject %x, Irp %x)\n",
+	 DeviceObject,
+	 Irp);
 
-   Stack = IoGetCurrentIrpStackLocation (Irp);
-   FsInformationClass = Stack->Parameters.SetVolume.FsInformationClass;
-   BufferLength = Stack->Parameters.SetVolume.Length;
-   SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
-//   FileObject = Stack->FileObject;
-//   FCB = ((PVFATCCB) (FileObject->FsContext2))->pFcb;
+  Stack = IoGetCurrentIrpStackLocation(Irp);
+  FsInformationClass = Stack->Parameters.SetVolume.FsInformationClass;
+  BufferLength = Stack->Parameters.SetVolume.Length;
+  SystemBuffer = Irp->AssociatedIrp.SystemBuffer;
+//  FileObject = Stack->FileObject;
+//  FCB = ((PVFATCCB) (FileObject->FsContext2))->pFcb;
 
-   DPRINT("FsInformationClass %d\n", FsInformationClass);
-   DPRINT("BufferLength %d\n", BufferLength);
-   DPRINT("SystemBuffer %x\n", SystemBuffer);
+  DPRINT("FsInformationClass %d\n", FsInformationClass);
+  DPRINT("BufferLength %d\n", BufferLength);
+  DPRINT("SystemBuffer %x\n", SystemBuffer);
 
-   switch (FsInformationClass)
-     {
-     case FileFsLabelInformation:
-       Status = FsdSetFsLabelInformation(DeviceObject,
-					 SystemBuffer);
-       break;
+  switch(FsInformationClass)
+    {
+    case FileFsLabelInformation:
+      Status = FsdSetFsLabelInformation(DeviceObject,
+					SystemBuffer);
+      break;
 
-     default:
-       Status = STATUS_NOT_SUPPORTED;
-     }
+    default:
+      Status = STATUS_NOT_SUPPORTED;
+    }
 
-   Irp->IoStatus.Status = Status;
-   Irp->IoStatus.Information = 0;
-   IoCompleteRequest(Irp,
-		     IO_NO_INCREMENT);
+  Irp->IoStatus.Status = Status;
+  Irp->IoStatus.Information = 0;
+  IoCompleteRequest(Irp,
+		    IO_NO_INCREMENT);
 
-   return(Status);
+  return(Status);
 }
 
 /* EOF */