mirror of
https://github.com/reactos/reactos.git
synced 2024-08-29 22:58:34 +00:00
4196 lines
114 KiB
C
4196 lines
114 KiB
C
/*++
|
|
|
|
Copyright (c) 1989-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
DevIoSup.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the low lever disk read/write support for Cdfs.
|
|
|
|
|
|
--*/
|
|
|
|
#include "cdprocs.h"
|
|
|
|
//
|
|
// The Bug check file id for this module
|
|
//
|
|
|
|
#define BugCheckFileId (CDFS_BUG_CHECK_DEVIOSUP)
|
|
|
|
//
|
|
// Local structure definitions
|
|
//
|
|
|
|
//
|
|
// An array of these structures is passed to CdMultipleAsync describing
|
|
// a set of runs to execute in parallel.
|
|
//
|
|
|
|
typedef struct _IO_RUN {
|
|
|
|
//
|
|
// Disk offset to read from and number of bytes to read. These
|
|
// must be a multiple of 2048 and the disk offset is also a
|
|
// multiple of 2048.
|
|
//
|
|
|
|
LONGLONG DiskOffset;
|
|
ULONG DiskByteCount;
|
|
|
|
//
|
|
// Current position in user buffer. This is the final destination for
|
|
// this portion of the Io transfer.
|
|
//
|
|
|
|
PVOID UserBuffer;
|
|
|
|
//
|
|
// Buffer to perform the transfer to. If this is the same as the
|
|
// user buffer above then we are using the user's buffer. Otherwise
|
|
// we either allocated a temporary buffer or are using a different portion
|
|
// of the user's buffer.
|
|
//
|
|
// TransferBuffer - Read full sectors into this location. This can
|
|
// be a pointer into the user's buffer at the exact location the
|
|
// data should go. It can also be an earlier point in the user's
|
|
// buffer if the complete I/O doesn't start on a sector boundary.
|
|
// It may also be a pointer into an allocated buffer.
|
|
//
|
|
// TransferByteCount - Count of bytes to transfer to user's buffer. A
|
|
// value of zero indicates that we did do the transfer into the
|
|
// user's buffer directly.
|
|
//
|
|
// TransferBufferOffset - Offset in this buffer to begin the transfer
|
|
// to the user's buffer.
|
|
//
|
|
|
|
PVOID TransferBuffer;
|
|
ULONG TransferByteCount;
|
|
ULONG TransferBufferOffset;
|
|
|
|
//
|
|
// This is the Mdl describing the locked pages in memory. It may
|
|
// be allocated to describe the allocated buffer. Or it may be
|
|
// the Mdl in the originating Irp. The MdlOffset is the offset of
|
|
// the current buffer from the beginning of the buffer described by
|
|
// the Mdl below. If the TransferMdl is not the same as the Mdl
|
|
// in the user's Irp then we know we have allocated it.
|
|
//
|
|
|
|
PMDL TransferMdl;
|
|
PVOID TransferVirtualAddress;
|
|
|
|
//
|
|
// Associated Irp used to perform the Io.
|
|
//
|
|
|
|
PIRP SavedIrp;
|
|
|
|
} IO_RUN;
|
|
typedef IO_RUN *PIO_RUN;
|
|
|
|
#define MAX_PARALLEL_IOS 5
|
|
|
|
//
|
|
// Local support routines
|
|
//
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
BOOLEAN
|
|
CdPrepareBuffers (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PIRP Irp,
|
|
_In_ PFCB Fcb,
|
|
_In_reads_bytes_(ByteCount) PVOID UserBuffer,
|
|
_In_ ULONG UserBufferOffset,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ ULONG ByteCount,
|
|
_Out_ PIO_RUN IoRuns,
|
|
_Out_ PULONG RunCount,
|
|
_Out_ PULONG ThisByteCount
|
|
);
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
VOID
|
|
CdPrepareXABuffers (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PIRP Irp,
|
|
_In_ PFCB Fcb,
|
|
_In_reads_bytes_(ByteCount) PVOID UserBuffer,
|
|
_In_ ULONG UserBufferOffset,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ ULONG ByteCount,
|
|
_Out_ PIO_RUN IoRuns,
|
|
_Out_ PULONG RunCount,
|
|
_Out_ PULONG ThisByteCount
|
|
);
|
|
|
|
BOOLEAN
|
|
CdFinishBuffers (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_Inout_ PIO_RUN IoRuns,
|
|
_In_ ULONG RunCount,
|
|
_In_ BOOLEAN FinalCleanup,
|
|
_In_ BOOLEAN SaveXABuffer
|
|
);
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
VOID
|
|
CdMultipleAsync (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PFCB Fcb,
|
|
_In_ ULONG RunCount,
|
|
_Inout_ PIO_RUN IoRuns
|
|
);
|
|
|
|
VOID
|
|
CdMultipleXAAsync (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ ULONG RunCount,
|
|
_Inout_ PIO_RUN IoRuns,
|
|
_In_ PRAW_READ_INFO RawReads,
|
|
_In_ TRACK_MODE_TYPE TrackMode
|
|
);
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
VOID
|
|
CdSingleAsync (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PIO_RUN Run,
|
|
_In_ PFCB Fcb
|
|
);
|
|
|
|
VOID
|
|
CdWaitSync (
|
|
_In_ PIRP_CONTEXT IrpContext
|
|
);
|
|
|
|
// Tell prefast this is a completion routine.
|
|
IO_COMPLETION_ROUTINE CdMultiSyncCompletionRoutine;
|
|
|
|
// Tell prefast this is a completion routine
|
|
IO_COMPLETION_ROUTINE CdMultiAsyncCompletionRoutine;
|
|
|
|
// Tell prefast this is a completion routine
|
|
IO_COMPLETION_ROUTINE CdSingleSyncCompletionRoutine;
|
|
|
|
// Tell prefast this is a completion routine
|
|
IO_COMPLETION_ROUTINE CdSingleAsyncCompletionRoutine;
|
|
|
|
_When_(SafeNodeType(Fcb) != CDFS_NTC_FCB_PATH_TABLE && StartingOffset == 0, _At_(ByteCount, _In_range_(>=, CdAudioDirentSize + sizeof(RAW_DIRENT))))
|
|
_When_(SafeNodeType(Fcb) != CDFS_NTC_FCB_PATH_TABLE && StartingOffset != 0, _At_(ByteCount, _In_range_(>=, CdAudioDirentSize + SECTOR_SIZE)))
|
|
VOID
|
|
CdReadAudioSystemFile (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PFCB Fcb,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ _In_range_(>=, CdAudioDirentSize) ULONG ByteCount,
|
|
_Out_writes_bytes_(ByteCount) PVOID SystemBuffer
|
|
);
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
BOOLEAN
|
|
CdReadDirDataThroughCache (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PIO_RUN Run
|
|
);
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, CdCreateUserMdl)
|
|
#pragma alloc_text(PAGE, CdMultipleAsync)
|
|
#pragma alloc_text(PAGE, CdMultipleXAAsync)
|
|
#pragma alloc_text(PAGE, CdNonCachedRead)
|
|
#pragma alloc_text(PAGE, CdNonCachedXARead)
|
|
#pragma alloc_text(PAGE, CdVolumeDasdWrite)
|
|
#pragma alloc_text(PAGE, CdFinishBuffers)
|
|
#pragma alloc_text(PAGE, CdPerformDevIoCtrl)
|
|
#pragma alloc_text(PAGE, CdPerformDevIoCtrlEx)
|
|
#pragma alloc_text(PAGE, CdPrepareBuffers)
|
|
#pragma alloc_text(PAGE, CdPrepareXABuffers)
|
|
#pragma alloc_text(PAGE, CdReadAudioSystemFile)
|
|
#pragma alloc_text(PAGE, CdReadSectors)
|
|
#pragma alloc_text(PAGE, CdSingleAsync)
|
|
#pragma alloc_text(PAGE, CdWaitSync)
|
|
#pragma alloc_text(PAGE, CdReadDirDataThroughCache)
|
|
#pragma alloc_text(PAGE, CdFreeDirCache)
|
|
#pragma alloc_text(PAGE, CdLbnToMmSsFf)
|
|
#pragma alloc_text(PAGE, CdHijackIrpAndFlushDevice)
|
|
#endif
|
|
|
|
|
|
VOID
|
|
CdLbnToMmSsFf (
|
|
_In_ ULONG Blocks,
|
|
_Out_writes_(3) PUCHAR Msf
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Convert Lbn to MSF format.
|
|
|
|
Arguments:
|
|
|
|
Msf - on output, set to 0xMmSsFf representation of blocks.
|
|
|
|
--*/
|
|
|
|
{
|
|
PAGED_CODE();
|
|
|
|
Blocks += 150; // Lbn 0 == 00:02:00, 1sec == 75 frames.
|
|
|
|
Msf[0] = (UCHAR)(Blocks % 75); // Frames
|
|
Blocks /= 75; // -> Seconds
|
|
Msf[1] = (UCHAR)(Blocks % 60); // Seconds
|
|
Blocks /= 60; // -> Minutes
|
|
Msf[2] = (UCHAR)Blocks; // Minutes
|
|
}
|
|
|
|
|
|
__inline
|
|
TRACK_MODE_TYPE
|
|
CdFileTrackMode (
|
|
_In_ PFCB Fcb
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine converts FCB XA file type flags to the track mode
|
|
used by the device drivers.
|
|
|
|
Arguments:
|
|
|
|
Fcb - Fcb representing the file to read.
|
|
|
|
Return Value:
|
|
|
|
TrackMode of the file represented by the Fcb.
|
|
|
|
--*/
|
|
{
|
|
NT_ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_MODE2FORM2_FILE |
|
|
FCB_STATE_MODE2_FILE |
|
|
FCB_STATE_DA_FILE ));
|
|
|
|
if (FlagOn( Fcb->FcbState, FCB_STATE_MODE2FORM2_FILE )) {
|
|
|
|
return XAForm2;
|
|
|
|
} else if (FlagOn( Fcb->FcbState, FCB_STATE_DA_FILE )) {
|
|
|
|
return CDDA;
|
|
|
|
}
|
|
|
|
//
|
|
// FCB_STATE_MODE2_FILE
|
|
//
|
|
|
|
return YellowMode2;
|
|
}
|
|
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
NTSTATUS
|
|
CdNonCachedRead (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PFCB Fcb,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ ULONG ByteCount
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine performs the non-cached reads to 'cooked' sectors (2048 bytes
|
|
per sector). This is done by performing the following in a loop.
|
|
|
|
Fill in the IoRuns array for the next block of Io.
|
|
Send the Io to the device.
|
|
Perform any cleanup on the Io runs array.
|
|
|
|
We will not do async Io to any request that generates non-aligned Io.
|
|
Also we will not perform async Io if it will exceed the size of our
|
|
IoRuns array. These should be the unusual cases but we will raise
|
|
or return CANT_WAIT in this routine if we detect this case.
|
|
|
|
Arguments:
|
|
|
|
Fcb - Fcb representing the file to read.
|
|
|
|
StartingOffset - Logical offset in the file to read from.
|
|
|
|
ByteCount - Number of bytes to read.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Status indicating the result of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
IO_RUN IoRuns[MAX_PARALLEL_IOS];
|
|
ULONG RunCount = 0;
|
|
ULONG CleanupRunCount = 0;
|
|
|
|
PVOID UserBuffer;
|
|
ULONG UserBufferOffset = 0;
|
|
LONGLONG CurrentOffset = StartingOffset;
|
|
ULONG RemainingByteCount = ByteCount;
|
|
ULONG ThisByteCount;
|
|
|
|
BOOLEAN Unaligned;
|
|
BOOLEAN FlushIoBuffers = FALSE;
|
|
BOOLEAN FirstPass = TRUE;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// We want to make sure the user's buffer is locked in all cases.
|
|
//
|
|
|
|
if (IrpContext->Irp->MdlAddress == NULL) {
|
|
|
|
CdCreateUserMdl( IrpContext, ByteCount, TRUE, IoWriteAccess );
|
|
}
|
|
|
|
CdMapUserBuffer( IrpContext, &UserBuffer);
|
|
|
|
//
|
|
// Special case the root directory and path table for a music volume.
|
|
//
|
|
|
|
if (FlagOn( Fcb->Vcb->VcbState, VCB_STATE_AUDIO_DISK ) &&
|
|
((SafeNodeType( Fcb ) == CDFS_NTC_FCB_INDEX) ||
|
|
(SafeNodeType( Fcb ) == CDFS_NTC_FCB_PATH_TABLE))) {
|
|
|
|
CdReadAudioSystemFile( IrpContext,
|
|
Fcb,
|
|
StartingOffset,
|
|
ByteCount,
|
|
UserBuffer );
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// If we're going to use the sector cache for this request, then
|
|
// mark the request waitable.
|
|
//
|
|
|
|
if ((SafeNodeType( Fcb) == CDFS_NTC_FCB_INDEX) &&
|
|
(NULL != Fcb->Vcb->SectorCacheBuffer) &&
|
|
(VcbMounted == IrpContext->Vcb->VcbCondition)) {
|
|
|
|
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
|
|
|
|
KeInitializeEvent( &IrpContext->IoContext->SyncEvent,
|
|
NotificationEvent,
|
|
FALSE );
|
|
|
|
SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Use a try-finally to perform the final cleanup.
|
|
//
|
|
|
|
_SEH2_TRY {
|
|
|
|
//
|
|
// Loop while there are more bytes to transfer.
|
|
//
|
|
|
|
do {
|
|
|
|
//
|
|
// Call prepare buffers to set up the next entries
|
|
// in the IoRuns array. Remember if there are any
|
|
// unaligned entries. This routine will raise CANT_WAIT
|
|
// if there are unaligned entries for an async request.
|
|
//
|
|
|
|
RtlZeroMemory( IoRuns, sizeof( IoRuns ));
|
|
|
|
Unaligned = CdPrepareBuffers( IrpContext,
|
|
IrpContext->Irp,
|
|
Fcb,
|
|
UserBuffer,
|
|
UserBufferOffset,
|
|
CurrentOffset,
|
|
RemainingByteCount,
|
|
IoRuns,
|
|
&CleanupRunCount,
|
|
&ThisByteCount );
|
|
|
|
|
|
RunCount = CleanupRunCount;
|
|
|
|
//
|
|
// If this is an async request and there aren't enough entries
|
|
// in the Io array then post the request.
|
|
//
|
|
|
|
if ((ThisByteCount < RemainingByteCount) &&
|
|
!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
|
|
|
|
CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
|
|
}
|
|
|
|
//
|
|
// If the entire Io is contained in a single run then
|
|
// we can pass the Io down to the driver. Send the driver down
|
|
// and wait on the result if this is synchronous.
|
|
//
|
|
|
|
if ((RunCount == 1) && !Unaligned && FirstPass) {
|
|
|
|
CdSingleAsync( IrpContext,&IoRuns[0], Fcb );
|
|
|
|
//
|
|
// No cleanup needed for the IoRuns array here.
|
|
//
|
|
|
|
CleanupRunCount = 0;
|
|
|
|
//
|
|
// Wait if we are synchronous, otherwise return
|
|
//
|
|
|
|
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
|
|
|
|
CdWaitSync( IrpContext );
|
|
|
|
Status = IrpContext->Irp->IoStatus.Status;
|
|
|
|
//
|
|
// Our completion routine will free the Io context but
|
|
// we do want to return STATUS_PENDING.
|
|
//
|
|
|
|
} else {
|
|
|
|
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ALLOC_IO );
|
|
Status = STATUS_PENDING;
|
|
}
|
|
|
|
try_return( NOTHING );
|
|
}
|
|
|
|
//
|
|
// Otherwise we will perform multiple Io to read in the data.
|
|
//
|
|
|
|
CdMultipleAsync( IrpContext, Fcb, RunCount, IoRuns );
|
|
|
|
//
|
|
// If this is a synchronous request then perform any necessary
|
|
// post-processing.
|
|
//
|
|
|
|
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
|
|
|
|
//
|
|
// Wait for the request to complete.
|
|
//
|
|
|
|
CdWaitSync( IrpContext );
|
|
|
|
Status = IrpContext->Irp->IoStatus.Status;
|
|
|
|
//
|
|
// Exit this loop if there is an error.
|
|
//
|
|
|
|
if (!NT_SUCCESS( Status )) {
|
|
|
|
try_return( NOTHING );
|
|
}
|
|
|
|
//
|
|
// Perform post read operations on the IoRuns if
|
|
// necessary.
|
|
//
|
|
|
|
if (Unaligned &&
|
|
CdFinishBuffers( IrpContext, IoRuns, RunCount, FALSE, FALSE )) {
|
|
|
|
FlushIoBuffers = TRUE;
|
|
}
|
|
|
|
CleanupRunCount = 0;
|
|
|
|
//
|
|
// Exit this loop if there are no more bytes to transfer
|
|
// or we have any error.
|
|
//
|
|
|
|
RemainingByteCount -= ThisByteCount;
|
|
CurrentOffset += ThisByteCount;
|
|
UserBuffer = Add2Ptr( UserBuffer, ThisByteCount, PVOID );
|
|
UserBufferOffset += ThisByteCount;
|
|
|
|
//
|
|
// Otherwise this is an asynchronous request. Always return
|
|
// STATUS_PENDING.
|
|
//
|
|
|
|
} else {
|
|
|
|
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ALLOC_IO );
|
|
CleanupRunCount = 0;
|
|
try_return( Status = STATUS_PENDING );
|
|
break;
|
|
}
|
|
|
|
FirstPass = FALSE;
|
|
} while (RemainingByteCount != 0);
|
|
|
|
//
|
|
// Flush the hardware cache if we performed any copy operations.
|
|
//
|
|
|
|
if (FlushIoBuffers) {
|
|
|
|
KeFlushIoBuffers( IrpContext->Irp->MdlAddress, TRUE, FALSE );
|
|
}
|
|
|
|
try_exit: NOTHING;
|
|
} _SEH2_FINALLY {
|
|
|
|
//
|
|
// Perform final cleanup on the IoRuns if necessary.
|
|
//
|
|
|
|
if (CleanupRunCount != 0) {
|
|
|
|
CdFinishBuffers( IrpContext, IoRuns, CleanupRunCount, TRUE, FALSE );
|
|
}
|
|
} _SEH2_END;
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
NTSTATUS
|
|
CdNonCachedXARead (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PFCB Fcb,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ ULONG ByteCount
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine performs the non-cached reads for 'raw' sectors (2352 bytes
|
|
per sector). We also prepend a hard-coded RIFF header of 44 bytes to the file.
|
|
All of this is already reflected in the file size.
|
|
|
|
We start by checking whether to prepend any portion of the RIFF header. Then we check
|
|
if the last raw sector read was from the beginning portion of this file, deallocating
|
|
that buffer if necessary. Finally we do the following in a loop.
|
|
|
|
Fill the IoRuns array for the next block of Io.
|
|
Send the Io to the device driver.
|
|
Perform any cleanup necessary on the IoRuns array.
|
|
|
|
We will not do any async request in this path. The request would have been
|
|
posted to a worker thread before getting to this point.
|
|
|
|
Arguments:
|
|
|
|
Fcb - Fcb representing the file to read.
|
|
|
|
StartingOffset - Logical offset in the file to read from.
|
|
|
|
ByteCount - Number of bytes to read.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Status indicating the result of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
RIFF_HEADER LocalRiffHeader;
|
|
PRIFF_HEADER RiffHeader;
|
|
|
|
RAW_READ_INFO RawReads[MAX_PARALLEL_IOS];
|
|
IO_RUN IoRuns[MAX_PARALLEL_IOS];
|
|
ULONG RunCount = 0;
|
|
ULONG CleanupRunCount = 0;
|
|
|
|
PVOID UserBuffer;
|
|
ULONG UserBufferOffset = 0;
|
|
LONGLONG CurrentOffset = StartingOffset;
|
|
ULONG RemainingByteCount = ByteCount;
|
|
ULONG ThisByteCount = 0;
|
|
ULONG Address = 0;
|
|
|
|
BOOLEAN TryingYellowbookMode2 = FALSE;
|
|
|
|
TRACK_MODE_TYPE TrackMode;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// We want to make sure the user's buffer is locked in all cases.
|
|
//
|
|
|
|
if (IrpContext->Irp->MdlAddress == NULL) {
|
|
|
|
CdCreateUserMdl( IrpContext, ByteCount, TRUE, IoWriteAccess );
|
|
}
|
|
|
|
//
|
|
// The byte count was rounded up to a logical sector boundary. It has
|
|
// nothing to do with the raw sectors on disk. Limit the remaining
|
|
// byte count to file size.
|
|
//
|
|
|
|
if (CurrentOffset + RemainingByteCount > Fcb->FileSize.QuadPart) {
|
|
|
|
RemainingByteCount = (ULONG) (Fcb->FileSize.QuadPart - CurrentOffset);
|
|
}
|
|
|
|
CdMapUserBuffer( IrpContext, &UserBuffer);
|
|
|
|
//
|
|
// Use a try-finally to perform the final cleanup.
|
|
//
|
|
|
|
_SEH2_TRY {
|
|
|
|
//
|
|
// If the initial offset lies within the RIFF header then copy the
|
|
// necessary bytes to the user's buffer.
|
|
//
|
|
|
|
if (CurrentOffset < sizeof( RIFF_HEADER )) {
|
|
|
|
//
|
|
// Copy the appropriate RIFF header.
|
|
//
|
|
|
|
if (FlagOn( Fcb->FcbState, FCB_STATE_DA_FILE )) {
|
|
|
|
//
|
|
// Create the pseudo entries for a music disk.
|
|
//
|
|
|
|
if (FlagOn( Fcb->Vcb->VcbState, VCB_STATE_AUDIO_DISK )) {
|
|
|
|
PAUDIO_PLAY_HEADER AudioPlayHeader;
|
|
PTRACK_DATA TrackData;
|
|
|
|
AudioPlayHeader = (PAUDIO_PLAY_HEADER) &LocalRiffHeader;
|
|
TrackData = &Fcb->Vcb->CdromToc->TrackData[Fcb->XAFileNumber];
|
|
|
|
//
|
|
// Copy the data header into our local buffer.
|
|
//
|
|
|
|
RtlCopyMemory( AudioPlayHeader,
|
|
CdAudioPlayHeader,
|
|
sizeof( AUDIO_PLAY_HEADER ));
|
|
|
|
//
|
|
// Copy the serial number into the Id field. Also
|
|
// the track number in the TOC.
|
|
//
|
|
|
|
AudioPlayHeader->DiskID = Fcb->Vcb->Vpb->SerialNumber;
|
|
AudioPlayHeader->TrackNumber = TrackData->TrackNumber;
|
|
|
|
//
|
|
// One frame == One sector.
|
|
// One second == 75 frames (winds up being a 44.1khz sample)
|
|
//
|
|
// Note: LBN 0 == 0:2:0 (MSF)
|
|
//
|
|
|
|
//
|
|
// Fill in the address (both MSF and Lbn format) and length fields.
|
|
//
|
|
|
|
SwapCopyUchar4( &Address, TrackData->Address);
|
|
CdLbnToMmSsFf( Address, AudioPlayHeader->TrackAddress);
|
|
|
|
SwapCopyUchar4( &AudioPlayHeader->StartingSector, TrackData->Address);
|
|
|
|
//
|
|
// Go to the next track and find the starting point.
|
|
//
|
|
|
|
TrackData = &Fcb->Vcb->CdromToc->TrackData[Fcb->XAFileNumber + 1];
|
|
|
|
SwapCopyUchar4( &AudioPlayHeader->SectorCount, TrackData->Address);
|
|
|
|
//
|
|
// Now compute the difference. If there is an error then use
|
|
// a length of zero.
|
|
//
|
|
|
|
if (AudioPlayHeader->SectorCount < AudioPlayHeader->StartingSector) {
|
|
|
|
AudioPlayHeader->SectorCount = 0;
|
|
|
|
} else {
|
|
|
|
AudioPlayHeader->SectorCount -= AudioPlayHeader->StartingSector;
|
|
}
|
|
|
|
//
|
|
// Use the sector count to determine the MSF length. Bias by 150 to make
|
|
// it an "lbn" since the conversion routine corrects for Lbn 0 == 0:2:0;
|
|
//
|
|
|
|
Address = AudioPlayHeader->SectorCount - 150;
|
|
CdLbnToMmSsFf( Address, AudioPlayHeader->TrackLength);
|
|
|
|
ThisByteCount = sizeof( RIFF_HEADER ) - (ULONG) CurrentOffset;
|
|
|
|
RtlCopyMemory( UserBuffer,
|
|
Add2Ptr( AudioPlayHeader,
|
|
sizeof( RIFF_HEADER ) - ThisByteCount,
|
|
PCHAR ),
|
|
ThisByteCount );
|
|
|
|
//
|
|
// CD-XA CDDA
|
|
//
|
|
|
|
} else {
|
|
|
|
//
|
|
// The WAVE header format is actually much closer to an audio play
|
|
// header in format but we only need to modify the filesize fields.
|
|
//
|
|
|
|
RiffHeader = &LocalRiffHeader;
|
|
|
|
//
|
|
// Copy the data header into our local buffer and add the file size to it.
|
|
//
|
|
|
|
RtlCopyMemory( RiffHeader,
|
|
CdXAAudioPhileHeader,
|
|
sizeof( RIFF_HEADER ));
|
|
|
|
RiffHeader->ChunkSize += Fcb->FileSize.LowPart;
|
|
RiffHeader->RawSectors += Fcb->FileSize.LowPart;
|
|
|
|
ThisByteCount = sizeof( RIFF_HEADER ) - (ULONG) CurrentOffset;
|
|
RtlCopyMemory( UserBuffer,
|
|
Add2Ptr( RiffHeader,
|
|
sizeof( RIFF_HEADER ) - ThisByteCount,
|
|
PCHAR ),
|
|
ThisByteCount );
|
|
}
|
|
|
|
//
|
|
// CD-XA non-audio
|
|
//
|
|
|
|
} else {
|
|
|
|
NT_ASSERT( FlagOn( Fcb->FcbState, FCB_STATE_MODE2_FILE | FCB_STATE_MODE2FORM2_FILE ));
|
|
|
|
RiffHeader = &LocalRiffHeader;
|
|
|
|
//
|
|
// Copy the data header into our local buffer and add the file size to it.
|
|
//
|
|
|
|
RtlCopyMemory( RiffHeader,
|
|
CdXAFileHeader,
|
|
sizeof( RIFF_HEADER ));
|
|
|
|
RiffHeader->ChunkSize += Fcb->FileSize.LowPart;
|
|
RiffHeader->RawSectors += Fcb->FileSize.LowPart;
|
|
|
|
RiffHeader->Attributes = (USHORT) Fcb->XAAttributes;
|
|
RiffHeader->FileNumber = (UCHAR) Fcb->XAFileNumber;
|
|
|
|
ThisByteCount = sizeof( RIFF_HEADER ) - (ULONG) CurrentOffset;
|
|
RtlCopyMemory( UserBuffer,
|
|
Add2Ptr( RiffHeader,
|
|
sizeof( RIFF_HEADER ) - ThisByteCount,
|
|
PCHAR ),
|
|
ThisByteCount );
|
|
}
|
|
|
|
//
|
|
// Adjust the starting offset and byte count to reflect that
|
|
// we copied over the RIFF bytes.
|
|
//
|
|
|
|
UserBuffer = Add2Ptr( UserBuffer, ThisByteCount, PVOID );
|
|
UserBufferOffset += ThisByteCount;
|
|
CurrentOffset += ThisByteCount;
|
|
RemainingByteCount -= ThisByteCount;
|
|
}
|
|
|
|
//
|
|
// Set up the appropriate trackmode
|
|
//
|
|
|
|
TrackMode = CdFileTrackMode(Fcb);
|
|
|
|
//
|
|
// Loop while there are more bytes to transfer.
|
|
//
|
|
|
|
while (RemainingByteCount != 0) {
|
|
|
|
//
|
|
// Call prepare buffers to set up the next entries
|
|
// in the IoRuns array. Remember if there are any
|
|
// unaligned entries. If we're just retrying the previous
|
|
// runs with a different track mode, then don't do anything here.
|
|
//
|
|
|
|
if (!TryingYellowbookMode2) {
|
|
|
|
RtlZeroMemory( IoRuns, sizeof( IoRuns ));
|
|
RtlZeroMemory( RawReads, sizeof( RawReads ));
|
|
|
|
CdPrepareXABuffers( IrpContext,
|
|
IrpContext->Irp,
|
|
Fcb,
|
|
UserBuffer,
|
|
UserBufferOffset,
|
|
CurrentOffset,
|
|
RemainingByteCount,
|
|
IoRuns,
|
|
&CleanupRunCount,
|
|
&ThisByteCount );
|
|
}
|
|
|
|
//
|
|
// Perform multiple Io to read in the data. Note that
|
|
// there may be no Io to do if we were able to use an
|
|
// existing buffer from the Vcb.
|
|
//
|
|
|
|
if (CleanupRunCount != 0) {
|
|
|
|
RunCount = CleanupRunCount;
|
|
|
|
CdMultipleXAAsync( IrpContext,
|
|
RunCount,
|
|
IoRuns,
|
|
RawReads,
|
|
TrackMode );
|
|
//
|
|
// Wait for the request to complete.
|
|
//
|
|
|
|
CdWaitSync( IrpContext );
|
|
|
|
Status = IrpContext->Irp->IoStatus.Status;
|
|
|
|
//
|
|
// Exit this loop if there is an error.
|
|
//
|
|
|
|
if (!NT_SUCCESS( Status )) {
|
|
|
|
if (!TryingYellowbookMode2 &&
|
|
FlagOn( Fcb->FcbState, FCB_STATE_MODE2FORM2_FILE )) {
|
|
|
|
//
|
|
// There are wacky cases where someone has mastered as CD-XA
|
|
// but the sectors they claim are Mode2Form2 are really, according
|
|
// to ATAPI devices, Yellowbook Mode2. We will try once more
|
|
// with these. Kodak PHOTO-CD has been observed to do this.
|
|
//
|
|
|
|
TryingYellowbookMode2 = TRUE;
|
|
TrackMode = YellowMode2;
|
|
|
|
//
|
|
// Clear our 'cumulative' error status value
|
|
//
|
|
|
|
IrpContext->IoContext->Status = STATUS_SUCCESS;
|
|
|
|
continue;
|
|
}
|
|
|
|
try_return( NOTHING );
|
|
}
|
|
|
|
CleanupRunCount = 0;
|
|
|
|
if (TryingYellowbookMode2) {
|
|
|
|
//
|
|
// We succesfully got data when we tried switching the trackmode,
|
|
// so change the state of the FCB to remember that.
|
|
//
|
|
|
|
SetFlag( Fcb->FcbState, FCB_STATE_MODE2_FILE );
|
|
ClearFlag( Fcb->FcbState, FCB_STATE_MODE2FORM2_FILE );
|
|
|
|
TryingYellowbookMode2 = FALSE;
|
|
}
|
|
|
|
//
|
|
// Perform post read operations on the IoRuns if
|
|
// necessary.
|
|
//
|
|
|
|
CdFinishBuffers( IrpContext, IoRuns, RunCount, FALSE, TRUE );
|
|
}
|
|
|
|
//
|
|
// Adjust our loop variants.
|
|
//
|
|
|
|
RemainingByteCount -= ThisByteCount;
|
|
CurrentOffset += ThisByteCount;
|
|
UserBuffer = Add2Ptr( UserBuffer, ThisByteCount, PVOID );
|
|
UserBufferOffset += ThisByteCount;
|
|
}
|
|
|
|
//
|
|
// Always flush the hardware cache.
|
|
//
|
|
|
|
KeFlushIoBuffers( IrpContext->Irp->MdlAddress, TRUE, FALSE );
|
|
|
|
try_exit: NOTHING;
|
|
} _SEH2_FINALLY {
|
|
|
|
//
|
|
// Perform final cleanup on the IoRuns if necessary.
|
|
//
|
|
|
|
if (CleanupRunCount != 0) {
|
|
|
|
CdFinishBuffers( IrpContext, IoRuns, CleanupRunCount, TRUE, FALSE );
|
|
}
|
|
} _SEH2_END;
|
|
|
|
return Status;
|
|
}
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
NTSTATUS
|
|
CdVolumeDasdWrite (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PFCB Fcb,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ ULONG ByteCount
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine performs the non-cached writes to 'cooked' sectors (2048 bytes
|
|
per sector). This is done by filling the IoRun for the desired request
|
|
and send it down to the device.
|
|
|
|
Arguments:
|
|
|
|
Fcb - Fcb representing the file to read.
|
|
|
|
StartingOffset - Logical offset in the file to read from.
|
|
|
|
ByteCount - Number of bytes to read.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Status indicating the result of the operation.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
IO_RUN IoRun;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// We want to make sure the user's buffer is locked in all cases.
|
|
//
|
|
|
|
CdLockUserBuffer( IrpContext, ByteCount, IoReadAccess );
|
|
|
|
//
|
|
// The entire Io can be contained in a single run, just pass
|
|
// the Io down to the driver. Send the driver down
|
|
// and wait on the result if this is synchronous.
|
|
//
|
|
|
|
RtlZeroMemory( &IoRun, sizeof( IoRun ) );
|
|
|
|
IoRun.DiskOffset = StartingOffset;
|
|
IoRun.DiskByteCount = ByteCount;
|
|
|
|
CdSingleAsync( IrpContext, &IoRun, Fcb );
|
|
|
|
//
|
|
// Wait if we are synchronous, otherwise return
|
|
//
|
|
|
|
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
|
|
|
|
CdWaitSync( IrpContext );
|
|
|
|
Status = IrpContext->Irp->IoStatus.Status;
|
|
|
|
//
|
|
// Our completion routine will free the Io context but
|
|
// we do want to return STATUS_PENDING.
|
|
//
|
|
|
|
} else {
|
|
|
|
ClearFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_ALLOC_IO );
|
|
Status = STATUS_PENDING;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
BOOLEAN
|
|
CdReadSectors (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ ULONG ByteCount,
|
|
_In_ BOOLEAN ReturnError,
|
|
_Out_writes_bytes_(ByteCount) PVOID Buffer,
|
|
_In_ PDEVICE_OBJECT TargetDeviceObject
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called to transfer sectors from the disk to a
|
|
specified buffer. It is used for mount and volume verify operations.
|
|
|
|
This routine is synchronous, it will not return until the operation
|
|
is complete or until the operation fails.
|
|
|
|
The routine allocates an IRP and then passes this IRP to a lower
|
|
level driver. Errors may occur in the allocation of this IRP or
|
|
in the operation of the lower driver.
|
|
|
|
Arguments:
|
|
|
|
StartingOffset - Logical offset on the disk to start the read. This
|
|
must be on a sector boundary, no check is made here.
|
|
|
|
ByteCount - Number of bytes to read. This is an integral number of
|
|
2K sectors, no check is made here to confirm this.
|
|
|
|
ReturnError - Indicates whether we should return TRUE or FALSE
|
|
to indicate an error or raise an error condition. This only applies
|
|
to the result of the IO. Any other error may cause a raise.
|
|
|
|
Buffer - Buffer to transfer the disk data into.
|
|
|
|
TargetDeviceObject - The device object for the volume to be read.
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - Depending on 'RaiseOnError' flag above. TRUE if operation
|
|
succeeded, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
KEVENT Event;
|
|
PIRP Irp;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Initialize the event.
|
|
//
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
//
|
|
// Attempt to allocate the IRP. If unsuccessful, raise
|
|
// STATUS_INSUFFICIENT_RESOURCES.
|
|
//
|
|
|
|
Irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ,
|
|
TargetDeviceObject,
|
|
Buffer,
|
|
ByteCount,
|
|
(PLARGE_INTEGER) &StartingOffset,
|
|
&Event,
|
|
&IrpContext->Irp->IoStatus );
|
|
|
|
if (Irp == NULL) {
|
|
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
|
|
}
|
|
|
|
//
|
|
// Ignore the change line (verify) for mount and verify requests
|
|
//
|
|
|
|
SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
|
|
|
|
//
|
|
// Send the request down to the driver. If an error occurs return
|
|
// it to the caller.
|
|
//
|
|
|
|
Status = IoCallDriver( TargetDeviceObject, Irp );
|
|
|
|
//
|
|
// If the status was STATUS_PENDING then wait on the event.
|
|
//
|
|
|
|
if (Status == STATUS_PENDING) {
|
|
|
|
Status = KeWaitForSingleObject( &Event,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
//
|
|
// On a successful wait pull the status out of the IoStatus block.
|
|
//
|
|
|
|
if (NT_SUCCESS( Status )) {
|
|
|
|
Status = IrpContext->Irp->IoStatus.Status;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check whether we should raise in the error case.
|
|
//
|
|
|
|
if (!NT_SUCCESS( Status )) {
|
|
|
|
if (!ReturnError) {
|
|
|
|
CdNormalizeAndRaiseStatus( IrpContext, Status );
|
|
}
|
|
|
|
//
|
|
// We don't raise, but return FALSE to indicate an error.
|
|
//
|
|
|
|
return FALSE;
|
|
|
|
//
|
|
// The operation completed successfully.
|
|
//
|
|
|
|
} else {
|
|
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
CdCreateUserMdl (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ ULONG BufferLength,
|
|
_In_ BOOLEAN RaiseOnError,
|
|
_In_ LOCK_OPERATION Operation
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine locks the specified buffer for read access (we only write into
|
|
the buffer). The file system requires this routine since it does not
|
|
ask the I/O system to lock its buffers for direct I/O. This routine
|
|
may only be called from the Fsd while still in the user context.
|
|
|
|
This routine is only called if there is not already an Mdl.
|
|
|
|
Arguments:
|
|
|
|
BufferLength - Length of user buffer.
|
|
|
|
RaiseOnError - Indicates if our caller wants this routine to raise on
|
|
an error condition.
|
|
|
|
Operation - IoWriteAccess or IoReadAccess
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Status from this routine. Error status only returned if
|
|
RaiseOnError is FALSE.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
PMDL Mdl;
|
|
|
|
PAGED_CODE();
|
|
|
|
UNREFERENCED_PARAMETER( Operation );
|
|
UNREFERENCED_PARAMETER( IrpContext );
|
|
|
|
ASSERT_IRP_CONTEXT( IrpContext );
|
|
ASSERT_IRP( IrpContext->Irp );
|
|
NT_ASSERT( IrpContext->Irp->MdlAddress == NULL );
|
|
|
|
//
|
|
// Allocate the Mdl, and Raise if we fail.
|
|
//
|
|
|
|
Mdl = IoAllocateMdl( IrpContext->Irp->UserBuffer,
|
|
BufferLength,
|
|
FALSE,
|
|
FALSE,
|
|
IrpContext->Irp );
|
|
|
|
if (Mdl != NULL) {
|
|
|
|
//
|
|
// Now probe the buffer described by the Irp. If we get an exception,
|
|
// deallocate the Mdl and return the appropriate "expected" status.
|
|
//
|
|
|
|
_SEH2_TRY {
|
|
|
|
MmProbeAndLockPages( Mdl, IrpContext->Irp->RequestorMode, IoWriteAccess );
|
|
|
|
Status = STATUS_SUCCESS;
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(suppress: 6320)
|
|
#endif
|
|
} _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
Status = _SEH2_GetExceptionCode();
|
|
|
|
IoFreeMdl( Mdl );
|
|
IrpContext->Irp->MdlAddress = NULL;
|
|
|
|
if (!FsRtlIsNtstatusExpected( Status )) {
|
|
|
|
Status = STATUS_INVALID_USER_BUFFER;
|
|
}
|
|
} _SEH2_END;
|
|
}
|
|
|
|
//
|
|
// Check if we are to raise or return
|
|
//
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
|
|
if (RaiseOnError) {
|
|
|
|
CdRaiseStatus( IrpContext, Status );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Return the status code.
|
|
//
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
CdPerformDevIoCtrlEx (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ ULONG IoControlCode,
|
|
_In_ PDEVICE_OBJECT Device,
|
|
_In_reads_bytes_opt_(InputBufferLength) PVOID InputBuffer,
|
|
_In_ ULONG InputBufferLength,
|
|
_Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer,
|
|
_In_ ULONG OutputBufferLength,
|
|
_In_ BOOLEAN InternalDeviceIoControl,
|
|
_In_ BOOLEAN OverrideVerify,
|
|
_Out_opt_ PIO_STATUS_BLOCK Iosb
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called to perform DevIoCtrl functions internally within
|
|
the filesystem. We take the status from the driver and return it to our
|
|
caller.
|
|
|
|
Arguments:
|
|
|
|
IoControlCode - Code to send to driver.
|
|
|
|
Device - This is the device to send the request to.
|
|
|
|
OutPutBuffer - Pointer to output buffer.
|
|
|
|
OutputBufferLength - Length of output buffer above.
|
|
|
|
InternalDeviceIoControl - Indicates if this is an internal or external
|
|
Io control code.
|
|
|
|
OverrideVerify - Indicates if we should tell the driver not to return
|
|
STATUS_VERIFY_REQUIRED for mount and verify.
|
|
|
|
Iosb - If specified, we return the results of the operation here.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - Status returned by next lower driver.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Status;
|
|
PIRP Irp;
|
|
KEVENT Event;
|
|
IO_STATUS_BLOCK LocalIosb;
|
|
PIO_STATUS_BLOCK IosbToUse = &LocalIosb;
|
|
|
|
PAGED_CODE();
|
|
|
|
UNREFERENCED_PARAMETER( IrpContext );
|
|
|
|
//
|
|
// Check if the user gave us an Iosb.
|
|
//
|
|
|
|
if (ARGUMENT_PRESENT( Iosb )) {
|
|
|
|
IosbToUse = Iosb;
|
|
}
|
|
|
|
IosbToUse->Status = 0;
|
|
IosbToUse->Information = 0;
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
Irp = IoBuildDeviceIoControlRequest( IoControlCode,
|
|
Device,
|
|
InputBuffer,
|
|
InputBufferLength,
|
|
OutputBuffer,
|
|
OutputBufferLength,
|
|
InternalDeviceIoControl,
|
|
&Event,
|
|
IosbToUse );
|
|
|
|
if (Irp == NULL) {
|
|
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
if (OverrideVerify) {
|
|
|
|
SetFlag( IoGetNextIrpStackLocation( Irp )->Flags, SL_OVERRIDE_VERIFY_VOLUME );
|
|
}
|
|
|
|
Status = IoCallDriver( Device, Irp );
|
|
|
|
//
|
|
// We check for device not ready by first checking Status
|
|
// and then if status pending was returned, the Iosb status
|
|
// value.
|
|
//
|
|
|
|
if (Status == STATUS_PENDING) {
|
|
|
|
(VOID) KeWaitForSingleObject( &Event,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
(PLARGE_INTEGER)NULL );
|
|
|
|
Status = IosbToUse->Status;
|
|
}
|
|
|
|
NT_ASSERT( !(OverrideVerify && (STATUS_VERIFY_REQUIRED == Status)));
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
FASTCALL
|
|
CdPerformDevIoCtrl (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ ULONG IoControlCode,
|
|
_In_ PDEVICE_OBJECT Device,
|
|
_Out_writes_bytes_opt_(OutputBufferLength) PVOID OutputBuffer,
|
|
_In_ ULONG OutputBufferLength,
|
|
_In_ BOOLEAN InternalDeviceIoControl,
|
|
_In_ BOOLEAN OverrideVerify,
|
|
_Out_opt_ PIO_STATUS_BLOCK Iosb
|
|
)
|
|
{
|
|
PAGED_CODE();
|
|
|
|
return CdPerformDevIoCtrlEx( IrpContext,
|
|
IoControlCode,
|
|
Device,
|
|
NULL,
|
|
0,
|
|
OutputBuffer,
|
|
OutputBufferLength,
|
|
InternalDeviceIoControl,
|
|
OverrideVerify,
|
|
Iosb);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
BOOLEAN
|
|
CdPrepareBuffers (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PIRP Irp,
|
|
_In_ PFCB Fcb,
|
|
_In_reads_bytes_(ByteCount) PVOID UserBuffer,
|
|
_In_ ULONG UserBufferOffset,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ ULONG ByteCount,
|
|
_Out_ PIO_RUN IoRuns,
|
|
_Out_ PULONG RunCount,
|
|
_Out_ PULONG ThisByteCount
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the worker routine which looks up each run of an IO
|
|
request and stores an entry for it in the IoRuns array. If the run
|
|
begins on an unaligned disk boundary then we will allocate a buffer
|
|
and Mdl for the unaligned portion and put it in the IoRuns entry.
|
|
|
|
This routine will raise CANT_WAIT if an unaligned transfer is encountered
|
|
and this request can't wait.
|
|
|
|
Arguments:
|
|
|
|
Irp - Originating Irp for this request.
|
|
|
|
Fcb - This is the Fcb for this data stream. It may be a file, directory,
|
|
path table or the volume file.
|
|
|
|
UserBuffer - Current position in the user's buffer.
|
|
|
|
UserBufferOffset - Offset from the start of the original user buffer.
|
|
|
|
StartingOffset - Offset in the stream to begin the read.
|
|
|
|
ByteCount - Number of bytes to read. We will fill the IoRuns array up
|
|
to this point. We will stop early if we exceed the maximum number
|
|
of parallel Ios we support.
|
|
|
|
IoRuns - Pointer to the IoRuns array. The entire array is zeroes when
|
|
this routine is called.
|
|
|
|
RunCount - Number of entries in the IoRuns array filled here.
|
|
|
|
ThisByteCount - Number of bytes described by the IoRun entries. Will
|
|
not exceed the ByteCount passed in.
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - TRUE if one of the entries in an unaligned buffer (provided
|
|
this is synchronous). FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOLEAN FoundUnaligned = FALSE;
|
|
PIO_RUN ThisIoRun = IoRuns;
|
|
|
|
//
|
|
// Following indicate where we are in the current transfer. Current
|
|
// position in the file and number of bytes yet to transfer from
|
|
// this position.
|
|
//
|
|
|
|
ULONG RemainingByteCount = ByteCount;
|
|
LONGLONG CurrentFileOffset = StartingOffset;
|
|
|
|
//
|
|
// Following indicate the state of the user's buffer. We have
|
|
// the destination of the next transfer and its offset in the
|
|
// buffer. We also have the next available position in the buffer
|
|
// available for a scratch buffer. We will align this up to a sector
|
|
// boundary.
|
|
//
|
|
|
|
PVOID CurrentUserBuffer = UserBuffer;
|
|
ULONG CurrentUserBufferOffset = UserBufferOffset;
|
|
|
|
//
|
|
// The following is the next contiguous bytes on the disk to
|
|
// transfer. Read from the allocation package.
|
|
//
|
|
|
|
LONGLONG DiskOffset = 0;
|
|
ULONG CurrentByteCount = RemainingByteCount;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Initialize the RunCount and ByteCount.
|
|
//
|
|
|
|
*RunCount = 0;
|
|
*ThisByteCount = 0;
|
|
|
|
//
|
|
// Loop while there are more bytes to process or there are
|
|
// available entries in the IoRun array.
|
|
//
|
|
|
|
while (TRUE) {
|
|
|
|
*RunCount += 1;
|
|
|
|
//
|
|
// Initialize the current position in the IoRuns array.
|
|
// Find the user's buffer for this portion of the transfer.
|
|
//
|
|
|
|
ThisIoRun->UserBuffer = CurrentUserBuffer;
|
|
|
|
//
|
|
// Find the allocation information for the current offset in the
|
|
// stream.
|
|
//
|
|
|
|
CdLookupAllocation( IrpContext,
|
|
Fcb,
|
|
CurrentFileOffset,
|
|
&DiskOffset,
|
|
&CurrentByteCount );
|
|
|
|
//
|
|
// Limit ourselves to the data requested.
|
|
//
|
|
|
|
if (CurrentByteCount > RemainingByteCount) {
|
|
|
|
CurrentByteCount = RemainingByteCount;
|
|
}
|
|
|
|
//
|
|
// Handle the case where this is an unaligned transfer. The
|
|
// following must all be true for this to be an aligned transfer.
|
|
//
|
|
// Disk offset on a 2048 byte boundary (Start of transfer)
|
|
//
|
|
// Byte count is a multiple of 2048 (Length of transfer)
|
|
//
|
|
// If the ByteCount is at least one sector then do the
|
|
// unaligned transfer only for the tail. We can use the
|
|
// user's buffer for the aligned portion.
|
|
//
|
|
|
|
if (FlagOn( (ULONG) DiskOffset, SECTOR_MASK ) ||
|
|
(FlagOn( (ULONG) CurrentByteCount, SECTOR_MASK ) &&
|
|
(CurrentByteCount < SECTOR_SIZE))) {
|
|
|
|
NT_ASSERT( SafeNodeType(Fcb) != CDFS_NTC_FCB_INDEX);
|
|
|
|
//
|
|
// If we can't wait then raise.
|
|
//
|
|
|
|
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
|
|
|
|
CdRaiseStatus( IrpContext, STATUS_CANT_WAIT );
|
|
}
|
|
|
|
//
|
|
// Remember the offset and the number of bytes out of
|
|
// the transfer buffer to copy into the user's buffer.
|
|
// We will truncate the current read to end on a sector
|
|
// boundary.
|
|
//
|
|
|
|
ThisIoRun->TransferBufferOffset = SectorOffset( DiskOffset );
|
|
|
|
//
|
|
// Make sure this transfer ends on a sector boundary.
|
|
//
|
|
|
|
ThisIoRun->DiskOffset = LlSectorTruncate( DiskOffset );
|
|
|
|
//
|
|
// We need to allocate an auxilary buffer for the next sector.
|
|
// Read up to a page containing the partial data.
|
|
//
|
|
|
|
ThisIoRun->DiskByteCount = SectorAlign( ThisIoRun->TransferBufferOffset + CurrentByteCount );
|
|
|
|
if (ThisIoRun->DiskByteCount > PAGE_SIZE) {
|
|
|
|
ThisIoRun->DiskByteCount = PAGE_SIZE;
|
|
}
|
|
|
|
if (ThisIoRun->TransferBufferOffset + CurrentByteCount > ThisIoRun->DiskByteCount) {
|
|
|
|
CurrentByteCount = ThisIoRun->DiskByteCount - ThisIoRun->TransferBufferOffset;
|
|
}
|
|
|
|
ThisIoRun->TransferByteCount = CurrentByteCount;
|
|
|
|
//
|
|
// Allocate a buffer for the non-aligned transfer.
|
|
//
|
|
|
|
ThisIoRun->TransferBuffer = FsRtlAllocatePoolWithTag( CdNonPagedPool, PAGE_SIZE, TAG_IO_BUFFER );
|
|
|
|
//
|
|
// Allocate and build the Mdl to describe this buffer.
|
|
//
|
|
|
|
ThisIoRun->TransferMdl = IoAllocateMdl( ThisIoRun->TransferBuffer,
|
|
PAGE_SIZE,
|
|
FALSE,
|
|
FALSE,
|
|
NULL );
|
|
|
|
ThisIoRun->TransferVirtualAddress = ThisIoRun->TransferBuffer;
|
|
|
|
if (ThisIoRun->TransferMdl == NULL) {
|
|
|
|
IrpContext->Irp->IoStatus.Information = 0;
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
|
|
}
|
|
|
|
MmBuildMdlForNonPagedPool( ThisIoRun->TransferMdl );
|
|
|
|
//
|
|
// Remember we found an unaligned transfer.
|
|
//
|
|
|
|
FoundUnaligned = TRUE;
|
|
|
|
//
|
|
// Otherwise we use the buffer and Mdl from the original request.
|
|
//
|
|
|
|
} else {
|
|
|
|
//
|
|
// Truncate the read length to a sector-aligned value. We know
|
|
// the length must be at least one sector or we wouldn't be
|
|
// here now.
|
|
//
|
|
|
|
CurrentByteCount = SectorTruncate( CurrentByteCount );
|
|
|
|
//
|
|
// Read these sectors from the disk.
|
|
//
|
|
|
|
ThisIoRun->DiskOffset = DiskOffset;
|
|
ThisIoRun->DiskByteCount = CurrentByteCount;
|
|
|
|
//
|
|
// Use the user's buffer and Mdl as our transfer buffer
|
|
// and Mdl.
|
|
//
|
|
|
|
ThisIoRun->TransferBuffer = CurrentUserBuffer;
|
|
ThisIoRun->TransferMdl = Irp->MdlAddress;
|
|
ThisIoRun->TransferVirtualAddress = Add2Ptr( Irp->UserBuffer,
|
|
CurrentUserBufferOffset,
|
|
PVOID );
|
|
}
|
|
|
|
//
|
|
// Update our position in the transfer and the RunCount and
|
|
// ByteCount for the user.
|
|
//
|
|
|
|
RemainingByteCount -= CurrentByteCount;
|
|
|
|
//
|
|
// Break out if no more positions in the IoRuns array or
|
|
// we have all of the bytes accounted for.
|
|
//
|
|
|
|
*ThisByteCount += CurrentByteCount;
|
|
|
|
if ((RemainingByteCount == 0) || (*RunCount == MAX_PARALLEL_IOS)) {
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Update our pointers for the user's buffer.
|
|
//
|
|
|
|
ThisIoRun += 1;
|
|
CurrentUserBuffer = Add2Ptr( CurrentUserBuffer, CurrentByteCount, PVOID );
|
|
CurrentUserBufferOffset += CurrentByteCount;
|
|
CurrentFileOffset += CurrentByteCount;
|
|
}
|
|
|
|
return FoundUnaligned;
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
VOID
|
|
CdPrepareXABuffers (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PIRP Irp,
|
|
_In_ PFCB Fcb,
|
|
_In_reads_bytes_(ByteCount) PVOID UserBuffer,
|
|
_In_ ULONG UserBufferOffset,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ ULONG ByteCount,
|
|
_Out_ PIO_RUN IoRuns,
|
|
_Out_ PULONG RunCount,
|
|
_Out_ PULONG ThisByteCount
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is the worker routine which looks up the individual runs
|
|
of an IO request and stores an entry for it in the IoRuns array. The
|
|
worker routine is for XA files where we need to convert the raw offset
|
|
in the file to logical cooked sectors. We store one raw sector in
|
|
the Vcb. If the current read is to that sector then we can simply copy
|
|
whatever bytes are needed from that sector.
|
|
|
|
Arguments:
|
|
|
|
Irp - Originating Irp for this request.
|
|
|
|
Fcb - This is the Fcb for this data stream. It must be a data stream.
|
|
|
|
UserBuffer - Current position in the user's buffer.
|
|
|
|
UserBufferOffset - Offset of this buffer from the beginning of the user's
|
|
buffer for the original request.
|
|
|
|
StartingOffset - Offset in the stream to begin the read.
|
|
|
|
ByteCount - Number of bytes to read. We will fill the IoRuns array up
|
|
to this point. We will stop early if we exceed the maximum number
|
|
of parallel Ios we support.
|
|
|
|
IoRuns - Pointer to the IoRuns array. The entire array is zeroes when
|
|
this routine is called.
|
|
|
|
RunCount - Number of entries in the IoRuns array filled here.
|
|
|
|
ThisByteCount - Number of bytes described by the IoRun entries. Will
|
|
not exceed the ByteCount passed in.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
PIO_RUN ThisIoRun = IoRuns;
|
|
BOOLEAN PerformedCopy;
|
|
|
|
//
|
|
// The following deal with where we are in the range of raw sectors.
|
|
// Note that we will bias the input file offset by the RIFF header
|
|
// to deal directly with the raw sectors.
|
|
//
|
|
|
|
ULONG RawSectorOffset;
|
|
ULONG RemainingRawByteCount = ByteCount;
|
|
LONGLONG CurrentRawOffset = StartingOffset - sizeof( RIFF_HEADER );
|
|
|
|
//
|
|
// The following is the offset into the cooked sectors for the file.
|
|
//
|
|
|
|
LONGLONG CurrentCookedOffset;
|
|
ULONG RemainingCookedByteCount;
|
|
|
|
//
|
|
// Following indicate the state of the user's buffer. We have
|
|
// the destination of the next transfer and its offset in the
|
|
// buffer. We also have the next available position in the buffer
|
|
// available for a scratch buffer.
|
|
//
|
|
|
|
PVOID CurrentUserBuffer = UserBuffer;
|
|
ULONG CurrentUserBufferOffset = UserBufferOffset;
|
|
|
|
//
|
|
// The following is the next contiguous bytes on the disk to
|
|
// transfer. These are represented by cooked byte offset and length.
|
|
// We also compute the number of raw bytes in the current transfer.
|
|
//
|
|
|
|
LONGLONG DiskOffset = 0;
|
|
ULONG CurrentCookedByteCount = 0;
|
|
ULONG CurrentRawByteCount;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// We need to maintain our position as we walk through the sectors on the disk.
|
|
// We keep separate values for the cooked offset as well as the raw offset.
|
|
// These are initialized on sector boundaries and we move through these
|
|
// the file sector-by-sector.
|
|
//
|
|
// Try to do 32-bit math.
|
|
//
|
|
|
|
if (((PLARGE_INTEGER) &CurrentRawOffset)->HighPart == 0) {
|
|
|
|
//
|
|
// Prefix/fast: Note that the following are safe since we only
|
|
// take this path for 32bit offsets.
|
|
//
|
|
|
|
CurrentRawOffset = (LONGLONG) ((ULONG) CurrentRawOffset / RAW_SECTOR_SIZE);
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma prefast( suppress: __WARNING_RESULTOFSHIFTCASTTOLARGERSIZE, "This is fine beacuse raw sector size > sector shift" )
|
|
#endif
|
|
CurrentCookedOffset = (LONGLONG) ((ULONG) CurrentRawOffset << SECTOR_SHIFT );
|
|
|
|
CurrentRawOffset = (LONGLONG) ((ULONG) CurrentRawOffset * RAW_SECTOR_SIZE);
|
|
|
|
//
|
|
// Otherwise we need to do 64-bit math (sigh).
|
|
//
|
|
|
|
} else {
|
|
|
|
CurrentRawOffset /= RAW_SECTOR_SIZE;
|
|
|
|
CurrentCookedOffset = CurrentRawOffset << SECTOR_SHIFT;
|
|
|
|
CurrentRawOffset *= RAW_SECTOR_SIZE;
|
|
}
|
|
|
|
//
|
|
// Now compute the full number of sectors to be read. Count all of the raw
|
|
// sectors that need to be read and convert to cooked bytes.
|
|
//
|
|
|
|
RawSectorOffset = (ULONG) ( StartingOffset - CurrentRawOffset) - sizeof( RIFF_HEADER );
|
|
CurrentRawByteCount = (RawSectorOffset + RemainingRawByteCount + RAW_SECTOR_SIZE - 1) / RAW_SECTOR_SIZE;
|
|
|
|
RemainingCookedByteCount = CurrentRawByteCount << SECTOR_SHIFT;
|
|
|
|
//
|
|
// Initialize the RunCount and ByteCount.
|
|
//
|
|
|
|
*RunCount = 0;
|
|
*ThisByteCount = 0;
|
|
|
|
//
|
|
// Loop while there are more bytes to process or there are
|
|
// available entries in the IoRun array.
|
|
//
|
|
|
|
while (TRUE) {
|
|
|
|
PerformedCopy = FALSE;
|
|
*RunCount += 1;
|
|
|
|
//
|
|
// Initialize the current position in the IoRuns array. Find the
|
|
// eventual destination in the user's buffer for this portion of the transfer.
|
|
//
|
|
|
|
ThisIoRun->UserBuffer = CurrentUserBuffer;
|
|
|
|
//
|
|
// Find the allocation information for the current offset in the
|
|
// stream.
|
|
//
|
|
|
|
CdLookupAllocation( IrpContext,
|
|
Fcb,
|
|
CurrentCookedOffset,
|
|
&DiskOffset,
|
|
&CurrentCookedByteCount );
|
|
//
|
|
// Maybe we got lucky and this is the same sector as in the
|
|
// Vcb.
|
|
//
|
|
|
|
if (DiskOffset == Fcb->Vcb->XADiskOffset) {
|
|
|
|
//
|
|
// We will perform safe synchronization. Check again that
|
|
// this is the correct sector.
|
|
//
|
|
|
|
CdLockVcb( IrpContext, Fcb->Vcb );
|
|
|
|
if ((DiskOffset == Fcb->Vcb->XADiskOffset) &&
|
|
(Fcb->Vcb->XASector != NULL)) {
|
|
|
|
//
|
|
// Copy any bytes we can from the current sector.
|
|
//
|
|
|
|
CurrentRawByteCount = RAW_SECTOR_SIZE - RawSectorOffset;
|
|
|
|
//
|
|
// Check whether we don't go to the end of the sector.
|
|
//
|
|
|
|
if (CurrentRawByteCount > RemainingRawByteCount) {
|
|
|
|
CurrentRawByteCount = RemainingRawByteCount;
|
|
}
|
|
|
|
RtlCopyMemory( CurrentUserBuffer,
|
|
Add2Ptr( Fcb->Vcb->XASector, RawSectorOffset, PCHAR ),
|
|
CurrentRawByteCount );
|
|
|
|
CdUnlockVcb( IrpContext, Fcb->Vcb );
|
|
|
|
//
|
|
// Adjust the run count and pointer in the IoRuns array
|
|
// to show that we didn't use a position.
|
|
//
|
|
|
|
*RunCount -= 1;
|
|
ThisIoRun -= 1;
|
|
|
|
//
|
|
// Remember that we performed a copy operation.
|
|
//
|
|
|
|
PerformedCopy = TRUE;
|
|
|
|
CurrentCookedByteCount = SECTOR_SIZE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// The safe test showed no available buffer. Drop down to common code to
|
|
// perform the Io.
|
|
//
|
|
|
|
CdUnlockVcb( IrpContext, Fcb->Vcb );
|
|
}
|
|
}
|
|
|
|
//
|
|
// No work in this pass if we did a copy operation.
|
|
//
|
|
|
|
if (!PerformedCopy) {
|
|
|
|
//
|
|
// Limit ourselves by the number of remaining cooked bytes.
|
|
//
|
|
|
|
if (CurrentCookedByteCount > RemainingCookedByteCount) {
|
|
|
|
CurrentCookedByteCount = RemainingCookedByteCount;
|
|
}
|
|
|
|
ThisIoRun->DiskOffset = DiskOffset;
|
|
ThisIoRun->TransferBufferOffset = RawSectorOffset;
|
|
|
|
//
|
|
// We will always need to perform copy operations for XA files.
|
|
// We allocate an auxillary buffer to read the start of the
|
|
// transfer. Then we can use a range of the user's buffer to
|
|
// perform the next range of the transfer. Finally we may
|
|
// need to allocate a buffer for the tail of the transfer.
|
|
//
|
|
// We can use the user's buffer (at the current scratch buffer) if the
|
|
// following are true:
|
|
//
|
|
// If we are to store the beginning of the raw sector in the user's buffer.
|
|
// The current scratch buffer precedes the destination in the user's buffer
|
|
// (and hence also lies within it)
|
|
// There are enough bytes remaining in the buffer for at least one
|
|
// raw sector.
|
|
//
|
|
|
|
if ((RawSectorOffset == 0) &&
|
|
(RemainingRawByteCount >= RAW_SECTOR_SIZE)) {
|
|
|
|
//
|
|
// We can use the scratch buffer. We must ensure we don't send down reads
|
|
// greater than the device can handle, since the driver is unable to split
|
|
// raw requests.
|
|
//
|
|
|
|
if (CurrentCookedByteCount <= Fcb->Vcb->MaximumTransferRawSectors * SECTOR_SIZE) {
|
|
|
|
CurrentRawByteCount = (SectorAlign( CurrentCookedByteCount) >> SECTOR_SHIFT) * RAW_SECTOR_SIZE;
|
|
|
|
} else {
|
|
|
|
CurrentCookedByteCount = Fcb->Vcb->MaximumTransferRawSectors * SECTOR_SIZE;
|
|
CurrentRawByteCount = Fcb->Vcb->MaximumTransferRawSectors * RAW_SECTOR_SIZE;
|
|
}
|
|
|
|
//
|
|
// Now make sure we are within the page transfer limit.
|
|
//
|
|
|
|
while (ADDRESS_AND_SIZE_TO_SPAN_PAGES(CurrentUserBuffer, RawSectorAlign( CurrentRawByteCount)) >
|
|
Fcb->Vcb->MaximumPhysicalPages ) {
|
|
|
|
CurrentRawByteCount -= RAW_SECTOR_SIZE;
|
|
CurrentCookedByteCount -= SECTOR_SIZE;
|
|
}
|
|
|
|
//
|
|
// Trim the number of bytes to read if it won't fit into the current buffer. Take
|
|
// account of the fact that we must read in whole raw sector multiples.
|
|
//
|
|
|
|
while (RawSectorAlign( CurrentRawByteCount) > RemainingRawByteCount) {
|
|
|
|
CurrentRawByteCount -= RAW_SECTOR_SIZE;
|
|
CurrentCookedByteCount -= SECTOR_SIZE;
|
|
}
|
|
|
|
//
|
|
// Now trim the maximum number of raw bytes to the remaining bytes.
|
|
//
|
|
|
|
if (CurrentRawByteCount > RemainingRawByteCount) {
|
|
|
|
CurrentRawByteCount = RemainingRawByteCount;
|
|
}
|
|
|
|
//
|
|
// Update the IO run array. We point to the scratch buffer as
|
|
// well as the buffer and Mdl in the original Irp.
|
|
//
|
|
|
|
ThisIoRun->DiskByteCount = SectorAlign( CurrentCookedByteCount);
|
|
|
|
//
|
|
// Point to the user's buffer and Mdl for this transfer.
|
|
//
|
|
|
|
ThisIoRun->TransferBuffer = CurrentUserBuffer;
|
|
ThisIoRun->TransferMdl = Irp->MdlAddress;
|
|
ThisIoRun->TransferVirtualAddress = Add2Ptr( Irp->UserBuffer,
|
|
CurrentUserBufferOffset,
|
|
PVOID);
|
|
|
|
} else {
|
|
|
|
//
|
|
// We need to determine the number of bytes to transfer and the
|
|
// offset into this page to begin the transfer.
|
|
//
|
|
// We will transfer only one raw sector.
|
|
//
|
|
|
|
ThisIoRun->DiskByteCount = SECTOR_SIZE;
|
|
|
|
CurrentCookedByteCount = SECTOR_SIZE;
|
|
|
|
ThisIoRun->TransferByteCount = RAW_SECTOR_SIZE - RawSectorOffset;
|
|
ThisIoRun->TransferBufferOffset = RawSectorOffset;
|
|
|
|
if (ThisIoRun->TransferByteCount > RemainingRawByteCount) {
|
|
|
|
ThisIoRun->TransferByteCount = RemainingRawByteCount;
|
|
}
|
|
|
|
CurrentRawByteCount = ThisIoRun->TransferByteCount;
|
|
|
|
//
|
|
// We need to allocate an auxillary buffer. We will allocate
|
|
// a single page. Then we will build an Mdl to describe the buffer.
|
|
//
|
|
|
|
ThisIoRun->TransferBuffer = FsRtlAllocatePoolWithTag( CdNonPagedPool, PAGE_SIZE, TAG_IO_BUFFER );
|
|
|
|
//
|
|
// Allocate and build the Mdl to describe this buffer.
|
|
//
|
|
|
|
ThisIoRun->TransferMdl = IoAllocateMdl( ThisIoRun->TransferBuffer,
|
|
PAGE_SIZE,
|
|
FALSE,
|
|
FALSE,
|
|
NULL );
|
|
|
|
ThisIoRun->TransferVirtualAddress = ThisIoRun->TransferBuffer;
|
|
|
|
if (ThisIoRun->TransferMdl == NULL) {
|
|
|
|
IrpContext->Irp->IoStatus.Information = 0;
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
|
|
}
|
|
|
|
MmBuildMdlForNonPagedPool( ThisIoRun->TransferMdl );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Update the byte count for our caller.
|
|
//
|
|
|
|
RemainingRawByteCount -= CurrentRawByteCount;
|
|
*ThisByteCount += CurrentRawByteCount;
|
|
|
|
//
|
|
// Break out if no more positions in the IoRuns array or
|
|
// we have all of the bytes accounted for.
|
|
//
|
|
|
|
if ((RemainingRawByteCount == 0) || (*RunCount == MAX_PARALLEL_IOS)) {
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Update our local pointers to allow for the current range of bytes.
|
|
//
|
|
|
|
ThisIoRun += 1;
|
|
|
|
CurrentUserBuffer = Add2Ptr( CurrentUserBuffer, CurrentRawByteCount, PVOID );
|
|
CurrentUserBufferOffset += CurrentRawByteCount;
|
|
|
|
RawSectorOffset = 0;
|
|
|
|
CurrentCookedOffset += CurrentCookedByteCount;
|
|
RemainingCookedByteCount -= CurrentCookedByteCount;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
BOOLEAN
|
|
CdFinishBuffers (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_Inout_ PIO_RUN IoRuns,
|
|
_In_ ULONG RunCount,
|
|
_In_ BOOLEAN FinalCleanup,
|
|
_In_ BOOLEAN SaveXABuffer
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called to perform any data transferred required for
|
|
unaligned Io or to perform the final cleanup of the IoRuns array.
|
|
|
|
In all cases this is where we will deallocate any buffer and mdl
|
|
allocated to perform the unaligned transfer. If this is not the
|
|
final cleanup then we also transfer the bytes to the user buffer
|
|
and flush the hardware cache.
|
|
|
|
We walk backwards through the run array because we may be shifting data
|
|
in the user's buffer. Typical case is where we allocated a buffer for
|
|
the first part of a read and then used the user's buffer for the
|
|
next section (but stored it at the beginning of the buffer.
|
|
|
|
Arguments:
|
|
|
|
IoRuns - Pointer to the IoRuns array.
|
|
|
|
RunCount - Number of entries in the IoRuns array filled here.
|
|
|
|
FinalCleanup - Indicates if we should be deallocating temporary buffers
|
|
(TRUE) or transferring bytes for a unaligned transfers and
|
|
deallocating the buffers (FALSE). Flush the system cache if
|
|
transferring data.
|
|
|
|
SaveXABuffer - TRUE if we should try to save an XA buffer, FALSE otherwise
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - TRUE if this request needs the Io buffers to be flushed, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOLEAN FlushIoBuffers = FALSE;
|
|
|
|
ULONG RemainingEntries = RunCount;
|
|
PIO_RUN ThisIoRun = &IoRuns[RunCount - 1];
|
|
PVCB Vcb;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Walk through each entry in the IoRun array.
|
|
//
|
|
|
|
while (RemainingEntries != 0) {
|
|
|
|
//
|
|
// We only need to deal with the case of an unaligned transfer.
|
|
//
|
|
|
|
if (ThisIoRun->TransferByteCount != 0) {
|
|
|
|
//
|
|
// If not the final cleanup then transfer the data to the
|
|
// user's buffer and remember that we will need to flush
|
|
// the user's buffer to memory.
|
|
//
|
|
|
|
if (!FinalCleanup) {
|
|
|
|
RtlCopyMemory( ThisIoRun->UserBuffer,
|
|
Add2Ptr( ThisIoRun->TransferBuffer,
|
|
ThisIoRun->TransferBufferOffset,
|
|
PVOID ),
|
|
ThisIoRun->TransferByteCount );
|
|
|
|
FlushIoBuffers = TRUE;
|
|
}
|
|
|
|
//
|
|
// Free any Mdl we may have allocated. If the Mdl isn't
|
|
// present then we must have failed during the allocation
|
|
// phase.
|
|
//
|
|
|
|
if (ThisIoRun->TransferMdl != IrpContext->Irp->MdlAddress) {
|
|
|
|
if (ThisIoRun->TransferMdl != NULL) {
|
|
|
|
IoFreeMdl( ThisIoRun->TransferMdl );
|
|
}
|
|
|
|
//
|
|
// Now free any buffer we may have allocated. If the Mdl
|
|
// doesn't match the original Mdl then free the buffer.
|
|
//
|
|
|
|
if (ThisIoRun->TransferBuffer != NULL) {
|
|
|
|
//
|
|
// If this is the final buffer for an XA read then store this buffer
|
|
// into the Vcb so that we will have it when reading any remaining
|
|
// portion of this buffer.
|
|
//
|
|
|
|
if (SaveXABuffer) {
|
|
|
|
Vcb = IrpContext->Vcb;
|
|
|
|
CdLockVcb( IrpContext, Vcb );
|
|
|
|
if (Vcb->XASector != NULL) {
|
|
|
|
CdFreePool( &Vcb->XASector );
|
|
}
|
|
|
|
Vcb->XASector = ThisIoRun->TransferBuffer;
|
|
Vcb->XADiskOffset = ThisIoRun->DiskOffset;
|
|
|
|
SaveXABuffer = FALSE;
|
|
|
|
CdUnlockVcb( IrpContext, Vcb );
|
|
|
|
//
|
|
// Otherwise just free the buffer.
|
|
//
|
|
|
|
} else {
|
|
|
|
CdFreePool( &ThisIoRun->TransferBuffer );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now handle the case where we failed in the process
|
|
// of allocating associated Irps and Mdls.
|
|
//
|
|
|
|
if (ThisIoRun->SavedIrp != NULL) {
|
|
|
|
if (ThisIoRun->SavedIrp->MdlAddress != NULL) {
|
|
|
|
IoFreeMdl( ThisIoRun->SavedIrp->MdlAddress );
|
|
}
|
|
|
|
IoFreeIrp( ThisIoRun->SavedIrp );
|
|
}
|
|
|
|
//
|
|
// Move to the previous IoRun entry.
|
|
//
|
|
|
|
ThisIoRun -= 1;
|
|
RemainingEntries -= 1;
|
|
}
|
|
|
|
//
|
|
// If we copied any data then flush the Io buffers.
|
|
//
|
|
|
|
return FlushIoBuffers;
|
|
}
|
|
|
|
// Tell prefast this is a completion routine.
|
|
IO_COMPLETION_ROUTINE CdSyncCompletionRoutine;
|
|
|
|
NTSTATUS
|
|
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
|
|
CdSyncCompletionRoutine (
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PVOID Contxt
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Completion routine for synchronizing back to dispatch.
|
|
|
|
Arguments:
|
|
|
|
Contxt - pointer to KEVENT.
|
|
|
|
Return Value:
|
|
|
|
STATUS_MORE_PROCESSING_REQUIRED
|
|
|
|
--*/
|
|
|
|
{
|
|
PKEVENT Event = (PKEVENT)Contxt;
|
|
_Analysis_assume_(Contxt != NULL);
|
|
|
|
UNREFERENCED_PARAMETER( Irp );
|
|
UNREFERENCED_PARAMETER( DeviceObject );
|
|
|
|
KeSetEvent( Event, 0, FALSE );
|
|
|
|
//
|
|
// We don't want IO to get our IRP and free it.
|
|
//
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
VOID
|
|
CdFreeDirCache (
|
|
_In_ PIRP_CONTEXT IrpContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Safely frees the sector cache buffer.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PAGED_CODE();
|
|
|
|
if (NULL != IrpContext->Vcb->SectorCacheBuffer) {
|
|
|
|
CdAcquireCacheForUpdate( IrpContext);
|
|
CdFreePool( &IrpContext->Vcb->SectorCacheBuffer);
|
|
CdReleaseCache( IrpContext);
|
|
}
|
|
}
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
BOOLEAN
|
|
CdReadDirDataThroughCache (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PIO_RUN Run
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Reads blocks through the sector cache. If the data is present, then it
|
|
is copied from memory. If not present, one of the cache chunks will be
|
|
replaced with a chunk containing the requested region, and the data
|
|
copied from there.
|
|
|
|
Only intended for reading *directory* blocks, for the purpose of pre-caching
|
|
directory information, by reading a chunk of blocks which hopefully contains
|
|
other directory blocks, rather than just the (usually) single block requested.
|
|
|
|
Arguments:
|
|
|
|
Run - description of extent required, and buffer to read into.
|
|
|
|
Return Value:
|
|
|
|
None. Raises on error.
|
|
|
|
--*/
|
|
|
|
{
|
|
PVCB Vcb = IrpContext->Vcb;
|
|
ULONG Lbn = SectorsFromLlBytes( Run->DiskOffset);
|
|
ULONG Remaining = SectorsFromBytes( Run->DiskByteCount);
|
|
PUCHAR UserBuffer = Run->TransferBuffer;
|
|
|
|
NTSTATUS Status;
|
|
ULONG Found;
|
|
ULONG BufferSectorOffset;
|
|
ULONG StartBlock;
|
|
ULONG EndBlock;
|
|
ULONG Blocks;
|
|
|
|
PIO_STACK_LOCATION IrpSp;
|
|
IO_STATUS_BLOCK Iosb;
|
|
|
|
PTRACK_DATA TrackData;
|
|
|
|
#if DBG
|
|
BOOLEAN JustRead = FALSE;
|
|
#endif
|
|
|
|
ULONG Index;
|
|
PCD_SECTOR_CACHE_CHUNK Buffer;
|
|
BOOLEAN Result = FALSE;
|
|
|
|
PAGED_CODE();
|
|
|
|
CdAcquireCacheForRead( IrpContext);
|
|
|
|
_SEH2_TRY {
|
|
|
|
//
|
|
// Check the cache hasn't gone away due to volume verify failure (which
|
|
// is the *only* reason it'll go away). If this is the case we raise
|
|
// the same error any I/O would return if the cache weren't here.
|
|
//
|
|
|
|
if (NULL == Vcb->SectorCacheBuffer) {
|
|
|
|
CdRaiseStatus( IrpContext, STATUS_VERIFY_REQUIRED);
|
|
}
|
|
|
|
while (Remaining) {
|
|
|
|
Buffer = NULL;
|
|
|
|
//
|
|
// Look to see if any portion is currently cached.
|
|
//
|
|
|
|
for (Index = 0; Index < CD_SEC_CACHE_CHUNKS; Index++) {
|
|
|
|
if ((Vcb->SecCacheChunks[ Index].BaseLbn != -1) &&
|
|
(Vcb->SecCacheChunks[ Index].BaseLbn <= Lbn) &&
|
|
((Vcb->SecCacheChunks[ Index].BaseLbn + CD_SEC_CHUNK_BLOCKS) > Lbn)) {
|
|
|
|
Buffer = &Vcb->SecCacheChunks[ Index];
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we found any, copy it out and continue.
|
|
//
|
|
|
|
if (NULL != Buffer) {
|
|
|
|
BufferSectorOffset = Lbn - Buffer->BaseLbn;
|
|
Found = Min( CD_SEC_CHUNK_BLOCKS - BufferSectorOffset, Remaining);
|
|
|
|
RtlCopyMemory( UserBuffer,
|
|
Buffer->Buffer + BytesFromSectors( BufferSectorOffset),
|
|
BytesFromSectors( Found));
|
|
|
|
Remaining -= Found;
|
|
UserBuffer += BytesFromSectors( Found);
|
|
Lbn += Found;
|
|
#if DBG
|
|
//
|
|
// Update stats. Don't count a hit if we've just read the data in.
|
|
//
|
|
|
|
if (!JustRead) {
|
|
|
|
InterlockedIncrement( (LONG*)&Vcb->SecCacheHits);
|
|
}
|
|
|
|
JustRead = FALSE;
|
|
#endif
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Missed the cache, so we need to read a new chunk. Take the cache
|
|
// resource exclusive while we do so.
|
|
//
|
|
|
|
CdReleaseCache( IrpContext);
|
|
CdAcquireCacheForUpdate( IrpContext);
|
|
#if DBG
|
|
Vcb->SecCacheMisses += 1;
|
|
#endif
|
|
//
|
|
// Select the chunk to replace and calculate the start block of the
|
|
// chunk to cache. We cache blocks which start on Lbns aligned on
|
|
// multiples of chunk size, treating block 16 (VRS start) as block
|
|
// zero.
|
|
//
|
|
|
|
Buffer = &Vcb->SecCacheChunks[ Vcb->SecCacheLRUChunkIndex];
|
|
|
|
StartBlock = Lbn - ((Lbn - 16) % CD_SEC_CHUNK_BLOCKS);
|
|
|
|
//
|
|
// Make sure we don't try and read past end of the last track.
|
|
//
|
|
|
|
#ifdef __REACTOS__
|
|
if (Vcb->CdromToc) {
|
|
#endif
|
|
TrackData = &Vcb->CdromToc->TrackData[(Vcb->CdromToc->LastTrack - Vcb->CdromToc->FirstTrack + 1)];
|
|
|
|
SwapCopyUchar4( &EndBlock, &TrackData->Address );
|
|
|
|
Blocks = EndBlock - StartBlock;
|
|
|
|
if (Blocks > CD_SEC_CHUNK_BLOCKS) {
|
|
|
|
Blocks = CD_SEC_CHUNK_BLOCKS;
|
|
}
|
|
#ifdef __REACTOS__
|
|
} else {
|
|
// HACK!!!!!!!! Might cause reads to overrun the end of the partition, no idea what consequences that can have.
|
|
Blocks = CD_SEC_CHUNK_BLOCKS;
|
|
}
|
|
#endif
|
|
|
|
if ((0 == Blocks) || (Lbn < 16)) {
|
|
|
|
CdRaiseStatus( IrpContext, STATUS_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// Now build / send the read request.
|
|
//
|
|
|
|
IoReuseIrp( Vcb->SectorCacheIrp, STATUS_SUCCESS);
|
|
|
|
KeClearEvent( &Vcb->SectorCacheEvent);
|
|
Vcb->SectorCacheIrp->Tail.Overlay.Thread = PsGetCurrentThread();
|
|
|
|
//
|
|
// Get a pointer to the stack location of the first driver which will be
|
|
// invoked. This is where the function codes and the parameters are set.
|
|
//
|
|
|
|
IrpSp = IoGetNextIrpStackLocation( Vcb->SectorCacheIrp);
|
|
IrpSp->MajorFunction = (UCHAR) IRP_MJ_READ;
|
|
|
|
//
|
|
// Build an MDL to describe the buffer.
|
|
//
|
|
|
|
IoAllocateMdl( Buffer->Buffer,
|
|
BytesFromSectors( Blocks),
|
|
FALSE,
|
|
FALSE,
|
|
Vcb->SectorCacheIrp);
|
|
|
|
if (NULL == Vcb->SectorCacheIrp->MdlAddress) {
|
|
|
|
IrpContext->Irp->IoStatus.Information = 0;
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES);
|
|
}
|
|
|
|
//
|
|
// We're reading/writing into the block cache (paged pool). Lock the
|
|
// pages and update the MDL with physical page information.
|
|
//
|
|
|
|
_SEH2_TRY {
|
|
|
|
MmProbeAndLockPages( Vcb->SectorCacheIrp->MdlAddress,
|
|
KernelMode,
|
|
(LOCK_OPERATION) IoWriteAccess );
|
|
}
|
|
#ifdef _MSC_VER
|
|
#pragma warning(suppress: 6320)
|
|
#endif
|
|
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
IoFreeMdl( Vcb->SectorCacheIrp->MdlAddress );
|
|
Vcb->SectorCacheIrp->MdlAddress = NULL;
|
|
} _SEH2_END;
|
|
|
|
if (NULL == Vcb->SectorCacheIrp->MdlAddress) {
|
|
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
|
|
}
|
|
|
|
//
|
|
// Reset the BaseLbn as we can't trust this Buffer's data until the request
|
|
// is successfully completed.
|
|
//
|
|
|
|
Buffer->BaseLbn = (ULONG)-1;
|
|
|
|
IrpSp->Parameters.Read.Length = BytesFromSectors( Blocks);
|
|
IrpSp->Parameters.Read.ByteOffset.QuadPart = LlBytesFromSectors( StartBlock);
|
|
|
|
IoSetCompletionRoutine( Vcb->SectorCacheIrp,
|
|
CdSyncCompletionRoutine,
|
|
&Vcb->SectorCacheEvent,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE );
|
|
|
|
Vcb->SectorCacheIrp->UserIosb = &Iosb;
|
|
|
|
Status = IoCallDriver( Vcb->TargetDeviceObject, Vcb->SectorCacheIrp );
|
|
|
|
if (STATUS_PENDING == Status) {
|
|
|
|
|
|
(VOID)KeWaitForSingleObject( &Vcb->SectorCacheEvent,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
Status = Vcb->SectorCacheIrp->IoStatus.Status;
|
|
}
|
|
|
|
Vcb->SectorCacheIrp->UserIosb = NULL;
|
|
|
|
//
|
|
// Unlock the pages and free the MDL.
|
|
//
|
|
|
|
MmUnlockPages( Vcb->SectorCacheIrp->MdlAddress );
|
|
IoFreeMdl( Vcb->SectorCacheIrp->MdlAddress );
|
|
Vcb->SectorCacheIrp->MdlAddress = NULL;
|
|
|
|
if (!NT_SUCCESS( Status )) {
|
|
|
|
try_leave( Status );
|
|
}
|
|
|
|
//
|
|
// Update the buffer information, and drop the cache resource to shared
|
|
// to allow in reads.
|
|
//
|
|
|
|
Buffer->BaseLbn = StartBlock;
|
|
Vcb->SecCacheLRUChunkIndex = (Vcb->SecCacheLRUChunkIndex + 1) % CD_SEC_CACHE_CHUNKS;
|
|
|
|
CdConvertCacheToShared( IrpContext);
|
|
#if DBG
|
|
JustRead = TRUE;
|
|
#endif
|
|
}
|
|
|
|
Result = TRUE;
|
|
}
|
|
_SEH2_FINALLY {
|
|
|
|
CdReleaseCache( IrpContext);
|
|
} _SEH2_END;
|
|
|
|
return Result;
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
VOID
|
|
CdMultipleAsync (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PFCB Fcb,
|
|
_In_ ULONG RunCount,
|
|
_Inout_ PIO_RUN IoRuns
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine first does the initial setup required of a Master IRP that is
|
|
going to be completed using associated IRPs. This routine should not
|
|
be used if only one async request is needed, instead the single read
|
|
async routines should be called.
|
|
|
|
A context parameter is initialized, to serve as a communications area
|
|
between here and the common completion routine.
|
|
|
|
Next this routine reads or writes one or more contiguous sectors from
|
|
a device asynchronously, and is used if there are multiple reads for a
|
|
master IRP. A completion routine is used to synchronize with the
|
|
completion of all of the I/O requests started by calls to this routine.
|
|
|
|
Also, prior to calling this routine the caller must initialize the
|
|
IoStatus field in the Context, with the correct success status and byte
|
|
count which are expected if all of the parallel transfers complete
|
|
successfully. After return this status will be unchanged if all requests
|
|
were, in fact, successful. However, if one or more errors occur, the
|
|
IoStatus will be modified to reflect the error status and byte count
|
|
from the first run (by Vbo) which encountered an error. I/O status
|
|
from all subsequent runs will not be indicated.
|
|
|
|
Arguments:
|
|
|
|
RunCount - Supplies the number of multiple async requests
|
|
that will be issued against the master irp.
|
|
|
|
IoRuns - Supplies an array containing the Offset and ByteCount for the
|
|
separate requests.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIO_COMPLETION_ROUTINE CompletionRoutine;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
PMDL Mdl;
|
|
PIRP Irp;
|
|
PIRP MasterIrp;
|
|
ULONG UnwindRunCount;
|
|
BOOLEAN UseSectorCache;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Set up things according to whether this is truely async.
|
|
//
|
|
|
|
CompletionRoutine = CdMultiSyncCompletionRoutine;
|
|
|
|
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
|
|
|
|
CompletionRoutine = CdMultiAsyncCompletionRoutine;
|
|
}
|
|
|
|
//
|
|
// For directories, use the sector cache.
|
|
//
|
|
|
|
if ((SafeNodeType( Fcb) == CDFS_NTC_FCB_INDEX) &&
|
|
(NULL != Fcb->Vcb->SectorCacheBuffer) &&
|
|
(VcbMounted == IrpContext->Vcb->VcbCondition)) {
|
|
|
|
UseSectorCache = TRUE;
|
|
}
|
|
else {
|
|
|
|
UseSectorCache = FALSE;
|
|
}
|
|
|
|
//
|
|
// Initialize some local variables.
|
|
//
|
|
|
|
MasterIrp = IrpContext->Irp;
|
|
|
|
//
|
|
// Itterate through the runs, doing everything that can fail.
|
|
// We let the cleanup in CdFinishBuffers clean up on error.
|
|
//
|
|
|
|
for (UnwindRunCount = 0;
|
|
UnwindRunCount < RunCount;
|
|
UnwindRunCount += 1) {
|
|
|
|
if (UseSectorCache) {
|
|
|
|
if (!CdReadDirDataThroughCache( IrpContext, &IoRuns[ UnwindRunCount])) {
|
|
|
|
//
|
|
// Turn off using directory cache and restart all over again.
|
|
//
|
|
|
|
UseSectorCache = FALSE;
|
|
UnwindRunCount = 0;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Create an associated IRP, making sure there is one stack entry for
|
|
// us, as well.
|
|
//
|
|
|
|
IoRuns[UnwindRunCount].SavedIrp =
|
|
Irp = IoMakeAssociatedIrp( MasterIrp, (CCHAR)(IrpContext->Vcb->TargetDeviceObject->StackSize + 1) );
|
|
|
|
if (Irp == NULL) {
|
|
|
|
IrpContext->Irp->IoStatus.Information = 0;
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
|
|
}
|
|
|
|
//
|
|
// Allocate and build a partial Mdl for the request.
|
|
//
|
|
|
|
Mdl = IoAllocateMdl( IoRuns[UnwindRunCount].TransferVirtualAddress,
|
|
IoRuns[UnwindRunCount].DiskByteCount,
|
|
FALSE,
|
|
FALSE,
|
|
Irp );
|
|
|
|
if (Mdl == NULL) {
|
|
|
|
IrpContext->Irp->IoStatus.Information = 0;
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
|
|
}
|
|
|
|
IoBuildPartialMdl( IoRuns[UnwindRunCount].TransferMdl,
|
|
Mdl,
|
|
IoRuns[UnwindRunCount].TransferVirtualAddress,
|
|
IoRuns[UnwindRunCount].DiskByteCount );
|
|
|
|
//
|
|
// Get the first IRP stack location in the associated Irp
|
|
//
|
|
|
|
IoSetNextIrpStackLocation( Irp );
|
|
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
|
|
|
//
|
|
// Setup the Stack location to describe our read.
|
|
//
|
|
|
|
IrpSp->MajorFunction = IRP_MJ_READ;
|
|
IrpSp->Parameters.Read.Length = IoRuns[UnwindRunCount].DiskByteCount;
|
|
IrpSp->Parameters.Read.ByteOffset.QuadPart = IoRuns[UnwindRunCount].DiskOffset;
|
|
|
|
//
|
|
// Set up the completion routine address in our stack frame.
|
|
//
|
|
|
|
IoSetCompletionRoutine( Irp,
|
|
CompletionRoutine,
|
|
IrpContext->IoContext,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE );
|
|
|
|
//
|
|
// Setup the next IRP stack location in the associated Irp for the disk
|
|
// driver beneath us.
|
|
//
|
|
|
|
IrpSp = IoGetNextIrpStackLocation( Irp );
|
|
|
|
//
|
|
// Setup the Stack location to do a read from the disk driver.
|
|
//
|
|
|
|
IrpSp->MajorFunction = IRP_MJ_READ;
|
|
IrpSp->Parameters.Read.Length = IoRuns[UnwindRunCount].DiskByteCount;
|
|
IrpSp->Parameters.Read.ByteOffset.QuadPart = IoRuns[UnwindRunCount].DiskOffset;
|
|
}
|
|
|
|
//
|
|
// If we used the cache, we're done.
|
|
//
|
|
|
|
if (UseSectorCache) {
|
|
|
|
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
|
|
|
|
IrpContext->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
KeSetEvent( &IrpContext->IoContext->SyncEvent, 0, FALSE );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// We only need to set the associated IRP count in the master irp to
|
|
// make it a master IRP. But we set the count to one more than our
|
|
// caller requested, because we do not want the I/O system to complete
|
|
// the I/O. We also set our own count.
|
|
//
|
|
|
|
IrpContext->IoContext->IrpCount = RunCount;
|
|
IrpContext->IoContext->MasterIrp = MasterIrp;
|
|
|
|
//
|
|
// We set the count in the master Irp to 1 since typically we
|
|
// will clean up the associated irps ourselves. Setting this to one
|
|
// means completing the last associated Irp with SUCCESS (in the async
|
|
// case) will complete the master irp.
|
|
//
|
|
|
|
MasterIrp->AssociatedIrp.IrpCount = 1;
|
|
|
|
//
|
|
// If we (FS) acquired locks, transition the lock owners to an object, since
|
|
// when we return this thread could go away before request completion, and
|
|
// the resource package may otherwise try to boost priority, etc.
|
|
//
|
|
|
|
if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT ) &&
|
|
FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL )) {
|
|
|
|
NT_ASSERT( IrpContext->IoContext->ResourceThreadId == (ERESOURCE_THREAD)PsGetCurrentThread() );
|
|
|
|
IrpContext->IoContext->ResourceThreadId = ((ULONG_PTR)IrpContext->IoContext) | 3;
|
|
|
|
ExSetResourceOwnerPointer( IrpContext->IoContext->Resource,
|
|
(PVOID)IrpContext->IoContext->ResourceThreadId );
|
|
}
|
|
|
|
//
|
|
// Now that all the dangerous work is done, issue the Io requests
|
|
//
|
|
|
|
for (UnwindRunCount = 0;
|
|
UnwindRunCount < RunCount;
|
|
UnwindRunCount++) {
|
|
|
|
Irp = IoRuns[UnwindRunCount].SavedIrp;
|
|
IoRuns[UnwindRunCount].SavedIrp = NULL;
|
|
|
|
if (NULL != Irp) {
|
|
|
|
//
|
|
// If IoCallDriver returns an error, it has completed the Irp
|
|
// and the error will be caught by our completion routines
|
|
// and dealt with as a normal IO error.
|
|
//
|
|
|
|
(VOID) IoCallDriver( IrpContext->Vcb->TargetDeviceObject, Irp );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
VOID
|
|
CdMultipleXAAsync (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ ULONG RunCount,
|
|
_Inout_ PIO_RUN IoRuns,
|
|
_In_ PRAW_READ_INFO RawReads,
|
|
_In_ TRACK_MODE_TYPE TrackMode
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine first does the initial setup required of a Master IRP that is
|
|
going to be completed using associated IRPs. This routine is used to generate
|
|
the associated Irps used to read raw sectors from the disk.
|
|
|
|
A context parameter is initialized, to serve as a communications area
|
|
between here and the common completion routine.
|
|
|
|
Next this routine reads or writes one or more contiguous sectors from
|
|
a device asynchronously, and is used if there are multiple reads for a
|
|
master IRP. A completion routine is used to synchronize with the
|
|
completion of all of the I/O requests started by calls to this routine.
|
|
|
|
Also, prior to calling this routine the caller must initialize the
|
|
IoStatus field in the Context, with the correct success status and byte
|
|
count which are expected if all of the parallel transfers complete
|
|
successfully. After return this status will be unchanged if all requests
|
|
were, in fact, successful. However, if one or more errors occur, the
|
|
IoStatus will be modified to reflect the error status and byte count
|
|
from the first run (by Vbo) which encountered an error. I/O status
|
|
from all subsequent runs will not be indicated.
|
|
|
|
Arguments:
|
|
|
|
RunCount - Supplies the number of multiple async requests
|
|
that will be issued against the master irp.
|
|
|
|
IoRuns - Supplies an array containing the Offset and ByteCount for the
|
|
separate requests.
|
|
|
|
RawReads - Supplies an array of structures to store in the Irps passed to the
|
|
device driver to perform the low-level Io.
|
|
|
|
TrackMode - Supplies the recording mode of sectors in these IoRuns
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIO_STACK_LOCATION IrpSp;
|
|
PMDL Mdl;
|
|
PIRP Irp;
|
|
PIRP MasterIrp;
|
|
ULONG UnwindRunCount;
|
|
ULONG RawByteCount;
|
|
|
|
PIO_RUN ThisIoRun = IoRuns;
|
|
PRAW_READ_INFO ThisRawRead = RawReads;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// Initialize some local variables.
|
|
//
|
|
|
|
MasterIrp = IrpContext->Irp;
|
|
|
|
//
|
|
// Itterate through the runs, doing everything that can fail.
|
|
// We let the cleanup in CdFinishBuffers clean up on error.
|
|
//
|
|
|
|
for (UnwindRunCount = 0;
|
|
UnwindRunCount < RunCount;
|
|
UnwindRunCount += 1, ThisIoRun += 1, ThisRawRead += 1) {
|
|
|
|
//
|
|
// Create an associated IRP, making sure there is one stack entry for
|
|
// us, as well.
|
|
//
|
|
|
|
ThisIoRun->SavedIrp =
|
|
Irp = IoMakeAssociatedIrp( MasterIrp, (CCHAR)(IrpContext->Vcb->TargetDeviceObject->StackSize + 1) );
|
|
|
|
if (Irp == NULL) {
|
|
|
|
IrpContext->Irp->IoStatus.Information = 0;
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
|
|
}
|
|
|
|
//
|
|
// Should have been passed a byte count of at least one sector, and
|
|
// must be a multiple of sector size
|
|
//
|
|
|
|
NT_ASSERT( ThisIoRun->DiskByteCount && !SectorOffset(ThisIoRun->DiskByteCount));
|
|
|
|
RawByteCount = SectorsFromBytes( ThisIoRun->DiskByteCount) * RAW_SECTOR_SIZE;
|
|
|
|
//
|
|
// Allocate and build a partial Mdl for the request.
|
|
//
|
|
|
|
Mdl = IoAllocateMdl( ThisIoRun->TransferVirtualAddress,
|
|
RawByteCount,
|
|
FALSE,
|
|
FALSE,
|
|
Irp );
|
|
|
|
if (Mdl == NULL) {
|
|
|
|
IrpContext->Irp->IoStatus.Information = 0;
|
|
CdRaiseStatus( IrpContext, STATUS_INSUFFICIENT_RESOURCES );
|
|
}
|
|
|
|
IoBuildPartialMdl( ThisIoRun->TransferMdl,
|
|
Mdl,
|
|
ThisIoRun->TransferVirtualAddress,
|
|
RawByteCount);
|
|
//
|
|
// Get the first IRP stack location in the associated Irp
|
|
//
|
|
|
|
IoSetNextIrpStackLocation( Irp );
|
|
IrpSp = IoGetCurrentIrpStackLocation( Irp );
|
|
|
|
//
|
|
// Setup the Stack location to describe our read (using cooked values)
|
|
// These values won't be used for the raw read in any case.
|
|
//
|
|
|
|
IrpSp->MajorFunction = IRP_MJ_READ;
|
|
IrpSp->Parameters.Read.Length = ThisIoRun->DiskByteCount;
|
|
IrpSp->Parameters.Read.ByteOffset.QuadPart = ThisIoRun->DiskOffset;
|
|
|
|
//
|
|
// Set up the completion routine address in our stack frame.
|
|
//
|
|
|
|
IoSetCompletionRoutine( Irp,
|
|
CdMultiSyncCompletionRoutine,
|
|
IrpContext->IoContext,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE );
|
|
|
|
//
|
|
// Setup the next IRP stack location in the associated Irp for the disk
|
|
// driver beneath us.
|
|
//
|
|
|
|
IrpSp = IoGetNextIrpStackLocation( Irp );
|
|
|
|
//
|
|
// Setup the stack location to do a read of raw sectors at this location.
|
|
// Note that the storage stack always reads multiples of whole XA sectors.
|
|
//
|
|
|
|
ThisRawRead->DiskOffset.QuadPart = ThisIoRun->DiskOffset;
|
|
ThisRawRead->SectorCount = ThisIoRun->DiskByteCount >> SECTOR_SHIFT;
|
|
ThisRawRead->TrackMode = TrackMode;
|
|
|
|
IrpSp->MajorFunction = IRP_MJ_DEVICE_CONTROL;
|
|
|
|
IrpSp->Parameters.DeviceIoControl.OutputBufferLength = ThisRawRead->SectorCount * RAW_SECTOR_SIZE;
|
|
Irp->UserBuffer = ThisIoRun->TransferVirtualAddress;
|
|
|
|
IrpSp->Parameters.DeviceIoControl.InputBufferLength = sizeof( RAW_READ_INFO );
|
|
IrpSp->Parameters.DeviceIoControl.Type3InputBuffer = ThisRawRead;
|
|
|
|
IrpSp->Parameters.DeviceIoControl.IoControlCode = IOCTL_CDROM_RAW_READ;
|
|
}
|
|
|
|
//
|
|
// We only need to set the associated IRP count in the master irp to
|
|
// make it a master IRP. But we set the count to one more than our
|
|
// caller requested, because we do not want the I/O system to complete
|
|
// the I/O. We also set our own count.
|
|
//
|
|
|
|
IrpContext->IoContext->IrpCount = RunCount;
|
|
IrpContext->IoContext->MasterIrp = MasterIrp;
|
|
|
|
//
|
|
// We set the count in the master Irp to 1 since typically we
|
|
// will clean up the associated irps ourselves. Setting this to one
|
|
// means completing the last associated Irp with SUCCESS (in the async
|
|
// case) will complete the master irp.
|
|
//
|
|
|
|
MasterIrp->AssociatedIrp.IrpCount = 1;
|
|
|
|
//
|
|
// Now that all the dangerous work is done, issue the Io requests
|
|
//
|
|
|
|
for (UnwindRunCount = 0;
|
|
UnwindRunCount < RunCount;
|
|
UnwindRunCount++) {
|
|
|
|
Irp = IoRuns[UnwindRunCount].SavedIrp;
|
|
IoRuns[UnwindRunCount].SavedIrp = NULL;
|
|
|
|
//
|
|
//
|
|
// If IoCallDriver returns an error, it has completed the Irp
|
|
// and the error will be caught by our completion routines
|
|
// and dealt with as a normal IO error.
|
|
//
|
|
|
|
(VOID) IoCallDriver( IrpContext->Vcb->TargetDeviceObject, Irp );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
_Requires_lock_held_(_Global_critical_region_)
|
|
VOID
|
|
CdSingleAsync (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PIO_RUN Run,
|
|
_In_ PFCB Fcb
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine reads one or more contiguous sectors from a device
|
|
asynchronously, and is used if there is only one read necessary to
|
|
complete the IRP. It implements the read by simply filling
|
|
in the next stack frame in the Irp, and passing it on. The transfer
|
|
occurs to the single buffer originally specified in the user request.
|
|
|
|
Arguments:
|
|
|
|
ByteOffset - Supplies the starting Logical Byte Offset to begin reading from
|
|
|
|
ByteCount - Supplies the number of bytes to read from the device
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PIO_STACK_LOCATION IrpSp;
|
|
PIO_COMPLETION_ROUTINE CompletionRoutine;
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// For directories, look in the sector cache,
|
|
//
|
|
|
|
if ((SafeNodeType( Fcb) == CDFS_NTC_FCB_INDEX) &&
|
|
(NULL != Fcb->Vcb->SectorCacheBuffer) &&
|
|
(VcbMounted == IrpContext->Vcb->VcbCondition)) {
|
|
|
|
if (CdReadDirDataThroughCache( IrpContext, Run )) {
|
|
|
|
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
|
|
|
|
IrpContext->Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
KeSetEvent( &IrpContext->IoContext->SyncEvent, 0, FALSE );
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set up things according to whether this is truely async.
|
|
//
|
|
|
|
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
|
|
|
|
CompletionRoutine = CdSingleSyncCompletionRoutine;
|
|
|
|
} else {
|
|
|
|
CompletionRoutine = CdSingleAsyncCompletionRoutine;
|
|
|
|
//
|
|
// If we (FS) acquired locks, transition the lock owners to an object, since
|
|
// when we return this thread could go away before request completion, and
|
|
// the resource package may otherwise try to boost priority, etc.
|
|
//
|
|
|
|
if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_TOP_LEVEL )) {
|
|
|
|
NT_ASSERT( IrpContext->IoContext->ResourceThreadId == (ERESOURCE_THREAD)PsGetCurrentThread() );
|
|
|
|
IrpContext->IoContext->ResourceThreadId = ((ULONG_PTR)IrpContext->IoContext) | 3;
|
|
|
|
ExSetResourceOwnerPointer( IrpContext->IoContext->Resource,
|
|
(PVOID)IrpContext->IoContext->ResourceThreadId );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set up the completion routine address in our stack frame.
|
|
//
|
|
|
|
IoSetCompletionRoutine( IrpContext->Irp,
|
|
CompletionRoutine,
|
|
IrpContext->IoContext,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE );
|
|
|
|
//
|
|
// Setup the next IRP stack location in the associated Irp for the disk
|
|
// driver beneath us.
|
|
//
|
|
|
|
IrpSp = IoGetNextIrpStackLocation( IrpContext->Irp );
|
|
|
|
//
|
|
// Setup the Stack location to do a read from the disk driver.
|
|
//
|
|
|
|
IrpSp->MajorFunction = IrpContext->MajorFunction;
|
|
IrpSp->Parameters.Read.Length = Run->DiskByteCount;
|
|
IrpSp->Parameters.Read.ByteOffset.QuadPart = Run->DiskOffset;
|
|
|
|
//
|
|
// Issue the Io request
|
|
//
|
|
|
|
//
|
|
// If IoCallDriver returns an error, it has completed the Irp
|
|
// and the error will be caught by our completion routines
|
|
// and dealt with as a normal IO error.
|
|
//
|
|
|
|
(VOID)IoCallDriver( IrpContext->Vcb->TargetDeviceObject, IrpContext->Irp );
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
VOID
|
|
CdWaitSync (
|
|
_In_ PIRP_CONTEXT IrpContext
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine waits for one or more previously started I/O requests
|
|
from the above routines, by simply waiting on the event.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
PAGED_CODE();
|
|
|
|
|
|
(VOID)KeWaitForSingleObject( &IrpContext->IoContext->SyncEvent,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
KeClearEvent( &IrpContext->IoContext->SyncEvent );
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
NTSTATUS
|
|
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
|
|
CdMultiSyncCompletionRoutine (
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PVOID Context
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the completion routine for all synchronous reads
|
|
started via CdMultipleAsynch.
|
|
|
|
The completion routine has has the following responsibilities:
|
|
|
|
If the individual request was completed with an error, then
|
|
this completion routine must see if this is the first error
|
|
and remember the error status in the Context.
|
|
|
|
If the IrpCount goes to 1, then it sets the event in the Context
|
|
parameter to signal the caller that all of the asynch requests
|
|
are done.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the file system device object.
|
|
|
|
Irp - Pointer to the associated Irp which is being completed. (This
|
|
Irp will no longer be accessible after this routine returns.)
|
|
|
|
Context - The context parameter which was specified for all of
|
|
the multiple asynch I/O requests for this MasterIrp.
|
|
|
|
Return Value:
|
|
|
|
The routine returns STATUS_MORE_PROCESSING_REQUIRED so that we can
|
|
immediately complete the Master Irp without being in a race condition
|
|
with the IoCompleteRequest thread trying to decrement the IrpCount in
|
|
the Master Irp.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCD_IO_CONTEXT IoContext = Context;
|
|
_Analysis_assume_(Context != NULL);
|
|
|
|
AssertVerifyDeviceIrp( Irp );
|
|
|
|
//
|
|
// If we got an error (or verify required), remember it in the Irp
|
|
//
|
|
|
|
if (!NT_SUCCESS( Irp->IoStatus.Status )) {
|
|
|
|
InterlockedExchange( &IoContext->Status, Irp->IoStatus.Status );
|
|
IoContext->MasterIrp->IoStatus.Information = 0;
|
|
}
|
|
|
|
//
|
|
// We must do this here since IoCompleteRequest won't get a chance
|
|
// on this associated Irp.
|
|
//
|
|
|
|
IoFreeMdl( Irp->MdlAddress );
|
|
IoFreeIrp( Irp );
|
|
|
|
if (InterlockedDecrement( &IoContext->IrpCount ) == 0) {
|
|
|
|
//
|
|
// Update the Master Irp with any error status from the associated Irps.
|
|
//
|
|
|
|
IoContext->MasterIrp->IoStatus.Status = IoContext->Status;
|
|
KeSetEvent( &IoContext->SyncEvent, 0, FALSE );
|
|
}
|
|
|
|
UNREFERENCED_PARAMETER( DeviceObject );
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
NTSTATUS
|
|
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
|
|
CdMultiAsyncCompletionRoutine (
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PVOID Context
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the completion routine for all asynchronous reads
|
|
started via CdMultipleAsynch.
|
|
|
|
The completion routine has has the following responsibilities:
|
|
|
|
If the individual request was completed with an error, then
|
|
this completion routine must see if this is the first error
|
|
and remember the error status in the Context.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the file system device object.
|
|
|
|
Irp - Pointer to the associated Irp which is being completed. (This
|
|
Irp will no longer be accessible after this routine returns.)
|
|
|
|
Context - The context parameter which was specified for all of
|
|
the multiple asynch I/O requests for this MasterIrp.
|
|
|
|
Return Value:
|
|
|
|
Currently always returns STATUS_SUCCESS.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCD_IO_CONTEXT IoContext = Context;
|
|
_Analysis_assume_(Context != NULL);
|
|
AssertVerifyDeviceIrp( Irp );
|
|
|
|
UNREFERENCED_PARAMETER( DeviceObject );
|
|
|
|
//
|
|
// If we got an error (or verify required), remember it in the Irp
|
|
//
|
|
|
|
if (!NT_SUCCESS( Irp->IoStatus.Status )) {
|
|
|
|
InterlockedExchange( &IoContext->Status, Irp->IoStatus.Status );
|
|
}
|
|
|
|
//
|
|
// Decrement IrpCount and see if it goes to zero.
|
|
//
|
|
|
|
if (InterlockedDecrement( &IoContext->IrpCount ) == 0) {
|
|
|
|
//
|
|
// Mark the master Irp pending
|
|
//
|
|
|
|
IoMarkIrpPending( IoContext->MasterIrp );
|
|
|
|
//
|
|
// Update the Master Irp with any error status from the associated Irps.
|
|
//
|
|
|
|
IoContext->MasterIrp->IoStatus.Status = IoContext->Status;
|
|
|
|
//
|
|
// Update the information field with the correct value.
|
|
//
|
|
|
|
IoContext->MasterIrp->IoStatus.Information = 0;
|
|
|
|
if (NT_SUCCESS( IoContext->MasterIrp->IoStatus.Status )) {
|
|
|
|
IoContext->MasterIrp->IoStatus.Information = IoContext->RequestedByteCount;
|
|
}
|
|
|
|
//
|
|
// Now release the resource
|
|
//
|
|
|
|
_Analysis_assume_lock_held_(*IoContext->Resource);
|
|
ExReleaseResourceForThreadLite( IoContext->Resource, IoContext->ResourceThreadId );
|
|
|
|
//
|
|
// and finally, free the context record.
|
|
//
|
|
|
|
CdFreeIoContext( IoContext );
|
|
|
|
//
|
|
// Return success in this case.
|
|
//
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} else {
|
|
|
|
//
|
|
// We need to cleanup the associated Irp and its Mdl.
|
|
//
|
|
|
|
IoFreeMdl( Irp->MdlAddress );
|
|
IoFreeIrp( Irp );
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
NTSTATUS
|
|
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
|
|
CdSingleSyncCompletionRoutine (
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PVOID Context
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the completion routine for all reads started via CdSingleAsynch.
|
|
|
|
The completion routine has has the following responsibilities:
|
|
|
|
It sets the event in the Context parameter to signal the caller
|
|
that all of the asynch requests are done.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the file system device object.
|
|
|
|
Irp - Pointer to the Irp for this request. (This Irp will no longer
|
|
be accessible after this routine returns.)
|
|
|
|
Context - The context parameter which was specified in the call to
|
|
CdSingleAsynch.
|
|
|
|
Return Value:
|
|
|
|
The routine returns STATUS_MORE_PROCESSING_REQUIRED so that we can
|
|
immediately complete the Master Irp without being in a race condition
|
|
with the IoCompleteRequest thread trying to decrement the IrpCount in
|
|
the Master Irp.
|
|
|
|
--*/
|
|
|
|
{
|
|
_Analysis_assume_(Context != NULL);
|
|
|
|
UNREFERENCED_PARAMETER( DeviceObject );
|
|
|
|
AssertVerifyDeviceIrp( Irp );
|
|
|
|
//
|
|
// Store the correct information field into the Irp.
|
|
//
|
|
|
|
if (!NT_SUCCESS( Irp->IoStatus.Status )) {
|
|
|
|
Irp->IoStatus.Information = 0;
|
|
}
|
|
|
|
KeSetEvent( &((PCD_IO_CONTEXT)Context)->SyncEvent, 0, FALSE );
|
|
|
|
return STATUS_MORE_PROCESSING_REQUIRED;
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
NTSTATUS
|
|
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
|
|
CdSingleAsyncCompletionRoutine (
|
|
PDEVICE_OBJECT DeviceObject,
|
|
PIRP Irp,
|
|
PVOID Context
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the completion routine for all asynchronous reads
|
|
started via CdSingleAsynch.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Pointer to the file system device object.
|
|
|
|
Irp - Pointer to the Irp for this request. (This Irp will no longer
|
|
be accessible after this routine returns.)
|
|
|
|
Context - The context parameter which was specified in the call to
|
|
CdSingleAsynch.
|
|
|
|
Return Value:
|
|
|
|
Currently always returns STATUS_SUCCESS.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCD_IO_CONTEXT IoContext = Context;
|
|
|
|
UNREFERENCED_PARAMETER( DeviceObject );
|
|
|
|
_Analysis_assume_(IoContext != NULL);
|
|
AssertVerifyDeviceIrp( Irp );
|
|
|
|
//
|
|
// Update the information field with the correct value for bytes read.
|
|
//
|
|
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
if (NT_SUCCESS( Irp->IoStatus.Status )) {
|
|
|
|
Irp->IoStatus.Information = IoContext->RequestedByteCount;
|
|
}
|
|
|
|
//
|
|
// Mark the Irp pending
|
|
//
|
|
|
|
IoMarkIrpPending( Irp );
|
|
|
|
//
|
|
// Now release the resource
|
|
//
|
|
|
|
_Analysis_assume_lock_held_(*IoContext->Resource);
|
|
ExReleaseResourceForThreadLite( IoContext->Resource, IoContext->ResourceThreadId );
|
|
|
|
//
|
|
// and finally, free the context record.
|
|
//
|
|
|
|
CdFreeIoContext( IoContext );
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Local support routine
|
|
//
|
|
|
|
_When_(SafeNodeType(Fcb) != CDFS_NTC_FCB_PATH_TABLE && StartingOffset == 0, _At_(ByteCount, _In_range_(>=, CdAudioDirentSize + sizeof(RAW_DIRENT))))
|
|
_When_(SafeNodeType(Fcb) != CDFS_NTC_FCB_PATH_TABLE && StartingOffset != 0, _At_(ByteCount, _In_range_(>=, CdAudioDirentSize + SECTOR_SIZE)))
|
|
VOID
|
|
CdReadAudioSystemFile (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_In_ PFCB Fcb,
|
|
_In_ LONGLONG StartingOffset,
|
|
_In_ _In_range_(>=, CdAudioDirentSize) ULONG ByteCount,
|
|
_Out_writes_bytes_(ByteCount) PVOID SystemBuffer
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called to read the pseudo root directory and path
|
|
table for a music disk. We build the individual elements on the
|
|
stack and copy into the cache buffer.
|
|
|
|
Arguments:
|
|
|
|
Fcb - Fcb representing the file to read.
|
|
|
|
StartingOffset - Logical offset in the file to read from.
|
|
|
|
ByteCount - Number of bytes to read.
|
|
|
|
SystemBuffer - Pointer to buffer to fill in. This will always be page
|
|
aligned.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PRAW_PATH_ISO RawPath;
|
|
PRAW_DIRENT RawDirent;
|
|
|
|
ULONG CurrentTrack;
|
|
ULONG SectorOffset;
|
|
ULONG EntryCount;
|
|
UCHAR TrackOnes;
|
|
UCHAR TrackTens;
|
|
PTRACK_DATA ThisTrack;
|
|
|
|
LONGLONG CurrentOffset;
|
|
|
|
PVOID CurrentSector;
|
|
|
|
PSYSTEM_USE_XA SystemUse;
|
|
|
|
ULONG BytesToCopy;
|
|
|
|
UCHAR LocalBuffer[FIELD_OFFSET( RAW_DIRENT, FileId ) + 12];
|
|
|
|
PAGED_CODE();
|
|
|
|
//
|
|
// If this is the path table then we just need a single entry.
|
|
//
|
|
|
|
if (SafeNodeType( Fcb ) == CDFS_NTC_FCB_PATH_TABLE) {
|
|
|
|
//
|
|
// Sanity check that the offset is zero.
|
|
//
|
|
|
|
NT_ASSERT( StartingOffset == 0 );
|
|
|
|
//
|
|
// Store a pseudo path entry in our local buffer.
|
|
//
|
|
|
|
RawPath = (PRAW_PATH_ISO) LocalBuffer;
|
|
|
|
RtlZeroMemory( RawPath, sizeof( LocalBuffer ));
|
|
|
|
RawPath->DirIdLen = 1;
|
|
RawPath->ParentNum = 1;
|
|
RawPath->DirId[0] = '\0';
|
|
|
|
//
|
|
// Now copy to the user's buffer.
|
|
//
|
|
|
|
BytesToCopy = FIELD_OFFSET( RAW_PATH_ISO, DirId ) + 2;
|
|
|
|
if (BytesToCopy > ByteCount) {
|
|
|
|
BytesToCopy = ByteCount;
|
|
}
|
|
|
|
RtlCopyMemory( SystemBuffer,
|
|
RawPath,
|
|
BytesToCopy );
|
|
|
|
//
|
|
// We need to deal with the multiple sector case for the root directory.
|
|
//
|
|
|
|
} else {
|
|
|
|
//
|
|
// Initialize the first track to return to our caller.
|
|
//
|
|
|
|
CurrentTrack = 0;
|
|
|
|
//
|
|
// If the offset is zero then store the entries for the self and parent
|
|
// entries.
|
|
//
|
|
|
|
if (StartingOffset == 0) {
|
|
|
|
RawDirent = SystemBuffer;
|
|
|
|
//
|
|
// Clear all of the fields initially.
|
|
//
|
|
|
|
RtlZeroMemory( RawDirent, FIELD_OFFSET( RAW_DIRENT, FileId ));
|
|
|
|
//
|
|
// Now fill in the interesting fields.
|
|
//
|
|
|
|
RawDirent->DirLen = FIELD_OFFSET( RAW_DIRENT, FileId ) + 1;
|
|
RawDirent->FileIdLen = 1;
|
|
RawDirent->FileId[0] = '\0';
|
|
SetFlag( RawDirent->FlagsISO, CD_ATTRIBUTE_DIRECTORY );
|
|
|
|
//
|
|
// Set the time stamp to be Jan 1, 1995
|
|
//
|
|
|
|
RawDirent->RecordTime[0] = 95;
|
|
RawDirent->RecordTime[1] = 1;
|
|
RawDirent->RecordTime[2] = 1;
|
|
|
|
SectorOffset = RawDirent->DirLen;
|
|
|
|
RawDirent = Add2Ptr( RawDirent, SectorOffset, PRAW_DIRENT );
|
|
|
|
//
|
|
// Clear all of the fields initially.
|
|
//
|
|
|
|
RtlZeroMemory( RawDirent, FIELD_OFFSET( RAW_DIRENT, FileId ));
|
|
|
|
//
|
|
// Now fill in the interesting fields.
|
|
//
|
|
|
|
RawDirent->DirLen = FIELD_OFFSET( RAW_DIRENT, FileId ) + 1;
|
|
RawDirent->FileIdLen = 1;
|
|
RawDirent->FileId[0] = '\1';
|
|
SetFlag( RawDirent->FlagsISO, CD_ATTRIBUTE_DIRECTORY );
|
|
|
|
//
|
|
// Set the time stamp to be Jan 1, 1995
|
|
//
|
|
|
|
RawDirent->RecordTime[0] = 95;
|
|
RawDirent->RecordTime[1] = 1;
|
|
RawDirent->RecordTime[2] = 1;
|
|
|
|
SectorOffset += RawDirent->DirLen;
|
|
EntryCount = 2;
|
|
|
|
//
|
|
// Otherwise compute the starting track to write to the buffer.
|
|
//
|
|
|
|
} else {
|
|
|
|
//
|
|
// Count the tracks in each preceding sector.
|
|
//
|
|
|
|
CurrentOffset = 0;
|
|
|
|
do {
|
|
|
|
CurrentTrack += CdAudioDirentsPerSector;
|
|
CurrentOffset += SECTOR_SIZE;
|
|
|
|
} while (CurrentOffset < StartingOffset);
|
|
|
|
//
|
|
// Bias the track count to reflect the two default entries.
|
|
//
|
|
|
|
CurrentTrack -= 2;
|
|
|
|
SectorOffset = 0;
|
|
EntryCount = 0;
|
|
}
|
|
|
|
//
|
|
// We now know the first track to return as well as where we are in
|
|
// the current sector. We will walk through sector by sector adding
|
|
// the entries for the separate tracks in the TOC. We will zero
|
|
// any sectors or partial sectors without data.
|
|
//
|
|
|
|
CurrentSector = SystemBuffer;
|
|
BytesToCopy = SECTOR_SIZE;
|
|
|
|
//
|
|
// Loop for each sector.
|
|
//
|
|
|
|
do {
|
|
|
|
//
|
|
// Add entries until we reach our threshold for each sector.
|
|
//
|
|
|
|
do {
|
|
|
|
//
|
|
// If we are beyond the entries in the TOC then exit.
|
|
//
|
|
|
|
if (CurrentTrack >= IrpContext->Vcb->TrackCount) {
|
|
|
|
break;
|
|
}
|
|
|
|
ThisTrack = &IrpContext->Vcb->CdromToc->TrackData[CurrentTrack];
|
|
|
|
//
|
|
// Point to the current position in the buffer.
|
|
//
|
|
|
|
RawDirent = Add2Ptr( CurrentSector, SectorOffset, PRAW_DIRENT );
|
|
|
|
//
|
|
// Clear all of the fields initially.
|
|
//
|
|
|
|
RtlZeroMemory( RawDirent, CdAudioDirentSize );
|
|
|
|
//
|
|
// Now fill in the interesting fields.
|
|
//
|
|
|
|
RawDirent->DirLen = (UCHAR) CdAudioDirentSize;
|
|
RawDirent->FileIdLen = CdAudioFileNameLength;
|
|
|
|
RtlCopyMemory( RawDirent->FileId,
|
|
CdAudioFileName,
|
|
CdAudioFileNameLength );
|
|
|
|
//
|
|
// Set the time stamp to be Jan 1, 1995 00:00
|
|
//
|
|
|
|
RawDirent->RecordTime[0] = 95;
|
|
RawDirent->RecordTime[1] = 1;
|
|
RawDirent->RecordTime[2] = 1;
|
|
|
|
//
|
|
// Put the track number into the file name.
|
|
//
|
|
|
|
TrackTens = TrackOnes = ThisTrack->TrackNumber;
|
|
|
|
TrackOnes = (TrackOnes % 10) + '0';
|
|
|
|
TrackTens /= 10;
|
|
TrackTens = (TrackTens % 10) + '0';
|
|
|
|
RawDirent->FileId[AUDIO_NAME_TENS_OFFSET] = TrackTens;
|
|
RawDirent->FileId[AUDIO_NAME_ONES_OFFSET] = TrackOnes;
|
|
|
|
SystemUse = Add2Ptr( RawDirent, CdAudioSystemUseOffset, PSYSTEM_USE_XA );
|
|
|
|
SystemUse->Attributes = SYSTEM_USE_XA_DA;
|
|
SystemUse->Signature = SYSTEM_XA_SIGNATURE;
|
|
|
|
//
|
|
// Store the track number as the file number.
|
|
//
|
|
|
|
SystemUse->FileNumber = (UCHAR) CurrentTrack;
|
|
|
|
EntryCount += 1;
|
|
SectorOffset += CdAudioDirentSize;
|
|
CurrentTrack += 1;
|
|
|
|
} while (EntryCount < CdAudioDirentsPerSector);
|
|
|
|
//
|
|
// Zero the remaining portion of this buffer.
|
|
//
|
|
|
|
RtlZeroMemory( Add2Ptr( CurrentSector, SectorOffset, PVOID ),
|
|
SECTOR_SIZE - SectorOffset );
|
|
|
|
//
|
|
// Prepare for the next sector.
|
|
//
|
|
|
|
EntryCount = 0;
|
|
BytesToCopy += SECTOR_SIZE;
|
|
SectorOffset = 0;
|
|
CurrentSector = Add2Ptr( CurrentSector, SECTOR_SIZE, PVOID );
|
|
|
|
} while (BytesToCopy <= ByteCount);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
CdHijackIrpAndFlushDevice (
|
|
_In_ PIRP_CONTEXT IrpContext,
|
|
_Inout_ PIRP Irp,
|
|
_In_ PDEVICE_OBJECT TargetDeviceObject
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine is called when we need to send a flush to a device but
|
|
we don't have a flush Irp. What this routine does is make a copy
|
|
of its current Irp stack location, but changes the Irp Major code
|
|
to a IRP_MJ_FLUSH_BUFFERS amd then send it down, but cut it off at
|
|
the knees in the completion routine, fix it up and return to the
|
|
user as if nothing had happened.
|
|
|
|
Arguments:
|
|
|
|
Irp - The Irp to hijack
|
|
|
|
TargetDeviceObject - The device to send the request to.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The Status from the flush in case anybody cares.
|
|
|
|
--*/
|
|
|
|
{
|
|
KEVENT Event;
|
|
NTSTATUS Status;
|
|
PIO_STACK_LOCATION NextIrpSp;
|
|
|
|
PAGED_CODE();
|
|
|
|
UNREFERENCED_PARAMETER( IrpContext );
|
|
|
|
//
|
|
// Get the next stack location, and copy over the stack location
|
|
//
|
|
|
|
NextIrpSp = IoGetNextIrpStackLocation( Irp );
|
|
|
|
*NextIrpSp = *IoGetCurrentIrpStackLocation( Irp );
|
|
|
|
NextIrpSp->MajorFunction = IRP_MJ_FLUSH_BUFFERS;
|
|
NextIrpSp->MinorFunction = 0;
|
|
|
|
//
|
|
// Set up the completion routine
|
|
//
|
|
|
|
KeInitializeEvent( &Event, NotificationEvent, FALSE );
|
|
|
|
IoSetCompletionRoutine( Irp,
|
|
CdSyncCompletionRoutine,
|
|
&Event,
|
|
TRUE,
|
|
TRUE,
|
|
TRUE );
|
|
|
|
//
|
|
// Send the request.
|
|
//
|
|
|
|
Status = IoCallDriver( TargetDeviceObject, Irp );
|
|
|
|
if (Status == STATUS_PENDING) {
|
|
|
|
(VOID)KeWaitForSingleObject( &Event, Executive, KernelMode, FALSE, NULL );
|
|
|
|
Status = Irp->IoStatus.Status;
|
|
}
|
|
|
|
//
|
|
// If the driver doesn't support flushes, return SUCCESS.
|
|
//
|
|
|
|
if (Status == STATUS_INVALID_DEVICE_REQUEST) {
|
|
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
Irp->IoStatus.Status = 0;
|
|
Irp->IoStatus.Information = 0;
|
|
|
|
return Status;
|
|
}
|
|
|
|
|