flush.c File Reference

#include "ntfs.h"
#include <debug.h>

Include dependency graph for flush.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static NTSTATUS NTAPI	NtfsFlushFileCache (_In_ PNTFS_FCB Fcb)
static NTSTATUS NTAPI	NtfsFlushVolumeFiles (_In_ PDEVICE_EXTENSION DeviceExt)
NtfsFlushBuffers
@implemented Handles IRP_MJ_FLUSH_BUFFERS. Parameters IrpContext Points to an NTFS_IRP_CONTEXT which describes the request Returns STATUS_SUCCESS if everything reached the media, otherwise the status the storage stack returned.
NTSTATUS	NtfsFlushBuffers (PNTFS_IRP_CONTEXT IrpContext)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 7 of file flush.c.

Function Documentation

NtfsFlushBuffers()

NTSTATUS NtfsFlushBuffers

(

PNTFS_IRP_CONTEXT

IrpContext

)

Definition at line 107 of file flush.c.

{
    PDEVICE_EXTENSION DeviceExt;
    PNTFS_FCB Fcb;
    NTSTATUS Status;
    NTSTATUS DeviceStatus;
 
    DPRINT("NtfsFlushBuffers(%p)\n", IrpContext);
 
    IrpContext->Irp->IoStatus.Information = 0;
 
    /* Nothing is mounted on the main device object */
    if (IrpContext->DeviceObject == NtfsGlobalData->DeviceObject)
    {
        return STATUS_SUCCESS;
    }
 
    DeviceExt = IrpContext->DeviceObject->DeviceExtension;
 
    if (DeviceExt->Flags & VCB_VOLUME_DISMOUNTED)
    {
        return STATUS_VOLUME_DISMOUNTED;
    }
 
    /* Flushing waits on the disk */
    if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT))
        return NtfsMarkIrpContextForQueue(IrpContext);
 
    /* Cached writes only reach the disk once the cache lets them go */
    Fcb = (PNTFS_FCB)IrpContext->FileObject->FsContext;
    if (NtfsIsRegularFileObject(IrpContext->FileObject))
        Status = NtfsFlushFileCache(Fcb);
    else if (Fcb != NULL && Fcb->Identifier.Type == NTFS_TYPE_FCB && (Fcb->Flags & FCB_IS_VOLUME))
        Status = NtfsFlushVolumeFiles(DeviceExt);
    else
        Status = STATUS_SUCCESS;
 
    DeviceStatus = NtfsFlushDevice(DeviceExt->StorageDevice);
 
    return NT_SUCCESS(Status) ? DeviceStatus : Status;
}

Referenced by NtfsDispatch().

NtfsFlushFileCache()

static NTSTATUS NTAPI NtfsFlushFileCache ( _In_ PNTFS_FCB  Fcb )

static

Definition at line 16 of file flush.c.

{
    IO_STATUS_BLOCK IoStatus;
 
    if ((Fcb->Flags & FCB_IS_VOLUME) || Fcb->SectionObjectPointers.DataSectionObject == NULL)
        return STATUS_SUCCESS;
 
    /* Keep cached writes out so the flush covers all of them */
    ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);
    CcFlushCache(&Fcb->SectionObjectPointers, NULL, 0, &IoStatus);
    ExReleaseResourceLite(&Fcb->MainResource);
 
    return IoStatus.Status;
}

Referenced by NtfsFlushBuffers(), and NtfsFlushVolumeFiles().

NtfsFlushVolumeFiles()

static NTSTATUS NTAPI NtfsFlushVolumeFiles ( _In_ PDEVICE_EXTENSION  DeviceExt )

static

Definition at line 36 of file flush.c.

{
    PNTFS_FCB *Fcbs;
    PLIST_ENTRY Entry;
    ULONG Count = 0, Taken = 0, i;
    NTSTATUS Status = STATUS_SUCCESS;
    KIRQL OldIrql;
 
    KeAcquireSpinLock(&DeviceExt->FcbListLock, &OldIrql);
    for (Entry = DeviceExt->FcbListHead.Flink; Entry != &DeviceExt->FcbListHead; Entry = Entry->Flink)
        Count++;
    KeReleaseSpinLock(&DeviceExt->FcbListLock, OldIrql);
 
    if (Count == 0)
        return STATUS_SUCCESS;
 
    /* Some slack for files opened meanwhile, the next flush gets the rest */
    Count += 16;
    Fcbs = ExAllocatePoolWithTag(NonPagedPool, Count * sizeof(*Fcbs), TAG_NTFS);
    if (Fcbs == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Take references, a delete may take an FCB off the list while we flush.
     * Unreferenced FCBs only linger for their section and have nothing cached
     * to write; releasing one again would tear it down twice. */
    KeAcquireSpinLock(&DeviceExt->FcbListLock, &OldIrql);
    for (Entry = DeviceExt->FcbListHead.Flink;
         Entry != &DeviceExt->FcbListHead && Taken < Count;
         Entry = Entry->Flink)
    {
        PNTFS_FCB Fcb = CONTAINING_RECORD(Entry, NTFS_FCB, FcbListEntry);
 
        if (Fcb->RefCount <= 0)
            continue;
 
        Fcb->RefCount++;
        Fcbs[Taken++] = Fcb;
    }
    KeReleaseSpinLock(&DeviceExt->FcbListLock, OldIrql);
 
    for (i = 0; i < Taken; i++)
    {
        NTSTATUS FlushStatus = NtfsFlushFileCache(Fcbs[i]);
 
        if (!NT_SUCCESS(FlushStatus) && NT_SUCCESS(Status))
            Status = FlushStatus;
 
        NtfsReleaseFCB(DeviceExt, Fcbs[i]);
    }
 
    ExFreePoolWithTag(Fcbs, TAG_NTFS);
 
    return Status;
}

Referenced by NtfsFlushBuffers().