blockdev.c File Reference

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

Include dependency graph for blockdev.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
VOID	NtfsInitIoRunList (OUT PNTFS_IO_RUN_LIST RunList)
NtfsAddIoRun
@implemented Appends one contiguous piece to a request's run list. Parameters RunList The list being built, previously initialized by NtfsInitIoRunList() Lbo Byte offset on the volume of this piece, or NTFS_SPARSE_LBO if the piece has no backing storage ByteCount Size of this piece, in bytes Returns STATUS_SUCCESS, or STATUS_INSUFFICIENT_RESOURCES if the list had to grow and the allocation failed. Remarks Runs tile the caller's buffer in the order they are added, so the buffer offset is implied. A piece continuing the previous one is merged into it, keeping contiguous files down to a single IRP.
NTSTATUS	NtfsAddIoRun (IN OUT PNTFS_IO_RUN_LIST RunList, IN LONGLONG Lbo, IN ULONG ByteCount)
VOID	NtfsFreeIoRunList (IN OUT PNTFS_IO_RUN_LIST RunList)
static NTSTATUS NTAPI	NtfsIoRunCompletionRoutine (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
static NTSTATUS	NtfsBuildIoRunIrp (IN PDEVICE_OBJECT DeviceObject, IN PNTFS_IO_CONTEXT IoContext, IN UCHAR MajorFunction, IN PUCHAR Buffer, IN ULONG BufferLength, IN OUT PNTFS_IO_RUN Run, IN BOOLEAN Override)
static NTSTATUS	NtfsIssueIoRuns (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MajorFunction, IN OUT PUCHAR Buffer, IN PMDL BorrowedMdl OPTIONAL, IN PNTFS_IO_RUN_LIST RunList, IN BOOLEAN Override, OUT PULONG BytesTransferred)
NtfsPerformIoRuns
@implemented Reads or writes the pieces described by RunList, all in parallel. Parameters DeviceObject Storage device to transfer to or from MajorFunction IRP_MJ_READ or IRP_MJ_WRITE SectorSize Sector size the storage device requires transfers to be aligned to Buffer System-space buffer of RunList->TotalLength bytes, tiled by the runs RunList The pieces to transfer. Consumed by this call: the runs are rewritten in place to satisfy the device's alignment requirements. Override Whether to set SL_OVERRIDE_VERIFY_VOLUME on the requests BytesTransferred Optionally receives how much of the request was satisfied Returns STATUS_SUCCESS on success, STATUS_INSUFFICIENT_RESOURCES if an allocation failed, STATUS_NOT_IMPLEMENTED for a write to a sparse run, since that's probably not happening for this driver
static NTSTATUS	NtfsPerformIoRunsInternal (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MajorFunction, IN ULONG SectorSize, IN OUT PUCHAR Buffer, IN PMDL BorrowedMdl OPTIONAL, IN PNTFS_IO_RUN_LIST RunList, IN BOOLEAN Override, OUT PULONG BytesTransferred OPTIONAL)
static NTSTATUS NTAPI	NtfsForwardedIrpCompletionRoutine (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
static NTSTATUS	NtfsForwardIrpToRun (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MajorFunction, IN PIRP Irp, IN PNTFS_IO_RUN Run, IN BOOLEAN Override, OUT PULONG BytesTransferred)
NtfsPerformIrpIoRuns
@implemented Transfers the runs of a request that originated from an IRP, forwarding that IRP straight to the storage stack when the request allows it. Parameters DeviceObject Storage device to transfer to or from MajorFunction IRP_MJ_READ or IRP_MJ_WRITE SectorSize Sector size the storage device requires transfers to be aligned to Irp The request being served. May be NULL, in which case this is exactly NtfsPerformIoRuns(). Buffer System-space mapping of the IRP's buffer, used whenever the request cannot simply be forwarded RunList The pieces to transfer Override Whether to set SL_OVERRIDE_VERIFY_VOLUME on the requests BytesTransferred Receives how much of the request was satisfied Returns STATUS_SUCCESS on success, otherwise the status of the failing transfer.
NTSTATUS	NtfsPerformIrpIoRuns (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MajorFunction, IN ULONG SectorSize, IN PIRP Irp, IN OUT PUCHAR Buffer, IN PNTFS_IO_RUN_LIST RunList, IN BOOLEAN Override, OUT PULONG BytesTransferred)
NTSTATUS	NtfsPerformIoRuns (IN PDEVICE_OBJECT DeviceObject, IN UCHAR MajorFunction, IN ULONG SectorSize, IN OUT PUCHAR Buffer, IN PNTFS_IO_RUN_LIST RunList, IN BOOLEAN Override, OUT PULONG BytesTransferred OPTIONAL)
NtfsReadDisk
@implemented Reads a single contiguous range from the given DeviceObject. Parameters DeviceObject Device to read from StartingOffset Offset, in bytes, from the start of the device object Length How much data to read, in bytes SectorSize Size of the sector on the disk that the read must be aligned to Buffer System-space buffer receiving the data Override Whether to set SL_OVERRIDE_VERIFY_VOLUME on the request Returns STATUS_SUCCESS in case of success, STATUS_INSUFFICIENT_RESOURCES if a memory allocation failed, or whatever status the storage stack returned.
NTSTATUS	NtfsReadDisk (IN PDEVICE_OBJECT DeviceObject, IN LONGLONG StartingOffset, IN ULONG Length, IN ULONG SectorSize, IN OUT PUCHAR Buffer, IN BOOLEAN Override)
NtfsWriteDisk
@implemented Writes data from the given buffer to the given DeviceObject. Parameters DeviceObject Device to write to StartingOffset Offset, in bytes, from the start of the device object where the data will be written Length How much data will be written, in bytes SectorSize Size of the sector on the disk that the write must be aligned to Buffer The data that's being written to the device Returns STATUS_SUCCESS in case of success, STATUS_INSUFFICIENT_RESOURCES if a memory allocation failed, or whatever status the storage stack returned.
NTSTATUS	NtfsWriteDisk (IN PDEVICE_OBJECT DeviceObject, IN LONGLONG StartingOffset, IN ULONG Length, IN ULONG SectorSize, IN const PUCHAR Buffer)
NtfsFlushDevice
@implemented Asks the storage stack to push everything it is holding out to the media. Parameters DeviceObject Device to flush Returns STATUS_SUCCESS on success, or whatever the storage stack returned.
NTSTATUS	NtfsFlushDevice (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS	NtfsReadSectors (IN PDEVICE_OBJECT DeviceObject, IN ULONG DiskSector, IN ULONG SectorCount, IN ULONG SectorSize, IN OUT PUCHAR Buffer, IN BOOLEAN Override)
NTSTATUS	NtfsDeviceIoControl (IN PDEVICE_OBJECT DeviceObject, IN ULONG ControlCode, IN PVOID InputBuffer, IN ULONG InputBufferSize, IN OUT PVOID OutputBuffer, IN OUT PULONG OutputBufferSize, IN BOOLEAN Override)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 31 of file blockdev.c.

Function Documentation

NtfsAddIoRun()

NTSTATUS NtfsAddIoRun	(	IN OUT PNTFS_IO_RUN_LIST	RunList,
		IN LONGLONG	Lbo,
		IN ULONG	ByteCount
	)

Definition at line 74 of file blockdev.c.

{
    PNTFS_IO_RUN LastRun;
    PNTFS_IO_RUN NewRuns;
    ULONG NewCapacity;
 
    if (ByteCount == 0)
        return STATUS_SUCCESS;
 
    /* Does this piece simply continue the previous one? */
    if (RunList->Count != 0)
    {
        LastRun = &RunList->Runs[RunList->Count - 1];
 
        if (LastRun->ByteCount <= MAXULONG - ByteCount &&
            ((Lbo == NTFS_SPARSE_LBO && LastRun->Lbo == NTFS_SPARSE_LBO) ||
             (Lbo != NTFS_SPARSE_LBO && LastRun->Lbo != NTFS_SPARSE_LBO &&
              LastRun->Lbo + LastRun->ByteCount == Lbo)))
        {
            LastRun->ByteCount += ByteCount;
            RunList->TotalLength += ByteCount;
            return STATUS_SUCCESS;
        }
    }
 
    if (RunList->Count == RunList->Capacity)
    {
        NewCapacity = RunList->Capacity * 2;
 
        /* Non-paged: a run list stays live across the transfer, and a request
         * on the paging path must not fault while walking it. */
        NewRuns = ExAllocatePoolWithTag(NonPagedPool,
                                        NewCapacity * sizeof(NTFS_IO_RUN),
                                        TAG_IO_RUNS);
        if (NewRuns == NULL)
        {
            DPRINT1("Not enough memory to grow the I/O run list!\n");
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlCopyMemory(NewRuns, RunList->Runs, RunList->Count * sizeof(NTFS_IO_RUN));
 
        if (RunList->Runs != RunList->StackRuns)
        {
            ExFreePoolWithTag(RunList->Runs, TAG_IO_RUNS);
        }
 
        RunList->Runs = NewRuns;
        RunList->Capacity = NewCapacity;
    }
 
    LastRun = &RunList->Runs[RunList->Count];
    LastRun->Lbo = Lbo;
    LastRun->BufferOffset = RunList->TotalLength;
    LastRun->ByteCount = ByteCount;
    LastRun->SavedIrp = NULL;
 
    RunList->Count++;
    RunList->TotalLength += ByteCount;
 
    return STATUS_SUCCESS;
}

Referenced by NtfsMapAttributeRuns(), NtfsReadDisk(), NtfsReadWriteVolume(), and NtfsWriteDisk().

NtfsBuildIoRunIrp()

static NTSTATUS NtfsBuildIoRunIrp ( IN PDEVICE_OBJECT  DeviceObject, IN PNTFS_IO_CONTEXT  IoContext, IN UCHAR  MajorFunction, IN PUCHAR  Buffer, IN ULONG  BufferLength, IN OUT PNTFS_IO_RUN  Run, IN BOOLEAN  Override  )

static

Definition at line 204 of file blockdev.c.

{
    PIO_STACK_LOCATION Stack;
    PIRP Irp;
    PMDL Mdl;
 
    Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
    if (Irp == NULL)
    {
        DPRINT1("IoAllocateIrp failed!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (Run->BufferOffset == 0 && Run->ByteCount == BufferLength)
    {
        Mdl = IoContext->MasterMdl;
    }
    else
    {
        PUCHAR MasterVa = (PUCHAR)IoContext->MasterVa + Run->BufferOffset;
 
        Mdl = IoAllocateMdl(MasterVa,
                            Run->ByteCount,
                            FALSE,
                            FALSE,
                            NULL);
        if (Mdl == NULL)
        {
            DPRINT1("IoAllocateMdl failed!\n");
            IoFreeIrp(Irp);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        IoBuildPartialMdl(IoContext->MasterMdl,
                          Mdl,
                          MasterVa,
                          Run->ByteCount);
    }
 
    Irp->MdlAddress = Mdl;
    Irp->Flags |= IRP_NOCACHE;
 
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = MajorFunction;
    Stack->Parameters.Read.Length = Run->ByteCount;
    Stack->Parameters.Read.ByteOffset.QuadPart = Run->Lbo;
 
    if (Override)
    {
        Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
    }
 
    IoSetCompletionRoutine(Irp,
                           NtfsIoRunCompletionRoutine,
                           IoContext,
                           TRUE,
                           TRUE,
                           TRUE);
 
    Run->SavedIrp = Irp;
 
    return STATUS_SUCCESS;
}

Referenced by NtfsIssueIoRuns().

NtfsDeviceIoControl()

NTSTATUS NtfsDeviceIoControl	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	ControlCode,
		IN PVOID	InputBuffer,
		IN ULONG	InputBufferSize,
		IN OUT PVOID	OutputBuffer,
		IN OUT PULONG	OutputBufferSize,
		IN BOOLEAN	Override
	)

Definition at line 1029 of file blockdev.c.

{
    PIO_STACK_LOCATION Stack;
    IO_STATUS_BLOCK IoStatus;
    KEVENT Event;
    PIRP Irp;
    NTSTATUS Status;
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    IoStatus.Status = STATUS_SUCCESS;
    IoStatus.Information = 0;
 
    DPRINT("Building device I/O control request ...\n");
    Irp = IoBuildDeviceIoControlRequest(ControlCode,
                                        DeviceObject,
                                        InputBuffer,
                                        InputBufferSize,
                                        OutputBuffer,
                                        (OutputBufferSize) ? *OutputBufferSize : 0,
                                        FALSE,
                                        &Event,
                                        &IoStatus);
    if (Irp == NULL)
    {
        DPRINT("IoBuildDeviceIoControlRequest() failed\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (Override)
    {
        Stack = IoGetNextIrpStackLocation(Irp);
        Stack->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
    }
 
    DPRINT("Calling IO Driver... with irp %p\n", Irp);
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatus.Status;
    }
 
    if (OutputBufferSize)
    {
        *OutputBufferSize = IoStatus.Information;
    }
 
    return Status;
}

Referenced by NtfsGetVolumeData(), and NtfsHasFileSystem().

NtfsFlushDevice()

NTSTATUS NtfsFlushDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 964 of file blockdev.c.

{
    NTFS_IO_CONTEXT IoContext;
    PIO_STACK_LOCATION Stack;
    NTSTATUS Status;
    PIRP Irp;
 
    Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
    if (Irp == NULL)
    {
        DPRINT1("IoAllocateIrp failed!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(&IoContext, sizeof(IoContext));
    KeInitializeEvent(&IoContext.SyncEvent, NotificationEvent, FALSE);
    IoContext.Status = STATUS_SUCCESS;
    IoContext.IrpCount = 1;
 
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = IRP_MJ_FLUSH_BUFFERS;
 
    IoSetCompletionRoutine(Irp,
                           NtfsIoRunCompletionRoutine,
                           &IoContext,
                           TRUE,
                           TRUE,
                           TRUE);
 
    (VOID)IoCallDriver(DeviceObject, Irp);
 
    KeWaitForSingleObject(&IoContext.SyncEvent, Executive, KernelMode, FALSE, NULL);
 
    Status = (NTSTATUS)IoContext.Status;
 
    if (Status == STATUS_INVALID_DEVICE_REQUEST ||
        Status == STATUS_NOT_SUPPORTED)
    {
        Status = STATUS_SUCCESS;
    }
 
    DPRINT("NtfsFlushDevice() done (Status %lx)\n", Status);
 
    return Status;
}

Referenced by NtfsFlushBuffers().

NtfsForwardedIrpCompletionRoutine()

static NTSTATUS NTAPI NtfsForwardedIrpCompletionRoutine ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp, IN PVOID  Context  )

static

Definition at line 642 of file blockdev.c.

{
    PNTFS_IO_CONTEXT IoContext = (PNTFS_IO_CONTEXT)Context;
 
    UNREFERENCED_PARAMETER(DeviceObject);
 
    IoContext->Status = Irp->IoStatus.Status;
    IoContext->BytesTransferred = (LONG)Irp->IoStatus.Information;
 
    KeSetEvent(&IoContext->SyncEvent, IO_NO_INCREMENT, FALSE);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by NtfsForwardIrpToRun().

NtfsForwardIrpToRun()

static NTSTATUS NtfsForwardIrpToRun ( IN PDEVICE_OBJECT  DeviceObject, IN UCHAR  MajorFunction, IN PIRP  Irp, IN PNTFS_IO_RUN  Run, IN BOOLEAN  Override, OUT PULONG  BytesTransferred  )

static

Definition at line 663 of file blockdev.c.

{
    NTFS_IO_CONTEXT IoContext;
    PIO_STACK_LOCATION Stack;
 
    DPRINT("Forwarding IRP %p for a single run at %I64x, %lu bytes\n",
           Irp, Run->Lbo, Run->ByteCount);
 
    RtlZeroMemory(&IoContext, sizeof(IoContext));
    KeInitializeEvent(&IoContext.SyncEvent, NotificationEvent, FALSE);
    IoContext.Status = STATUS_SUCCESS;
 
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = MajorFunction;
    Stack->MinorFunction = 0;
    Stack->FileObject = NULL;
    Stack->Parameters.Read.Length = Run->ByteCount;
    Stack->Parameters.Read.ByteOffset.QuadPart = Run->Lbo;
    Stack->Flags = Override ? SL_OVERRIDE_VERIFY_VOLUME : 0;
 
    /* Must come last: it takes over Control on this same stack location. */
    IoSetCompletionRoutine(Irp,
                           NtfsForwardedIrpCompletionRoutine,
                           &IoContext,
                           TRUE,
                           TRUE,
                           TRUE);
 
    (VOID)IoCallDriver(DeviceObject, Irp);
 
    KeWaitForSingleObject(&IoContext.SyncEvent, Executive, KernelMode, FALSE, NULL);
 
    *BytesTransferred = (ULONG)IoContext.BytesTransferred;
 
    return (NTSTATUS)IoContext.Status;
}

Referenced by NtfsPerformIrpIoRuns().

NtfsFreeIoRunList()

VOID NtfsFreeIoRunList

(

IN OUT PNTFS_IO_RUN_LIST

RunList

)

Definition at line 140 of file blockdev.c.

{
    if (RunList->Runs != RunList->StackRuns && RunList->Runs != NULL)
    {
        ExFreePoolWithTag(RunList->Runs, TAG_IO_RUNS);
    }
 
    RunList->Runs = NULL;
    RunList->Count = 0;
    RunList->Capacity = 0;
    RunList->TotalLength = 0;
}

Referenced by NtfsReadDisk(), NtfsReadWriteVolume(), NtfsWriteDisk(), ReadAttributeToIrp(), and WriteAttributeFromIrp().

NtfsInitIoRunList()

VOID NtfsInitIoRunList

(

OUT PNTFS_IO_RUN_LIST

RunList

)

Definition at line 40 of file blockdev.c.

{
    RunList->Runs = RunList->StackRuns;
    RunList->Capacity = NTFS_MAX_IO_RUNS_ON_STACK;
    RunList->Count = 0;
    RunList->TotalLength = 0;
}

Referenced by NtfsReadDisk(), NtfsReadWriteVolume(), NtfsWriteDisk(), ReadAttributeToIrp(), and WriteAttributeFromIrp().

NtfsIoRunCompletionRoutine()

static NTSTATUS NTAPI NtfsIoRunCompletionRoutine ( IN PDEVICE_OBJECT  DeviceObject, IN PIRP  Irp, IN PVOID  Context  )

static

Definition at line 162 of file blockdev.c.

{
    PNTFS_IO_CONTEXT IoContext = (PNTFS_IO_CONTEXT)Context;
 
    UNREFERENCED_PARAMETER(DeviceObject);
 
    if (NT_SUCCESS(Irp->IoStatus.Status))
    {
        InterlockedExchangeAdd(&IoContext->BytesTransferred,
                               (LONG)Irp->IoStatus.Information);
    }
    else
    {
        /* First error wins; STATUS_SUCCESS is the "nothing failed yet" sentinel. */
        InterlockedCompareExchange(&IoContext->Status,
                                   Irp->IoStatus.Status,
                                   STATUS_SUCCESS);
    }
 
    /* The master MDL belongs to the issuer and outlives every run built from it. */
    if (Irp->MdlAddress != NULL && Irp->MdlAddress != IoContext->MasterMdl)
    {
        IoFreeMdl(Irp->MdlAddress);
    }
 
    IoFreeIrp(Irp);
 
    if (InterlockedDecrement(&IoContext->IrpCount) == 0)
    {
        KeSetEvent(&IoContext->SyncEvent, IO_NO_INCREMENT, FALSE);
    }
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

Referenced by NtfsBuildIoRunIrp(), and NtfsFlushDevice().

NtfsIssueIoRuns()

static NTSTATUS NtfsIssueIoRuns ( IN PDEVICE_OBJECT  DeviceObject, IN UCHAR  MajorFunction, IN OUT PUCHAR  Buffer, IN PMDL BorrowedMdl  OPTIONAL, IN PNTFS_IO_RUN_LIST  RunList, IN BOOLEAN  Override, OUT PULONG  BytesTransferred  )

static

Definition at line 276 of file blockdev.c.

{
    NTFS_IO_CONTEXT IoContext;
    NTSTATUS Status = STATUS_SUCCESS;
    PNTFS_IO_RUN Run;
    ULONG DiskRunCount = 0;
    ULONG Index;
    ULONG BuiltCount = 0;
    PIRP Irp;
 
    *BytesTransferred = 0;
 
    RtlZeroMemory(&IoContext, sizeof(IoContext));
    KeInitializeEvent(&IoContext.SyncEvent, NotificationEvent, FALSE);
    IoContext.Status = STATUS_SUCCESS;
 
    /* Satisfy the sparse runs, and see if any real I/O is left */
    for (Index = 0; Index < RunList->Count; Index++)
    {
        Run = &RunList->Runs[Index];
 
        if (Run->Lbo != NTFS_SPARSE_LBO)
        {
            DiskRunCount++;
            continue;
        }
 
        if (MajorFunction != IRP_MJ_READ)
        {
            DPRINT1("FIXME: Writing to sparse files is not supported yet!\n");
            return STATUS_NOT_IMPLEMENTED;
        }
 
        RtlZeroMemory(Buffer + Run->BufferOffset, Run->ByteCount);
        *BytesTransferred += Run->ByteCount;
    }
 
    if (DiskRunCount == 0)
    {
        return STATUS_SUCCESS;
    }
 
    if (BorrowedMdl != NULL)
    {
        IoContext.MasterMdl = BorrowedMdl;
        IoContext.MasterVa = MmGetMdlVirtualAddress(BorrowedMdl);
        IoContext.OwnsMasterMdl = FALSE;
    }
    else
    {
        /* Our own buffer: describe and lock it once */
        IoContext.MasterMdl = IoAllocateMdl(Buffer, RunList->TotalLength, FALSE, FALSE, NULL);
        if (IoContext.MasterMdl == NULL)
        {
            DPRINT1("IoAllocateMdl failed!\n");
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        _SEH2_TRY
        {
            MmProbeAndLockPages(IoContext.MasterMdl,
                                KernelMode,
                                (MajorFunction == IRP_MJ_READ) ? IoWriteAccess : IoReadAccess);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
 
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("MmProbeAndLockPages failed (Status %lx)\n", Status);
            IoFreeMdl(IoContext.MasterMdl);
            return Status;
        }
 
        IoContext.MasterVa = Buffer;
        IoContext.OwnsMasterMdl = TRUE;
    }
 
    /* Build everything before issuing anything */
    for (Index = 0; Index < RunList->Count; Index++)
    {
        Run = &RunList->Runs[Index];
 
        if (Run->Lbo == NTFS_SPARSE_LBO)
            continue;
 
        Status = NtfsBuildIoRunIrp(DeviceObject,
                                   &IoContext,
                                   MajorFunction,
                                   Buffer,
                                   RunList->TotalLength,
                                   Run,
                                   Override);
        if (!NT_SUCCESS(Status))
            break;
 
        BuiltCount++;
    }
 
    if (!NT_SUCCESS(Status))
    {
        for (Index = 0; Index < RunList->Count; Index++)
        {
            Run = &RunList->Runs[Index];
 
            if (Run->SavedIrp == NULL)
                continue;
 
            if (Run->SavedIrp->MdlAddress != NULL &&
                Run->SavedIrp->MdlAddress != IoContext.MasterMdl)
            {
                IoFreeMdl(Run->SavedIrp->MdlAddress);
            }
 
            IoFreeIrp(Run->SavedIrp);
            Run->SavedIrp = NULL;
        }
 
        if (IoContext.OwnsMasterMdl)
        {
            MmUnlockPages(IoContext.MasterMdl);
            IoFreeMdl(IoContext.MasterMdl);
        }
 
        return Status;
    }
 
    /* Publish the count before the first completion routine can run. */
    IoContext.IrpCount = BuiltCount;
 
    for (Index = 0; Index < RunList->Count; Index++)
    {
        Run = &RunList->Runs[Index];
 
        if (Run->SavedIrp == NULL)
            continue;
 
        /* The completion routine frees the IRP, so drop our pointer first */
        Irp = Run->SavedIrp;
        Run->SavedIrp = NULL;
 
        /* A failure here is completed by the lower driver and picked up by
         * our completion routine like any other I/O error */
        (VOID)IoCallDriver(DeviceObject, Irp);
    }
 
    KeWaitForSingleObject(&IoContext.SyncEvent, Executive, KernelMode, FALSE, NULL);
 
    if (IoContext.OwnsMasterMdl)
    {
        MmUnlockPages(IoContext.MasterMdl);
        IoFreeMdl(IoContext.MasterMdl);
    }
 
    Status = (NTSTATUS)IoContext.Status;
    if (NT_SUCCESS(Status))
    {
        *BytesTransferred += (ULONG)IoContext.BytesTransferred;
    }
 
    return Status;
}

Referenced by NtfsPerformIoRunsInternal().

NtfsPerformIoRuns()

NTSTATUS NtfsPerformIoRuns	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	MajorFunction,
		IN ULONG	SectorSize,
		IN OUT PUCHAR	Buffer,
		IN PNTFS_IO_RUN_LIST	RunList,
		IN BOOLEAN	Override,
		OUT PULONG BytesTransferred	OPTIONAL
	)

Definition at line 788 of file blockdev.c.

{
    return NtfsPerformIoRunsInternal(DeviceObject,
                                     MajorFunction,
                                     SectorSize,
                                     Buffer,
                                     NULL,
                                     RunList,
                                     Override,
                                     BytesTransferred);
}

Referenced by NtfsReadDisk(), and NtfsWriteDisk().

NtfsPerformIoRunsInternal()

static NTSTATUS NtfsPerformIoRunsInternal ( IN PDEVICE_OBJECT  DeviceObject, IN UCHAR  MajorFunction, IN ULONG  SectorSize, IN OUT PUCHAR  Buffer, IN PMDL BorrowedMdl  OPTIONAL, IN PNTFS_IO_RUN_LIST  RunList, IN BOOLEAN  Override, OUT PULONG BytesTransferred  OPTIONAL  )

static

Definition at line 483 of file blockdev.c.

{
    NTSTATUS Status;
    PNTFS_IO_RUN FirstRun;
    PNTFS_IO_RUN LastRun;
    PUCHAR BounceBuffer;
    LONGLONG EndLbo;
    ULONG FrontPad = 0;
    ULONG BackPad = 0;
    ULONG BounceLength;
    ULONG Transferred = 0;
    ULONG Index;
    ULONG Length;
 
    if (BytesTransferred != NULL)
        *BytesTransferred = 0;
 
    if (RunList->Count == 0 || RunList->TotalLength == 0)
        return STATUS_SUCCESS;
 
    ASSERT(SectorSize != 0);
 
    Length = RunList->TotalLength;
    FirstRun = &RunList->Runs[0];
    LastRun = &RunList->Runs[RunList->Count - 1];
 
    /* Only the first run can start unaligned and only the last can end
     * unaligned; the rest sit on cluster boundaries */
    if (FirstRun->Lbo != NTFS_SPARSE_LBO)
    {
        FrontPad = (ULONG)(FirstRun->Lbo % SectorSize);
    }
 
    if (LastRun->Lbo != NTFS_SPARSE_LBO)
    {
        EndLbo = LastRun->Lbo + LastRun->ByteCount;
        BackPad = (ULONG)(ROUND_UP(EndLbo, (LONGLONG)SectorSize) - EndLbo);
    }
 
    if (FrontPad == 0 && BackPad == 0)
    {
        Status = NtfsIssueIoRuns(DeviceObject,
                                 MajorFunction,
                                 Buffer,
                                 BorrowedMdl,
                                 RunList,
                                 Override,
                                 &Transferred);
 
        if (BytesTransferred != NULL)
            *BytesTransferred = min(Transferred, Length);
 
        return Status;
    }
 
    BounceLength = FrontPad + Length + BackPad;
 
    BounceBuffer = ExAllocatePoolWithTag(NonPagedPool, BounceLength, TAG_NTFS);
    if (BounceBuffer == NULL)
    {
        DPRINT1("Not enough memory for an unaligned transfer!\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Grow the request out to whole sectors; everything after the first run
     * slides along by what we prepended */
    for (Index = 1; Index < RunList->Count; Index++)
    {
        RunList->Runs[Index].BufferOffset += FrontPad;
    }
 
    FirstRun->BufferOffset = 0;
    FirstRun->ByteCount += FrontPad;
    if (FirstRun->Lbo != NTFS_SPARSE_LBO)
        FirstRun->Lbo -= FrontPad;
 
    LastRun->ByteCount += BackPad;
    RunList->TotalLength = BounceLength;
 
    Status = STATUS_SUCCESS;
 
    if (MajorFunction != IRP_MJ_READ)
    {
        if (FrontPad != 0)
        {
            Status = NtfsReadDisk(DeviceObject,
                                  FirstRun->Lbo,
                                  SectorSize,
                                  SectorSize,
                                  BounceBuffer,
                                  Override);
        }
 
        /* Skip only if the read above already fetched this same sector */
        if (NT_SUCCESS(Status) &&
            BackPad != 0 &&
            (FrontPad == 0 || BounceLength > SectorSize))
        {
            Status = NtfsReadDisk(DeviceObject,
                                  LastRun->Lbo + LastRun->ByteCount - SectorSize,
                                  SectorSize,
                                  SectorSize,
                                  BounceBuffer + BounceLength - SectorSize,
                                  Override);
        }
 
        if (NT_SUCCESS(Status))
        {
            RtlCopyMemory(BounceBuffer + FrontPad, Buffer, Length);
        }
    }
 
    if (NT_SUCCESS(Status))
    {
        /* The bounce buffer is ours, so there is no MDL to borrow here. */
        Status = NtfsIssueIoRuns(DeviceObject,
                                 MajorFunction,
                                 BounceBuffer,
                                 NULL,
                                 RunList,
                                 Override,
                                 &Transferred);
 
        if (NT_SUCCESS(Status))
        {
            if (MajorFunction == IRP_MJ_READ)
            {
                RtlCopyMemory(Buffer, BounceBuffer + FrontPad, Length);
            }
 
            if (BytesTransferred != NULL)
            {
                /* The padding is ours, not the caller's. */
                Transferred = (Transferred > FrontPad) ? Transferred - FrontPad : 0;
                *BytesTransferred = min(Transferred, Length);
            }
        }
    }
 
    /* The bounce buffer can hold user data; do not leave it in pool. */
    RtlSecureZeroMemory(BounceBuffer, BounceLength);
    ExFreePoolWithTag(BounceBuffer, TAG_NTFS);
 
    return Status;
}

Referenced by NtfsPerformIoRuns(), and NtfsPerformIrpIoRuns().

NtfsPerformIrpIoRuns()

NTSTATUS NtfsPerformIrpIoRuns	(	IN PDEVICE_OBJECT	DeviceObject,
		IN UCHAR	MajorFunction,
		IN ULONG	SectorSize,
		IN PIRP	Irp,
		IN OUT PUCHAR	Buffer,
		IN PNTFS_IO_RUN_LIST	RunList,
		IN BOOLEAN	Override,
		OUT PULONG	BytesTransferred
	)

Definition at line 743 of file blockdev.c.

{
    PMDL BorrowedMdl = NULL;
 
    if (Irp != NULL &&
        Irp->MdlAddress != NULL &&
        RunList->TotalLength <= MmGetMdlByteCount(Irp->MdlAddress))
    {
        /* Buffer maps exactly the pages this MDL describes, so it can stand
         * in for one of our own, and on the paging path it must */
        BorrowedMdl = Irp->MdlAddress;
 
        /* One aligned run covering the lot goes straight down to the disk */
        if (RunList->Count == 1 &&
            RunList->Runs[0].Lbo != NTFS_SPARSE_LBO &&
            (RunList->Runs[0].Lbo % SectorSize) == 0 &&
            (RunList->Runs[0].ByteCount % SectorSize) == 0)
        {
            return NtfsForwardIrpToRun(DeviceObject,
                                       MajorFunction,
                                       Irp,
                                       &RunList->Runs[0],
                                       Override,
                                       BytesTransferred);
        }
    }
 
    return NtfsPerformIoRunsInternal(DeviceObject,
                                     MajorFunction,
                                     SectorSize,
                                     Buffer,
                                     BorrowedMdl,
                                     RunList,
                                     Override,
                                     BytesTransferred);
}

Referenced by NtfsReadWriteVolume(), ReadAttributeToIrp(), and WriteAttributeFromIrp().

NtfsReadDisk()

NTSTATUS NtfsReadDisk	(	IN PDEVICE_OBJECT	DeviceObject,
		IN LONGLONG	StartingOffset,
		IN ULONG	Length,
		IN ULONG	SectorSize,
		IN OUT PUCHAR	Buffer,
		IN BOOLEAN	Override
	)

Definition at line 836 of file blockdev.c.

{
    NTFS_IO_RUN_LIST RunList;
    NTSTATUS Status;
    ULONG Transferred;
 
    DPRINT("NtfsReadDisk(%p, %I64x, %lu, %lu, %p, %d)\n",
           DeviceObject, StartingOffset, Length, SectorSize, Buffer, Override);
 
    if (Length == 0)
        return STATUS_SUCCESS;
 
    NtfsInitIoRunList(&RunList);
 
    Status = NtfsAddIoRun(&RunList, StartingOffset, Length);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = NtfsPerformIoRuns(DeviceObject,
                               IRP_MJ_READ,
                               SectorSize,
                               Buffer,
                               &RunList,
                               Override,
                               &Transferred);
 
    NtfsFreeIoRunList(&RunList);
 
    if (NT_SUCCESS(Status) && Transferred != Length)
    {
        DPRINT1("Short read: asked for %lu bytes, got %lu\n", Length, Transferred);
        Status = STATUS_UNEXPECTED_IO_ERROR;
    }
 
    DPRINT("NtfsReadDisk() done (Status %x)\n", Status);
 
    return Status;
}

Referenced by NtfsPerformIoRunsInternal(), and NtfsReadSectors().

NtfsReadSectors()

NTSTATUS NtfsReadSectors	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	DiskSector,
		IN ULONG	SectorCount,
		IN ULONG	SectorSize,
		IN OUT PUCHAR	Buffer,
		IN BOOLEAN	Override
	)

Definition at line 1011 of file blockdev.c.

{
    LONGLONG Offset;
    ULONG BlockSize;
 
    Offset = (LONGLONG)DiskSector * (LONGLONG)SectorSize;
    BlockSize = SectorCount * SectorSize;
 
    return NtfsReadDisk(DeviceObject, Offset, BlockSize, SectorSize, Buffer, Override);
}

Referenced by NtfsGetVolumeData(), NtfsHasFileSystem(), and ReadLCN().

NtfsWriteDisk()

NTSTATUS NtfsWriteDisk	(	IN PDEVICE_OBJECT	DeviceObject,
		IN LONGLONG	StartingOffset,
		IN ULONG	Length,
		IN ULONG	SectorSize,
		IN const PUCHAR	Buffer
	)

Definition at line 907 of file blockdev.c.

{
    NTFS_IO_RUN_LIST RunList;
    NTSTATUS Status;
    ULONG Transferred;
 
    DPRINT("NtfsWriteDisk(%p, %I64x, %lu, %lu, %p)\n",
           DeviceObject, StartingOffset, Length, SectorSize, Buffer);
 
    if (Length == 0)
        return STATUS_SUCCESS;
 
    NtfsInitIoRunList(&RunList);
 
    Status = NtfsAddIoRun(&RunList, StartingOffset, Length);
    if (!NT_SUCCESS(Status))
        return Status;
 
    Status = NtfsPerformIoRuns(DeviceObject,
                               IRP_MJ_WRITE,
                               SectorSize,
                               Buffer,
                               &RunList,
                               FALSE,
                               &Transferred);
 
    NtfsFreeIoRunList(&RunList);
 
    if (NT_SUCCESS(Status) && Transferred != Length)
    {
        DPRINT1("Short write: asked for %lu bytes, wrote %lu\n", Length, Transferred);
        Status = STATUS_UNEXPECTED_IO_ERROR;
    }
 
    DPRINT("NtfsWriteDisk() done (Status %x)\n", Status);
 
    return Status;
}