cachesup.c File Reference

#include "fatprocs.h"

Include dependency graph for cachesup.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (FAT_BUG_CHECK_CACHESUP)
#define	Dbg   (DEBUG_TRACE_CACHESUP)

Functions
VOID	FatInitializeCacheMap (_In_ PFILE_OBJECT FileObject, _In_ PCC_FILE_SIZES FileSizes, _In_ BOOLEAN PinAccess, _In_ PCACHE_MANAGER_CALLBACKS Callbacks, _In_ PVOID LazyWriteContext)
VOID	FatReadVolumeFile (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN VBO StartingVbo, IN ULONG ByteCount, OUT PBCB *Bcb, OUT PVOID *Buffer)
	_Requires_lock_held_ (_Global_critical_region_)
PFILE_OBJECT	FatOpenEaFile (IN PIRP_CONTEXT IrpContext, IN PFCB EaFcb)
VOID	FatCloseEaFile (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN BOOLEAN FlushFirst)
VOID	FatRepinBcb (IN PIRP_CONTEXT IrpContext, IN PBCB Bcb)
VOID	FatUnpinRepinnedBcbs (IN PIRP_CONTEXT IrpContext)
FINISHED	FatZeroData (IN PIRP_CONTEXT IrpContext, IN PVCB Vcb, IN PFILE_OBJECT FileObject, IN ULONG StartingZero, IN ULONG ByteCount)
NTSTATUS	FatCompleteMdl (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
VOID	FatSyncUninitializeCacheMap (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT FileObject)
VOID	FatPinMappedData (IN PIRP_CONTEXT IrpContext, IN PDCB Dcb, IN VBO StartingVbo, IN ULONG ByteCount, OUT PBCB *Bcb)
NTSTATUS	FatPrefetchPages (IN PIRP_CONTEXT IrpContext, IN PFILE_OBJECT FileObject, IN ULONG StartingPage, IN ULONG PageCount)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (FAT_BUG_CHECK_CACHESUP)

Definition at line 23 of file cachesup.c.

Dbg

#define Dbg   (DEBUG_TRACE_CACHESUP)

Definition at line 29 of file cachesup.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 187 of file cachesup.c.

{
    LARGE_INTEGER Vbo;
 
    PAGED_CODE();
 
    //
    //  Check to see that all references are within the Bios Parameter Block
    //  or the fat(s).
    //
 
    NT_ASSERT( ((StartingVbo + ByteCount) <= (ULONG)
            (FatRootDirectoryLbo( &Vcb->Bpb ))));
 
    DebugTrace(+1, Dbg, "FatPrepareWriteVolumeFile\n", 0);
    DebugTrace( 0, Dbg, "Vcb         = %p\n", Vcb);
    DebugTrace( 0, Dbg, "StartingVbo = %08lx\n", (ULONG)StartingVbo);
    DebugTrace( 0, Dbg, "ByteCount   = %08lx\n", ByteCount);
    DebugTrace( 0, Dbg, "Zero        = %08lx\n", Zero);
 
    //
    //  Call the Cache manager to attempt the transfer.
    //
 
    Vbo.QuadPart = StartingVbo;
 
    if (!CcPinRead( Vcb->VirtualVolumeFile,
                    &Vbo,
                    ByteCount,
                    BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT),
                    Bcb,
                    Buffer )) {
 
        NT_ASSERT( !FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
 
        //
        // Could not read the data without waiting (cache miss).
        //
 
        FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
    }
 
    //
    //  This keeps the data pinned until we complete the request
    //  and writes the dirty bit through to the disk.
    //
 
    DbgDoit( IrpContext->PinCount += 1 )
 
    _SEH2_TRY {
 
        if (Zero) {
 
            RtlZeroMemory( *Buffer, ByteCount );
        }
 
        FatSetDirtyBcb( IrpContext, *Bcb, Vcb, Reversible );
 
    } _SEH2_FINALLY {
 
        if (_SEH2_AbnormalTermination()) {
 
            FatUnpinBcb(IrpContext, *Bcb);
        }
    } _SEH2_END;
 
    DebugTrace(-1, Dbg, "FatPrepareWriteVolumeFile -> VOID, *Bcb = %p\n", *Bcb);
 
    return;
}

FatCloseEaFile()

VOID FatCloseEaFile	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN BOOLEAN	FlushFirst
	)

Definition at line 1079 of file cachesup.c.

{
    PFILE_OBJECT EaFileObject = Vcb->VirtualEaFile;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatCloseEaFile\n", 0);
    DebugTrace( 0, Dbg, "Vcb = %p\n", Vcb);
 
    NT_ASSERT( FatVcbAcquiredExclusive(IrpContext, Vcb) );
 
    if (EaFileObject != NULL) {
 
        EaFileObject = Vcb->VirtualEaFile;
 
        if (FlushFirst) {
 
            CcFlushCache( Vcb->VirtualEaFile->SectionObjectPointer, NULL, 0, NULL );
        }
 
        Vcb->VirtualEaFile = NULL;
 
        //
        //  Empty the Mcb for the Ea file.
        //
 
        FatRemoveMcbEntry( Vcb, &Vcb->EaFcb->Mcb, 0, 0xFFFFFFFF );
 
        //
        //  Uninitialize the cache for this file object and dereference it.
        //
 
        FatSyncUninitializeCacheMap( IrpContext, EaFileObject );
 
        ObDereferenceObject( EaFileObject );
    }
 
    DebugTrace(-1, Dbg, "FatCloseEaFile -> %p\n", EaFileObject);
}

Referenced by FatTearDownVcb().

FatCompleteMdl()

NTSTATUS FatCompleteMdl	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 1728 of file cachesup.c.

{
    PFILE_OBJECT FileObject;
    PIO_STACK_LOCATION IrpSp;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatCompleteMdl\n", 0 );
    DebugTrace( 0, Dbg, "IrpContext = %p\n", IrpContext );
    DebugTrace( 0, Dbg, "Irp        = %p\n", Irp );
 
    //
    // Do completion processing.
    //
 
    FileObject = IoGetCurrentIrpStackLocation( Irp )->FileObject;
 
    switch( IrpContext->MajorFunction ) {
 
    case IRP_MJ_READ:
 
        CcMdlReadComplete( FileObject, Irp->MdlAddress );
        break;
 
    case IRP_MJ_WRITE:
 
        IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
        NT_ASSERT( FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT ));
 
        CcMdlWriteComplete( FileObject, &IrpSp->Parameters.Write.ByteOffset, Irp->MdlAddress );
 
        Irp->IoStatus.Status = STATUS_SUCCESS;
 
        break;
 
    default:
 
        DebugTrace( DEBUG_TRACE_ERROR, 0, "Illegal Mdl Complete.\n", 0);
#ifdef _MSC_VER
#pragma prefast( suppress: 28159, "we're very broken if we get here" )
#endif
        FatBugCheck( IrpContext->MajorFunction, 0, 0 );
    }
 
    //
    // Mdl is now deallocated.
    //
 
    Irp->MdlAddress = NULL;
 
    //
    // Complete the request and exit right away.
    //
 
    FatCompleteRequest( IrpContext, Irp, STATUS_SUCCESS );
 
    DebugTrace(-1, Dbg, "FatCompleteMdl -> STATUS_SUCCESS\n", 0 );
 
    return STATUS_SUCCESS;
}

Referenced by _Function_class_().

FatInitializeCacheMap()

VOID FatInitializeCacheMap	(	_In_ PFILE_OBJECT	FileObject,
		_In_ PCC_FILE_SIZES	FileSizes,
		_In_ BOOLEAN	PinAccess,
		_In_ PCACHE_MANAGER_CALLBACKS	Callbacks,
		_In_ PVOID	LazyWriteContext
	)

Definition at line 62 of file cachesup.c.

{
    //
    //  Initialize caching
    //
 
    CcInitializeCacheMap( FileObject,
                          FileSizes,
                          PinAccess,
                          Callbacks,
                          LazyWriteContext );
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
    //
    //  Enable Disk IO Accounting for this file
    //
 
    if (FatDiskAccountingEnabled) {
 
        CcSetAdditionalCacheAttributesEx( FileObject, CC_ENABLE_DISK_IO_ACCOUNTING );
    }
#endif
}

Referenced by _Requires_lock_held_(), FatOpenEaFile(), and FatSetupAllocationSupport().

FatOpenEaFile()

PFILE_OBJECT FatOpenEaFile	(	IN PIRP_CONTEXT	IrpContext,
		IN PFCB	EaFcb
	)

Definition at line 979 of file cachesup.c.

{
    PFILE_OBJECT EaFileObject = NULL;
    PDEVICE_OBJECT RealDevice;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatOpenEaFile\n", 0);
    DebugTrace( 0, Dbg, "EaFcb = %p\n", EaFcb);
 
    //
    //  Create the special file object for the ea file, and set
    //  up its pointers back to the Fcb and the section object pointer
    //
 
    RealDevice = EaFcb->Vcb->CurrentDevice;
 
    EaFileObject = IoCreateStreamFileObject( NULL, RealDevice );
 
    _SEH2_TRY {
 
        FatPreallocateCloseContext( IrpContext->Vcb);
 
        FatSetFileObject( EaFileObject,
                          EaFile,
                          EaFcb,
                          NULL );
 
        //
        //  Remember this internal, residual open.
        //
 
        InterlockedIncrement( (LONG*)&(EaFcb->Vcb->InternalOpenCount) );
        InterlockedIncrement( (LONG*)&(EaFcb->Vcb->ResidualOpenCount) );
 
        EaFileObject->SectionObjectPointer = &EaFcb->NonPaged->SectionObjectPointers;
 
        EaFileObject->ReadAccess = TRUE;
        EaFileObject->WriteAccess = TRUE;
 
        //
        //  Finally check if we need to initialize the Cache Map for the
        //  ea file.  The size of the section we are going to map
        //  the current allocation size for the Fcb.
        //
 
        EaFcb->Header.ValidDataLength = FatMaxLarge;
 
        FatInitializeCacheMap( EaFileObject,
                               (PCC_FILE_SIZES)&EaFcb->Header.AllocationSize,
                               TRUE,
                               &FatData.CacheManagerCallbacks,
                               EaFcb );
 
        CcSetAdditionalCacheAttributes( EaFileObject, TRUE, TRUE );
 
    } _SEH2_FINALLY {
 
        //
        //  Drop the fileobject if we're raising.  Two cases: couldn't get
        //  the close context, and it is still an UnopenedFileObject, or
        //  we lost trying to build the cache map - in which case we're
        //  OK for the close context if we have to.
        //
 
        if (_SEH2_AbnormalTermination()) {
 
            ObDereferenceObject( EaFileObject );
        }
    } _SEH2_END;
 
    DebugTrace(-1, Dbg, "FatOpenEaFile -> %p\n", EaFileObject);
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    return EaFileObject;
}

FatPinMappedData()

VOID FatPinMappedData	(	IN PIRP_CONTEXT	IrpContext,
		IN PDCB	Dcb,
		IN VBO	StartingVbo,
		IN ULONG	ByteCount,
		OUT PBCB *	Bcb
	)

Definition at line 1866 of file cachesup.c.

{
    LARGE_INTEGER Vbo;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatPinMappedData\n", 0);
    DebugTrace( 0, Dbg, "Dcb         = %p\n", Dcb);
    DebugTrace( 0, Dbg, "StartingVbo = %08lx\n", StartingVbo);
    DebugTrace( 0, Dbg, "ByteCount   = %08lx\n", ByteCount);
 
    //
    //  Call the Cache manager to perform the operation.
    //
 
    Vbo.QuadPart = StartingVbo;
 
    if (!CcPinMappedData( Dcb->Specific.Dcb.DirectoryFile,
                          &Vbo,
                          ByteCount,
                          BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT),
                          Bcb )) {
 
        //
        // Could not pin the data without waiting (cache miss).
        //
 
        FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
    }
 
    DebugTrace(-1, Dbg, "FatReadDirectoryFile -> VOID, *BCB = %p\n", *Bcb);
 
    return;
}

FatPrefetchPages()

NTSTATUS FatPrefetchPages	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	FileObject,
		IN ULONG	StartingPage,
		IN ULONG	PageCount
	)

Definition at line 1929 of file cachesup.c.

{
    IO_PRIORITY_INFO PriorityInformation = {0};
    MM_PREFETCH_FLAGS PrefetchFlags;
    ULONG PageNo;
    NTSTATUS Status;
 
    PREAD_LIST ReadList = NULL;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    PAGED_CODE();
 
    //
    //  Succeed zero page prefetch requests.
    //
 
    if (PageCount == 0) {
 
        return STATUS_SUCCESS;
    }
 
    //
    //  Mm's prefetch API's "only" support fetching a ULONG worth of pages.
    //  Make sure we don't overflow.
    //
 
    ASSERT( PageCount < (PFN_NUMBER)MAXULONG );
 
    IoInitializePriorityInfo( &PriorityInformation );
 
    Status = IoRetrievePriorityInfo( IrpContext->OriginatingIrp,
                                     FileObject,
                                     IrpContext->OriginatingIrp->Tail.Overlay.Thread,
                                     &PriorityInformation );
 
    if (!NT_SUCCESS( Status)) {
 
        goto Cleanup;
    }
 
    ReadList = ExAllocatePoolWithTag( PagedPool,
                                      FIELD_OFFSET( READ_LIST, List ) + PageCount * sizeof( FILE_SEGMENT_ELEMENT ),
                                      ' taF' );
 
    if (ReadList == NULL) {
 
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Cleanup;
    }
 
    //
    //  Call Mm to prefetch data.
    //
 
    ReadList->FileObject = FileObject;
    ReadList->IsImage = FALSE;
    ReadList->NumberOfEntries = PageCount;
 
    PrefetchFlags.AllFlags = 0;
    PrefetchFlags.Flags.Priority = PriorityInformation.PagePriority;
    PrefetchFlags.Flags.RepurposePriority = SYSTEM_PAGE_PRIORITY_LEVELS - 1;
    PrefetchFlags.Flags.PriorityProtection = 1;
    ReadList->List[0].Alignment = StartingPage * PAGE_SIZE;
    ReadList->List[0].Alignment |= PrefetchFlags.AllFlags;
 
    for (PageNo = 1; PageNo < PageCount; PageNo++) {
 
        ReadList->List[PageNo].Alignment = ReadList->List[PageNo-1].Alignment + PAGE_SIZE;
    }
 
    Status = MmPrefetchPages( 1, &ReadList );
 
Cleanup:
 
    if (ReadList != NULL) {
 
        ExFreePoolWithTag( ReadList, ' taF' );
    }
 
    return Status;
}

Referenced by FatExamineFatEntries().

FatReadVolumeFile()

VOID FatReadVolumeFile	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN VBO	StartingVbo,
		IN ULONG	ByteCount,
		OUT PBCB *	Bcb,
		OUT PVOID *	Buffer
	)

Definition at line 102 of file cachesup.c.

{
    LARGE_INTEGER Vbo;
 
    PAGED_CODE();
 
    //
    //  Check to see that all references are within the Bios Parameter Block
    //  or the fat(s).  A special case is made when StartingVbo == 0 at
    //  mounting time since we do not know how big the fat is.
    //
 
    NT_ASSERT( ((StartingVbo == 0) || ((StartingVbo + ByteCount) <= (ULONG)
            (FatRootDirectoryLbo( &Vcb->Bpb ) + PAGE_SIZE))));
 
    DebugTrace(+1, Dbg, "FatReadVolumeFile\n", 0);
    DebugTrace( 0, Dbg, "Vcb         = %p\n", Vcb);
    DebugTrace( 0, Dbg, "StartingVbo = %08lx\n", StartingVbo);
    DebugTrace( 0, Dbg, "ByteCount   = %08lx\n", ByteCount);
 
    //
    //  Call the Cache manager to attempt the transfer.
    //
 
    Vbo.QuadPart = StartingVbo;
 
    if (!CcMapData( Vcb->VirtualVolumeFile,
                    &Vbo,
                    ByteCount,
                    BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT),
                    Bcb,
                    Buffer )) {
 
        NT_ASSERT( !FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
 
        //
        // Could not read the data without waiting (cache miss).
        //
 
        FatRaiseStatus( IrpContext, STATUS_CANT_WAIT );
    }
 
    DbgDoit( IrpContext->PinCount += 1 )
 
    DebugTrace(-1, Dbg, "FatReadVolumeFile -> VOID, *BCB = %p\n", *Bcb);
 
    return;
}

Referenced by FatCheckDirtyBit(), FatExamineFatEntries(), and FatLookupFatEntry().

FatRepinBcb()

VOID FatRepinBcb	(	IN PIRP_CONTEXT	IrpContext,
		IN PBCB	Bcb
	)

Definition at line 1317 of file cachesup.c.

{
    PREPINNED_BCBS Repinned;
    ULONG i;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatRepinBcb\n", 0 );
    DebugTrace( 0, Dbg, "IrpContext = %p\n", IrpContext );
    DebugTrace( 0, Dbg, "Bcb        = %p\n", Bcb );
 
    //
    //  The algorithm is to search the list of repinned records until
    //  we either find a match for the bcb or we find a null slot.
    //
 
    Repinned = &IrpContext->Repinned;
 
    while (TRUE) {
 
        //
        //  For every entry in the repinned record check if the bcb's
        //  match or if the entry is null.  If the bcb's match then
        //  we've done because we've already repinned this bcb, if
        //  the entry is null then we know, because it's densely packed,
        //  that the bcb is not in the list so add it to the repinned
        //  record and repin it.
        //
 
        for (i = 0; i < REPINNED_BCBS_ARRAY_SIZE; i += 1) {
 
            if (Repinned->Bcb[i] == Bcb) {
 
                DebugTrace(-1, Dbg, "FatRepinBcb -> VOID\n", 0 );
                return;
            }
 
            if (Repinned->Bcb[i] == NULL) {
 
                Repinned->Bcb[i] = Bcb;
                CcRepinBcb( Bcb );
 
                DebugTrace(-1, Dbg, "FatRepinBcb -> VOID\n", 0 );
                return;
            }
        }
 
        //
        //  We finished checking one repinned record so now locate the next
        //  repinned record,  If there isn't one then allocate and zero out
        //  a new one.
        //
 
        if (Repinned->Next == NULL) {
 
            Repinned->Next = FsRtlAllocatePoolWithTag( PagedPool,
                                                       sizeof(REPINNED_BCBS),
                                                       TAG_REPINNED_BCB );
 
            RtlZeroMemory( Repinned->Next, sizeof(REPINNED_BCBS) );
        }
 
        Repinned = Repinned->Next;
    }
}

FatSyncUninitializeCacheMap()

VOID FatSyncUninitializeCacheMap	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	FileObject
	)

Definition at line 1812 of file cachesup.c.

{
    CACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent;
    NTSTATUS WaitStatus;
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    PAGED_CODE();
 
    KeInitializeEvent( &UninitializeCompleteEvent.Event,
                       SynchronizationEvent,
                       FALSE);
 
    CcUninitializeCacheMap( FileObject,
                            &FatLargeZero,
                            &UninitializeCompleteEvent );
 
    //
    //  Now wait for the cache manager to finish purging the file.
    //  This will garentee that Mm gets the purge before we
    //  delete the Vcb.
    //
 
#ifdef _MSC_VER
#pragma prefast( suppress: 28931, "we use WaitStatus in the debug assert, in fre builds prefast complains it's unused" )
#endif
    WaitStatus = KeWaitForSingleObject( &UninitializeCompleteEvent.Event,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL);
 
    NT_ASSERT(WaitStatus == STATUS_SUCCESS);
}

Referenced by _Requires_lock_held_(), and FatCloseEaFile().

FatUnpinRepinnedBcbs()

VOID FatUnpinRepinnedBcbs

(

IN PIRP_CONTEXT

IrpContext

)

Definition at line 1407 of file cachesup.c.

{
    IO_STATUS_BLOCK RaiseIosb;
    PREPINNED_BCBS Repinned;
    BOOLEAN WriteThroughToDisk;
    PFILE_OBJECT FileObject = NULL;
    BOOLEAN ForceVerify = FALSE;
    ULONG i;
    PFCB FcbOrDcb = NULL;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatUnpinRepinnedBcbs\n", 0 );
    DebugTrace( 0, Dbg, "IrpContext = %p\n", IrpContext );
 
    //
    //  The algorithm for this procedure is to scan the entire list of
    //  repinned records unpinning any repinned bcbs.  We start off
    //  with the first record in the irp context, and while there is a
    //  record to scan we do the following loop.
    //
 
    Repinned = &IrpContext->Repinned;
    RaiseIosb.Status = STATUS_SUCCESS;
 
    //
    //  WinSE bug #307418 "Occasional data corruption when
    //  standby/resume while copying files to removable FAT
    //  formatted media".
    //  Extract main FCB pointer from the irp context - we
    //  will need it later to detect new file creation operation.
    //
 
    if (IrpContext->MajorFunction == IRP_MJ_CREATE &&
        IrpContext->OriginatingIrp != NULL) {
        PIO_STACK_LOCATION IrpSp;
 
        IrpSp = IoGetCurrentIrpStackLocation( IrpContext->OriginatingIrp );
 
        if (IrpSp != NULL &&
            IrpSp->FileObject != NULL &&
            IrpSp->FileObject->FsContext != NULL) {
 
            FcbOrDcb = IrpSp->FileObject->FsContext;
        }
    }
 
    //
    //  If the request is write through or the media is deferred flush,
    //  unpin the bcb's write through.
    //
 
    WriteThroughToDisk = (BOOLEAN) (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_WRITE_THROUGH) &&
                                    IrpContext->Vcb != NULL &&
                                    (FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH) ||
                                     FlagOn(IrpContext->Vcb->VcbState, VCB_STATE_FLAG_DEFERRED_FLUSH)));
 
    while (Repinned != NULL) {
 
        //
        //  For every non-null entry in the repinned record unpin the
        //  repinned entry.
        //
        //  If the this is removable media (therefore all requests write-
        //  through) and the write fails, purge the cache so that we throw
        //  away the modifications as we will be returning an error to the
        //  user.
        //
 
        for (i = 0; i < REPINNED_BCBS_ARRAY_SIZE; i += 1) {
 
            if (Repinned->Bcb[i] != NULL) {
 
                IO_STATUS_BLOCK Iosb;
 
                if (WriteThroughToDisk &&
                    FlagOn(IrpContext->Vcb->VcbState, VCB_STATE_FLAG_DEFERRED_FLUSH)) {
 
                    FileObject = CcGetFileObjectFromBcb( Repinned->Bcb[i] );
                }
 
                CcUnpinRepinnedBcb( Repinned->Bcb[i],
                                    WriteThroughToDisk,
                                    &Iosb );
 
                if (!NT_SUCCESS(Iosb.Status)) {
 
                    if (RaiseIosb.Status == STATUS_SUCCESS) {
 
                        RaiseIosb = Iosb;
                    }
 
                    //
                    //  If this was a writethrough device, purge the cache,
                    //  except for Irp major codes that either don't handle
                    //  the error paths correctly or are simple victims like
                    //  cleanup.c.
                    //
 
                    if (FileObject &&
                        (IrpContext->MajorFunction != IRP_MJ_CLEANUP) &&
                        (IrpContext->MajorFunction != IRP_MJ_FLUSH_BUFFERS) &&
                        (IrpContext->MajorFunction != IRP_MJ_SET_INFORMATION)
 
                                        &&
 
                            //
                            //  WinSE bug #307418 "Occasional data corruption when
                            //  standby/resume while copying files to removable FAT
                            //  formatted media".
                            //  Buffer unpinning for new file creation operation can
                            //  be interrupted by system syspend. As a result some BCBs
                            //  will be successfully written to the disk while others will
                            //  be kicked back with STATUS_VERIFY_REQUIRED. Since there is
                            //  is still a chance for the failed BCBs to reach the disk
                            //  after the volume verification we'll not purge them.
                            //  Instead FatCommonCreate() will unroll the file creation
                            //  changes for these pages.
                            //
 
                        !(IrpContext->MajorFunction == IRP_MJ_CREATE &&
                          Iosb.Status == STATUS_VERIFY_REQUIRED &&
                          FcbOrDcb != NULL &&
                          NodeType( FcbOrDcb ) == FAT_NTC_FCB)) {
 
                        //
                        //  The call to CcPurgeCacheSection() below will
                        //  purge the entire file from memory.  It will also
                        //  block until all the file's BCB's are pinned.
                        //
                        //  We end up in a deadlock situation of there
                        //  are any other pinned BCB's in this IRP context
                        //  so the first thing we do is search the list
                        //  for BCB's pinned in the same file and unpin
                        //  them.
                        //
                        //  We are probably not going to lose data because
                        //  it's safe to assume that all flushes will
                        //  fail after the first one fails.
                        //
 
                        ULONG j;
                        ULONG k = i + 1;
                        PREPINNED_BCBS RepinnedToPurge = Repinned;
 
                        while( RepinnedToPurge != NULL ) {
 
                            for (j = k; j < REPINNED_BCBS_ARRAY_SIZE; j++) {
 
                                if (RepinnedToPurge->Bcb[j] != NULL) {
 
                                    if (CcGetFileObjectFromBcb( RepinnedToPurge->Bcb[j] ) == FileObject) {
 
                                        CcUnpinRepinnedBcb( RepinnedToPurge->Bcb[j],
                                                            FALSE,
                                                            &Iosb );
 
                                        RepinnedToPurge->Bcb[j] = NULL;
                                    }
                                }
                            }
 
                            RepinnedToPurge = RepinnedToPurge->Next;
                            k = 0;
                        }
 
                        CcPurgeCacheSection( FileObject->SectionObjectPointer,
                                             NULL,
                                             0,
                                             FALSE );
 
                        //
                        //  Force a verify operation here since who knows
                        //  what state things are in.
                        //
 
                        ForceVerify = TRUE;
                    }
                }
 
                Repinned->Bcb[i] = NULL;
 
            }
        }
 
        //
        //  Now find the next repinned record in the list, and possibly
        //  delete the one we've just processed.
        //
 
        if (Repinned != &IrpContext->Repinned) {
 
            PREPINNED_BCBS Saved;
 
            Saved = Repinned->Next;
            ExFreePool( Repinned );
            Repinned = Saved;
 
        } else {
 
            Repinned = Repinned->Next;
            IrpContext->Repinned.Next = NULL;
        }
    }
 
    //
    //  Now if we weren't completely successful in the our unpin
    //  then raise the iosb we got
    //
 
    if (!NT_SUCCESS(RaiseIosb.Status)) {
 
        if (ForceVerify && FileObject) {
 
            SetFlag(FileObject->DeviceObject->Flags, DO_VERIFY_VOLUME);
 
            IoSetHardErrorOrVerifyDevice( IrpContext->OriginatingIrp,
                                          FileObject->DeviceObject );
        }
 
        if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_DISABLE_RAISE )) {
            if (IrpContext->OriginatingIrp) {
                IrpContext->OriginatingIrp->IoStatus = RaiseIosb;
            }
            FatNormalizeAndRaiseStatus( IrpContext, RaiseIosb.Status );
        }
    }
 
    DebugTrace(-1, Dbg, "FatUnpinRepinnedBcbs -> VOID\n", 0 );
 
    return;
}

Referenced by _Requires_lock_held_(), FatCommonSetEa(), FatCompleteRequest_Real(), FatDeferredCleanVolume(), FatSetFsLabelInfo(), and FatSetRenameInfo().

FatZeroData()

FINISHED FatZeroData	(	IN PIRP_CONTEXT	IrpContext,
		IN PVCB	Vcb,
		IN PFILE_OBJECT	FileObject,
		IN ULONG	StartingZero,
		IN ULONG	ByteCount
	)

Definition at line 1659 of file cachesup.c.

{
#ifndef __REACTOS__
    LARGE_INTEGER ZeroStart = {0,0};
    LARGE_INTEGER BeyondZeroEnd = {0,0};
#else
    LARGE_INTEGER ZeroStart = {{0,0}};
    LARGE_INTEGER BeyondZeroEnd = {{0,0}};
#endif
 
    ULONG SectorSize;
 
    BOOLEAN Finished;
 
    PAGED_CODE();
 
    SectorSize = (ULONG)Vcb->Bpb.BytesPerSector;
 
    ZeroStart.LowPart = (StartingZero + (SectorSize - 1)) & ~(SectorSize - 1);
 
    //
    //  Detect overflow if we were asked to zero in the last sector of the file,
    //  which must be "zeroed" already (or we're in trouble).
    //
 
    if (StartingZero != 0 && ZeroStart.LowPart == 0) {
 
        return TRUE;
    }
 
    //
    //  Note that BeyondZeroEnd can take the value 4gb.
    //
 
    BeyondZeroEnd.QuadPart = ((ULONGLONG) StartingZero + ByteCount + (SectorSize - 1))
                             & (~((LONGLONG) SectorSize - 1));
 
    //
    //  If we were called to just zero part of a sector we are in trouble.
    //
 
    if ( ZeroStart.QuadPart == BeyondZeroEnd.QuadPart ) {
 
        return TRUE;
    }
 
    Finished = CcZeroData( FileObject,
                           &ZeroStart,
                           &BeyondZeroEnd,
                           BooleanFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
 
    return Finished;
}

Referenced by _Requires_lock_held_().