diff --git a/drivers/filesystems/fastfat/blockdev.c b/drivers/filesystems/fastfat/blockdev.c
index 2dc962f..c5db2aa 100644
--- a/drivers/filesystems/fastfat/blockdev.c
+++ b/drivers/filesystems/fastfat/blockdev.c
@@ -248,6 +248,86 @@ again:
     return Status;
 }
 
+NTSTATUS
+VfatWriteDisk(
+    IN PDEVICE_OBJECT pDeviceObject,
+    IN PLARGE_INTEGER WriteOffset,
+    IN ULONG WriteLength,
+    IN OUT PUCHAR Buffer,
+    IN BOOLEAN Override)
+{
+    PIO_STACK_LOCATION Stack;
+    PIRP Irp;
+    IO_STATUS_BLOCK IoStatus;
+    KEVENT Event;
+    NTSTATUS Status;
+
+again:
+    KeInitializeEvent(&Event, NotificationEvent, FALSE);
+
+    DPRINT("VfatWriteDisk(pDeviceObject %p, Offset %I64x, Length %u, Buffer %p)\n",
+           pDeviceObject, WriteOffset->QuadPart, WriteLength, Buffer);
+
+    DPRINT ("Building synchronous FSD Request...\n");
+    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
+                                       pDeviceObject,
+                                       Buffer,
+                                       WriteLength,
+                                       WriteOffset,
+                                       &Event,
+                                       &IoStatus);
+    if (Irp == NULL)
+    {
+        DPRINT("IoBuildSynchronousFsdRequest failed\n");
+        return STATUS_UNSUCCESSFUL;
+    }
+
+    if (Override)
+    {
+        Stack = IoGetNextIrpStackLocation(Irp);
+        Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
+    }
+
+    DPRINT("Calling IO Driver... with irp %p\n", Irp);
+    Status = IoCallDriver (pDeviceObject, Irp);
+
+    DPRINT("Waiting for IO Operation for %p\n", Irp);
+    if (Status == STATUS_PENDING)
+    {
+        DPRINT("Operation pending\n");
+        KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
+        DPRINT("Getting IO Status... for %p\n", Irp);
+        Status = IoStatus.Status;
+    }
+
+    if (Status == STATUS_VERIFY_REQUIRED)
+    {
+        PDEVICE_OBJECT DeviceToVerify;
+
+        DPRINT1 ("Media change detected!\n");
+
+        /* Find the device to verify and reset the thread field to empty value again. */
+        DeviceToVerify = IoGetDeviceToVerify(PsGetCurrentThread());
+        IoSetDeviceToVerify(PsGetCurrentThread(), NULL);
+        Status = IoVerifyVolume(DeviceToVerify,
+                                FALSE);
+        if (NT_SUCCESS(Status))
+        {
+            DPRINT1("Volume verification successful; Reissuing read request\n");
+            goto again;
+        }
+    }
+
+    if (!NT_SUCCESS(Status))
+    {
+        DPRINT("IO failed!!! VfatWriteDisk : Error code: %x\n", Status);
+        DPRINT("(pDeviceObject %p, Offset %I64x, Size %u, Buffer %p\n",
+               pDeviceObject, WriteOffset->QuadPart, WriteLength, Buffer);
+        return Status;
+    }
+    DPRINT("Block request succeeded for %p\n", Irp);
+    return STATUS_SUCCESS;
+}
 
 NTSTATUS
 VfatWriteDiskPartial(
diff --git a/drivers/filesystems/fastfat/fat.c b/drivers/filesystems/fastfat/fat.c
index 553d9ee..6c48f7c 100644
--- a/drivers/filesystems/fastfat/fat.c
+++ b/drivers/filesystems/fastfat/fat.c
@@ -19,6 +19,8 @@
 #define  CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGE_SIZE ? \
 		   (pDeviceExt)->FatInfo.BytesPerCluster : PAGE_SIZE)
 
+#define VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+
 /* FUNCTIONS ****************************************************************/
 
 /*
@@ -818,4 +820,333 @@ GetNextClusterExtend(
     return Status;
 }
 
+/*
+ * FUNCTION: Retrieve the dirty status
+ */
+NTSTATUS
+GetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    PBOOLEAN DirtyStatus)
+{
+    NTSTATUS Status;
+
+    DPRINT1("GetDirtyStatus(DeviceExt %p)\n", DeviceExt);
+
+    if (DeviceExt->FatInfo.FatType == FAT12)
+    {
+        *DirtyStatus = FALSE;
+        return STATUS_SUCCESS;
+    }
+
+    ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE);
+    Status = DeviceExt->GetDirtyStatus(DeviceExt, DirtyStatus);
+    ExReleaseResourceLite(&DeviceExt->FatResource);
+
+    return Status;
+}
+
+NTSTATUS
+FAT16GetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    PBOOLEAN DirtyStatus)
+{
+    LARGE_INTEGER Offset;
+    ULONG Length;
+#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    NTSTATUS Status;
+#else
+    PVOID Context;
+#endif
+    struct _BootSector * Sector;
+
+    Offset.QuadPart = 0;
+    Length = DeviceExt->FatInfo.BytesPerSector;
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    _SEH2_TRY
+    {
+        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
+    }
+    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+    {
+        _SEH2_YIELD(return _SEH2_GetExceptionCode());
+    }
+    _SEH2_END;
+#else
+    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_VFAT);
+    if (Sector == NULL)
+    {
+        *DirtyStatus = TRUE;
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
+    if  (!NT_SUCCESS(Status))
+    {
+        *DirtyStatus = TRUE;
+        ExFreePoolWithTag(Sector, TAG_VFAT);
+        return Status;
+    }
+#endif
+
+    if (Sector->Signatur1 != 0xaa55)
+    {
+        ASSERT(FALSE);
+        /* Set we are dirty so that we don't attempt anything */
+        *DirtyStatus = TRUE;
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+        CcUnpinData(Context);
+#else
+        ExFreePoolWithTag(Sector, TAG_VFAT);
+#endif
+        return STATUS_DISK_CORRUPT_ERROR;
+    }
+
+    if (Sector->Res1 & 0x01)
+        *DirtyStatus = TRUE;
+    else
+        *DirtyStatus = FALSE;
+
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    CcUnpinData(Context);
+#else
+    ExFreePoolWithTag(Sector, TAG_VFAT);
+#endif
+    return STATUS_SUCCESS;
+}
+
+NTSTATUS
+FAT32GetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    PBOOLEAN DirtyStatus)
+{
+    LARGE_INTEGER Offset;
+    ULONG Length;
+#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    NTSTATUS Status;
+#else
+    PVOID Context;
+#endif
+    struct _BootSector32 * Sector;
+
+    Offset.QuadPart = 0;
+    Length = DeviceExt->FatInfo.BytesPerSector;
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    _SEH2_TRY
+    {
+        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
+    }
+    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+    {
+        _SEH2_YIELD(return _SEH2_GetExceptionCode());
+    }
+    _SEH2_END;
+#else
+    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_VFAT);
+    if (Sector == NULL)
+    {
+        *DirtyStatus = TRUE;
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
+    if  (!NT_SUCCESS(Status))
+    {
+        *DirtyStatus = TRUE;
+        ExFreePoolWithTag(Sector, TAG_VFAT);
+        return Status;
+    }
+#endif
+
+    if (Sector->Signature1 != 0xaa55)
+    {
+        ASSERT(FALSE);
+        /* Set we are dirty so that we don't attempt anything */
+        *DirtyStatus = TRUE;
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+        CcUnpinData(Context);
+#else
+        ExFreePoolWithTag(Sector, TAG_VFAT);
+#endif
+        return STATUS_DISK_CORRUPT_ERROR;
+    }
+
+    if (Sector->Res4 & 0x01)
+        *DirtyStatus = TRUE;
+    else
+        *DirtyStatus = FALSE;
+
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    CcUnpinData(Context);
+#else
+    ExFreePoolWithTag(Sector, TAG_VFAT);
+#endif
+    return STATUS_SUCCESS;
+}
+
+/*
+ * FUNCTION: Set the dirty status
+ */
+NTSTATUS
+SetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    BOOLEAN DirtyStatus)
+{
+    NTSTATUS Status;
+
+    DPRINT1("SetDirtyStatus(DeviceExt %p, DirtyStatus %d)\n", DeviceExt, DirtyStatus);
+
+    if (DeviceExt->FatInfo.FatType == FAT12)
+    {
+        return STATUS_SUCCESS;
+    }
+
+    ExAcquireResourceExclusiveLite(&DeviceExt->FatResource, TRUE);
+    Status = DeviceExt->SetDirtyStatus(DeviceExt, DirtyStatus);
+    ExReleaseResourceLite(&DeviceExt->FatResource);
+
+    return Status;
+}
+
+NTSTATUS
+FAT16SetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    BOOLEAN DirtyStatus)
+{
+    LARGE_INTEGER Offset;
+    ULONG Length;
+#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    NTSTATUS Status;
+#else
+    PVOID Context;
+#endif
+    struct _BootSector * Sector;
+
+    Offset.QuadPart = 0;
+    Length = DeviceExt->FatInfo.BytesPerSector;
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    _SEH2_TRY
+    {
+        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
+    }
+    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+    {
+        _SEH2_YIELD(return _SEH2_GetExceptionCode());
+    }
+    _SEH2_END;
+#else
+    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_VFAT);
+    if (Sector == NULL)
+    {
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
+    if  (!NT_SUCCESS(Status))
+    {
+        ExFreePoolWithTag(Sector, TAG_VFAT);
+        return Status;
+    }
+#endif
+
+    if (Sector->Signatur1 != 0xaa55)
+    {
+        ASSERT(FALSE);
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+        CcUnpinData(Context);
+#else
+        ExFreePoolWithTag(Sector, TAG_VFAT);
+#endif
+        return STATUS_DISK_CORRUPT_ERROR;
+    }
+
+    if (!DirtyStatus)
+    {
+        Sector->Res1 &= ~0x01;
+    }
+    else
+    {
+        Sector->Res1 |= 0x01;
+    }
+
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    CcUnpinData(Context);
+    return STATUS_SUCCESS;
+#else
+    Status = VfatWriteDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
+    ExFreePoolWithTag(Sector, TAG_VFAT);
+    return Status;
+#endif
+}
+
+NTSTATUS
+FAT32SetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    BOOLEAN DirtyStatus)
+{
+    LARGE_INTEGER Offset;
+    ULONG Length;
+#ifdef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    NTSTATUS Status;
+#else
+    PVOID Context;
+#endif
+    struct _BootSector32 * Sector;
+
+    Offset.QuadPart = 0;
+    Length = DeviceExt->FatInfo.BytesPerSector;
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    _SEH2_TRY
+    {
+        CcPinRead(DeviceExt->VolumeFcb->FileObject, &Offset, Length, PIN_WAIT, &Context, (PVOID *)&Sector);
+    }
+    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+    {
+        _SEH2_YIELD(return _SEH2_GetExceptionCode());
+    }
+    _SEH2_END;
+#else
+    Sector = ExAllocatePoolWithTag(NonPagedPool, Length, TAG_VFAT);
+    if (Sector == NULL)
+    {
+        return STATUS_INSUFFICIENT_RESOURCES;
+    }
+
+    Status = VfatReadDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
+    if  (!NT_SUCCESS(Status))
+    {
+        ExFreePoolWithTag(Sector, TAG_VFAT);
+        return Status;
+    }
+#endif
+
+    if (Sector->Signature1 != 0xaa55)
+    {
+        ASSERT(FALSE);
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+        CcUnpinData(Context);
+#else
+        ExFreePoolWithTag(Sector, TAG_VFAT);
+#endif
+        return STATUS_DISK_CORRUPT_ERROR;
+    }
+
+    if (!DirtyStatus)
+    {
+        Sector->Res4 &= ~0x01;
+    }
+    else
+    {
+        Sector->Res4 |= 0x01;
+    }
+
+#ifndef VOLUME_IS_NOT_CACHED_WORK_AROUND_IT
+    CcUnpinData(Context);
+    return STATUS_SUCCESS;
+#else
+    Status = VfatWriteDisk(DeviceExt->StorageDevice, &Offset, Length, (PUCHAR)Sector, FALSE);
+    ExFreePoolWithTag(Sector, TAG_VFAT);
+    return Status;
+#endif
+}
+
 /* EOF */
diff --git a/drivers/filesystems/fastfat/fsctl.c b/drivers/filesystems/fastfat/fsctl.c
index 778a2bc..6839ead 100644
--- a/drivers/filesystems/fastfat/fsctl.c
+++ b/drivers/filesystems/fastfat/fsctl.c
@@ -531,9 +531,9 @@ VfatMount(
     UNICODE_STRING VolumeNameU = RTL_CONSTANT_STRING(L"\\$$Volume$$");
     UNICODE_STRING VolumeLabelU;
     ULONG HashTableSize;
-    ULONG eocMark;
     ULONG i;
     FATINFO FatInfo;
+    BOOLEAN Dirty;
 
     DPRINT("VfatMount(IrpContext %p)\n", IrpContext);
 
@@ -617,7 +617,6 @@ VfatMount(
             DeviceExt->GetNextCluster = FAT12GetNextCluster;
             DeviceExt->FindAndMarkAvailableCluster = FAT12FindAndMarkAvailableCluster;
             DeviceExt->WriteCluster = FAT12WriteCluster;
-            DeviceExt->CleanShutBitMask = 0;
             break;
 
         case FAT16:
@@ -625,7 +624,8 @@ VfatMount(
             DeviceExt->GetNextCluster = FAT16GetNextCluster;
             DeviceExt->FindAndMarkAvailableCluster = FAT16FindAndMarkAvailableCluster;
             DeviceExt->WriteCluster = FAT16WriteCluster;
-            DeviceExt->CleanShutBitMask = 0x8000;
+            DeviceExt->GetDirtyStatus = FAT16GetDirtyStatus;
+            DeviceExt->SetDirtyStatus = FAT16SetDirtyStatus;
             break;
 
         case FAT32:
@@ -633,7 +633,8 @@ VfatMount(
             DeviceExt->GetNextCluster = FAT32GetNextCluster;
             DeviceExt->FindAndMarkAvailableCluster = FAT32FindAndMarkAvailableCluster;
             DeviceExt->WriteCluster = FAT32WriteCluster;
-            DeviceExt->CleanShutBitMask = 0x80000000;
+            DeviceExt->GetDirtyStatus = FAT32GetDirtyStatus;
+            DeviceExt->SetDirtyStatus = FAT32SetDirtyStatus;
             break;
     }
 
@@ -764,15 +765,18 @@ VfatMount(
     Vpb->VolumeLabelLength = VolumeLabelU.Length;
 
     /* read clean shutdown bit status */
-    Status = GetNextCluster(DeviceExt, 1, &eocMark);
+    Status = GetDirtyStatus(DeviceExt, &Dirty);
     if (NT_SUCCESS(Status))
     {
-        if (eocMark & DeviceExt->CleanShutBitMask)
+        DPRINT1("Dirty: %x\n", Dirty);
+
+        if (!Dirty)
         {
-            /* unset clean shutdown bit */
-            eocMark &= ~DeviceExt->CleanShutBitMask;
-            WriteCluster(DeviceExt, 1, eocMark);
+            SetDirtyStatus(DeviceExt, TRUE);
             VolumeFcb->Flags |= VCB_CLEAR_DIRTY;
+            Status = GetDirtyStatus(DeviceExt, &Dirty);
+            ASSERT(NT_SUCCESS(Status));
+            ASSERT(Dirty);
         }
     }
 
@@ -1055,7 +1059,6 @@ NTSTATUS
 VfatMarkVolumeDirty(
     PVFAT_IRP_CONTEXT IrpContext)
 {
-    ULONG eocMark;
     PDEVICE_EXTENSION DeviceExt;
     NTSTATUS Status = STATUS_SUCCESS;
 
@@ -1064,13 +1067,7 @@ VfatMarkVolumeDirty(
 
     if (!BooleanFlagOn(DeviceExt->VolumeFcb->Flags, VCB_IS_DIRTY))
     {
-        Status = GetNextCluster(DeviceExt, 1, &eocMark);
-        if (NT_SUCCESS(Status))
-        {
-            /* unset clean shutdown bit */
-            eocMark &= ~DeviceExt->CleanShutBitMask;
-            Status = WriteCluster(DeviceExt, 1, eocMark);
-        }
+        SetDirtyStatus(DeviceExt, TRUE);
     }
 
     DeviceExt->VolumeFcb->Flags &= ~VCB_CLEAR_DIRTY;
@@ -1162,8 +1213,6 @@ VfatDismountVolume(
     PLIST_ENTRY NextEntry;
     PVFATFCB Fcb;
     PFILE_OBJECT FileObject;
-    ULONG eocMark;
-    NTSTATUS Status;
 
     DPRINT("VfatDismountVolume(%p)\n", IrpContext);
 
@@ -1198,13 +1247,8 @@ VfatDismountVolume(
     if (BooleanFlagOn(DeviceExt->VolumeFcb->Flags, VCB_CLEAR_DIRTY))
     {
         /* Set clean shutdown bit */
-        Status = GetNextCluster(DeviceExt, 1, &eocMark);
-        if (NT_SUCCESS(Status))
-        {
-            eocMark |= DeviceExt->CleanShutBitMask;
-            if (NT_SUCCESS(WriteCluster(DeviceExt, 1, eocMark)))
-                DeviceExt->VolumeFcb->Flags &= ~VCB_IS_DIRTY;
-        }
+        if (NT_SUCCESS(SetDirtyStatus(DeviceExt, FALSE)))
+            DeviceExt->VolumeFcb->Flags &= ~VCB_IS_DIRTY;
     }
 
     /* Flush volume & files */
diff --git a/drivers/filesystems/fastfat/shutdown.c b/drivers/filesystems/fastfat/shutdown.c
index 93ab2eb..b16f029 100644
--- a/drivers/filesystems/fastfat/shutdown.c
+++ b/drivers/filesystems/fastfat/shutdown.c
@@ -55,7 +55,6 @@ VfatShutdown(
     NTSTATUS Status;
     PLIST_ENTRY ListEntry;
     PDEVICE_EXTENSION DeviceExt;
-    ULONG eocMark;
 
     DPRINT("VfatShutdown(DeviceObject %p, Irp %p)\n",DeviceObject, Irp);
 
@@ -77,13 +76,8 @@ VfatShutdown(
             if (DeviceExt->VolumeFcb->Flags & VCB_CLEAR_DIRTY)
             {
                 /* set clean shutdown bit */
-                Status = GetNextCluster(DeviceExt, 1, &eocMark);
-                if (NT_SUCCESS(Status))
-                {
-                    eocMark |= DeviceExt->CleanShutBitMask;
-                    if (NT_SUCCESS(WriteCluster(DeviceExt, 1, eocMark)))
-                        DeviceExt->VolumeFcb->Flags &= ~VCB_IS_DIRTY;
-                }
+                if (NT_SUCCESS(SetDirtyStatus(DeviceExt, FALSE)))
+                    DeviceExt->VolumeFcb->Flags &= ~VCB_IS_DIRTY;
             }
 
             Status = VfatFlushVolume(DeviceExt, DeviceExt->VolumeFcb);
diff --git a/drivers/filesystems/fastfat/vfat.h b/drivers/filesystems/fastfat/vfat.h
index 1f29395..a805084 100644
--- a/drivers/filesystems/fastfat/vfat.h
+++ b/drivers/filesystems/fastfat/vfat.h
@@ -285,6 +285,8 @@ typedef BOOLEAN (*PIS_DIRECTORY_EMPTY)(PDEVICE_EXTENSION,struct _VFATFCB*);
 typedef NTSTATUS (*PADD_ENTRY)(PDEVICE_EXTENSION,PUNICODE_STRING,struct _VFATFCB**,struct _VFATFCB*,ULONG,UCHAR,struct _VFAT_MOVE_CONTEXT*);
 typedef NTSTATUS (*PDEL_ENTRY)(PDEVICE_EXTENSION,struct _VFATFCB*,struct _VFAT_MOVE_CONTEXT*);
 typedef NTSTATUS (*PGET_NEXT_DIR_ENTRY)(PVOID*,PVOID*,struct _VFATFCB*,struct _VFAT_DIRENTRY_CONTEXT*,BOOLEAN);
+typedef NTSTATUS (*PGET_DIRTY_STATUS)(PDEVICE_EXTENSION,PBOOLEAN);
+typedef NTSTATUS (*PSET_DIRTY_STATUS)(PDEVICE_EXTENSION,BOOLEAN);
 
 typedef struct _VFAT_DISPATCH
 {
@@ -326,7 +328,8 @@ typedef struct DEVICE_EXTENSION
     PGET_NEXT_CLUSTER GetNextCluster;
     PFIND_AND_MARK_AVAILABLE_CLUSTER FindAndMarkAvailableCluster;
     PWRITE_CLUSTER WriteCluster;
-    ULONG CleanShutBitMask;
+    PGET_DIRTY_STATUS GetDirtyStatus;
+    PSET_DIRTY_STATUS SetDirtyStatus;
 
     ULONG BaseDateYear;
 
@@ -655,6 +658,14 @@ VfatReadDiskPartial(
     IN BOOLEAN Wait);
 
 NTSTATUS
+VfatWriteDisk(
+    IN PDEVICE_OBJECT pDeviceObject,
+    IN PLARGE_INTEGER WriteOffset,
+    IN ULONG WriteLength,
+    IN OUT PUCHAR Buffer,
+    IN BOOLEAN Override);
+
+NTSTATUS
 VfatWriteDiskPartial(
     IN PVFAT_IRP_CONTEXT IrpContext,
     IN PLARGE_INTEGER WriteOffset,
@@ -885,6 +896,36 @@ WriteCluster(
     ULONG ClusterToWrite,
     ULONG NewValue);
 
+NTSTATUS
+GetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    PBOOLEAN DirtyStatus);
+
+NTSTATUS
+FAT16GetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    PBOOLEAN DirtyStatus);
+
+NTSTATUS
+FAT32GetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    PBOOLEAN DirtyStatus);
+
+NTSTATUS
+SetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    BOOLEAN DirtyStatus);
+
+NTSTATUS
+FAT16SetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    BOOLEAN DirtyStatus);
+
+NTSTATUS
+FAT32SetDirtyStatus(
+    PDEVICE_EXTENSION DeviceExt,
+    BOOLEAN DirtyStatus);
+
 /* fcb.c */
 
 PVFATFCB
