diff --git a/drivers/filesystems/fastfat/rw.c b/drivers/filesystems/fastfat/rw.c
index 4dd5993..c54e1d2 100644
--- a/drivers/filesystems/fastfat/rw.c
+++ b/drivers/filesystems/fastfat/rw.c
@@ -535,6 +535,167 @@ VfatWriteFileData(
     return Status;
 }
 
+#define OVERFLOW_READ_THRESHHOLD 0xE00
+
+NTSTATUS
+VfatCommonRead(
+    PVFAT_IRP_CONTEXT IrpContext)
+{
+    PVFATFCB Fcb;
+    PVOID Buffer;
+    NTSTATUS Status;    
+    ULONG Length = 0;
+    ULONG BytesPerSector;
+    LARGE_INTEGER ByteOffset;
+    ULONG ReturnedLength = 0;
+    BOOLEAN PagingIo, CanWait, IsVolume, NoCache;
+
+    PagingIo = BooleanFlagOn(IrpContext->Irp->Flags, IRP_PAGING_IO);
+    CanWait = BooleanFlagOn(IrpContext->Flags, IRPCONTEXT_CANWAIT);
+    NoCache = BooleanFlagOn(IrpContext->Irp->Flags, IRP_NOCACHE);
+    Fcb = IrpContext->FileObject->FsContext;
+    IsVolume = BooleanFlagOn(Fcb->Flags, FCB_IS_VOLUME);
+
+    ByteOffset = IrpContext->Stack->Parameters.Read.ByteOffset;
+    Length = IrpContext->Stack->Parameters.Read.Length;
+    BytesPerSector = IrpContext->DeviceExt->FatInfo.BytesPerSector;
+
+    if (!PagingIo &&
+        FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
+    {
+        if (!FsRtlCheckLockForReadAccess(&Fcb->FileLock, IrpContext->Irp))
+        {
+            return STATUS_FILE_LOCK_CONFLICT;
+        }
+    }
+
+    Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo);
+
+    if (!PagingIo && !NoCache && !IsVolume)
+    {
+        // cached read
+        Status = STATUS_SUCCESS;
+        if (ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
+        {
+            Length = Fcb->RFCB.FileSize.u.LowPart - ByteOffset.u.LowPart;
+            Status = /*STATUS_END_OF_FILE*/STATUS_SUCCESS;
+        }
+
+        vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReads, 1);
+        vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReadBytes, Length);
+
+        _SEH2_TRY
+        {
+            if (IrpContext->FileObject->PrivateCacheMap == NULL)
+            {
+                CcInitializeCacheMap(IrpContext->FileObject,
+                                     (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
+                                     FALSE,
+                                     &(VfatGlobalData->CacheMgrCallbacks),
+                                     Fcb);
+            }
+
+            if (!CcCopyRead(IrpContext->FileObject,
+                            &ByteOffset,
+                            Length,
+                            CanWait,
+                            Buffer,
+                            &IrpContext->Irp->IoStatus))
+            {
+                ASSERT(!CanWait);
+                Status = STATUS_PENDING;
+                goto ByeBye;
+            }
+        }
+        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
+        {
+            Status = _SEH2_GetExceptionCode();
+            goto ByeBye;
+        }
+        _SEH2_END;
+
+        if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status))
+        {
+            Status = IrpContext->Irp->IoStatus.Status;
+        }
+    }
+    else
+    {
+        // non cached read
+        Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
+        if (!NT_SUCCESS(Status))
+        {
+            goto ByeBye;
+        }
+
+        if (ByteOffset.QuadPart + Length > ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector))
+        {
+            Length = (ULONG)(ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector) - ByteOffset.QuadPart);
+        }
+
+        if (!IsVolume)
+        {
+            vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReads, 1);
+            vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReadBytes, Length);
+        }
+        else
+        {
+            vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReads, 1);
+            vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReadBytes, Length);
+        }
+
+        Status = VfatReadFileData(IrpContext, Length, ByteOffset, &ReturnedLength);
+        if (NT_SUCCESS(Status))
+        {
+            IrpContext->Irp->IoStatus.Information = ReturnedLength;
+        }
+    }
+
+ByeBye:
+    return Status;
+}
+
+VOID
+NTAPI
+VfatStackOverflowRead(
+    PVOID Context,
+    IN PKEVENT Event)
+{
+    PVFAT_IRP_CONTEXT IrpContext;
+
+    IrpContext = Context;
+    SetFlag(IrpContext->Flags, IRPCONTEXT_CANWAIT);
+
+    DPRINT1("Performing posted read\n");
+    VfatCommonRead(IrpContext);
+
+    KeSetEvent(Event, 0, FALSE);
+}
+
+VOID
+VfatPostRead(
+    PVFAT_IRP_CONTEXT IrpContext,
+    PERESOURCE Lock,
+    BOOLEAN PagingIo)
+{
+    KEVENT Event;
+
+    KeInitializeEvent(&Event, NotificationEvent, FALSE);
+
+    ExAcquireResourceSharedLite(Lock, TRUE);
+
+    if (PagingIo)
+    {
+        FsRtlPostPagingFileStackOverflow(IrpContext, &Event, VfatStackOverflowRead);
+    }
+    else
+    {
+        FsRtlPostStackOverflow(IrpContext, &Event, VfatStackOverflowRead);
+    }
+
+    KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
+}
+
 NTSTATUS
 VfatRead(
     PVFAT_IRP_CONTEXT IrpContext)
@@ -542,10 +703,8 @@ VfatRead(
     NTSTATUS Status;
     PVFATFCB Fcb;
     ULONG Length = 0;
-    ULONG ReturnedLength = 0;
     PERESOURCE Resource = NULL;
     LARGE_INTEGER ByteOffset;
-    PVOID Buffer;
     ULONG BytesPerSector;
     BOOLEAN PagingIo, CanWait, IsVolume, NoCache;
 
@@ -644,105 +803,28 @@ VfatRead(
         Resource = &Fcb->MainResource;
     }
 
-    if (!ExAcquireResourceSharedLite(Resource, CanWait))
-    {
-        Resource = NULL;
-        Status = STATUS_PENDING;
-        goto ByeBye;
-    }
-
-    if (!PagingIo &&
-        FsRtlAreThereCurrentFileLocks(&Fcb->FileLock))
+    if (IoGetRemainingStackSize() < OVERFLOW_READ_THRESHHOLD)
     {
-        if (!FsRtlCheckLockForReadAccess(&Fcb->FileLock, IrpContext->Irp))
-        {
-            Status = STATUS_FILE_LOCK_CONFLICT;
-            goto ByeBye;
-        }
-    }
-
-    Buffer = VfatGetUserBuffer(IrpContext->Irp, PagingIo);
-
-    if (!PagingIo && !NoCache && !IsVolume)
-    {
-        // cached read
-        Status = STATUS_SUCCESS;
-        if (ByteOffset.u.LowPart + Length > Fcb->RFCB.FileSize.u.LowPart)
-        {
-            Length = Fcb->RFCB.FileSize.u.LowPart - ByteOffset.u.LowPart;
-            Status = /*STATUS_END_OF_FILE*/STATUS_SUCCESS;
-        }
-
-        vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReads, 1);
-        vfatAddToStat(IrpContext->DeviceExt, Base.UserFileReadBytes, Length);
-
-        _SEH2_TRY
-        {
-            if (IrpContext->FileObject->PrivateCacheMap == NULL)
-            {
-                CcInitializeCacheMap(IrpContext->FileObject,
-                                     (PCC_FILE_SIZES)(&Fcb->RFCB.AllocationSize),
-                                     FALSE,
-                                     &(VfatGlobalData->CacheMgrCallbacks),
-                                     Fcb);
-            }
-
-            if (!CcCopyRead(IrpContext->FileObject,
-                            &ByteOffset,
-                            Length,
-                            CanWait,
-                            Buffer,
-                            &IrpContext->Irp->IoStatus))
-            {
-                ASSERT(!CanWait);
-                Status = STATUS_PENDING;
-                goto ByeBye;
-            }
-        }
-        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
-        {
-            Status = _SEH2_GetExceptionCode();
-            goto ByeBye;
-        }
-        _SEH2_END;
-
-        if (!NT_SUCCESS(IrpContext->Irp->IoStatus.Status))
-        {
-            Status = IrpContext->Irp->IoStatus.Status;
-        }
-    }
-    else
-    {
-        // non cached read
         Status = VfatLockUserBuffer(IrpContext->Irp, Length, IoWriteAccess);
         if (!NT_SUCCESS(Status))
         {
-            goto ByeBye;
+            return Status;
         }
 
-        if (ByteOffset.QuadPart + Length > ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector))
-        {
-            Length = (ULONG)(ROUND_UP_64(Fcb->RFCB.FileSize.QuadPart, BytesPerSector) - ByteOffset.QuadPart);
-        }
+        VfatPostRead(IrpContext, Resource, PagingIo);
 
-        if (!IsVolume)
-        {
-            vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReads, 1);
-            vfatAddToStat(IrpContext->DeviceExt, Fat.NonCachedReadBytes, Length);
-        }
-        else
-        {
-            vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReads, 1);
-            vfatAddToStat(IrpContext->DeviceExt, Base.MetaDataReadBytes, Length);
-        }
+        return IrpContext->Irp->IoStatus.Status;
+    }
 
-        Status = VfatReadFileData(IrpContext, Length, ByteOffset, &ReturnedLength);
-        if (NT_SUCCESS(Status))
-        {
-            IrpContext->Irp->IoStatus.Information = ReturnedLength;
-        }
+    if (!ExAcquireResourceSharedLite(Resource, CanWait))
+    {
+        Resource = NULL;
+        Status = STATUS_PENDING;
+        goto ByeBye;
     }
 
+    Status = VfatCommonRead(IrpContext);
+
 ByeBye:
     if (Resource)
     {
