deviosup.c File Reference

#include "cdprocs.h"

Include dependency graph for deviosup.c:

Go to the source code of this file.

Classes
struct	_IO_RUN

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_DEVIOSUP)
#define	MAX_PARALLEL_IOS   5

Typedefs
typedef struct _IO_RUN	IO_RUN
typedef IO_RUN *	PIO_RUN

Functions
	_Requires_lock_held_ (_Global_critical_region_)
__inline TRACK_MODE_TYPE	CdFileTrackMode (_In_ PFCB Fcb)
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)
NTSTATUS	CdCreateUserMdl (_In_ PIRP_CONTEXT IrpContext, _In_ ULONG BufferLength, _In_ BOOLEAN RaiseOnError, _In_ LOCK_OPERATION Operation)
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)
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)
BOOLEAN	CdFinishBuffers (_In_ PIRP_CONTEXT IrpContext, _Inout_ PIO_RUN IoRuns, _In_ ULONG RunCount, _In_ BOOLEAN FinalCleanup, _In_ BOOLEAN SaveXABuffer)
NTSTATUS NTAPI	CdSyncCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Contxt)
VOID	CdMultipleXAAsync (_In_ PIRP_CONTEXT IrpContext, _In_ ULONG RunCount, _Inout_ PIO_RUN IoRuns, _In_ PRAW_READ_INFO RawReads, _In_ TRACK_MODE_TYPE TrackMode)
VOID	CdWaitSync (_In_ PIRP_CONTEXT IrpContext)
NTSTATUS NTAPI	CdMultiSyncCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS NTAPI	CdMultiAsyncCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS NTAPI	CdSingleSyncCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS NTAPI	CdSingleAsyncCompletionRoutine (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
	_When_ (SafeNodeType(Fcb) !=CDFS_NTC_FCB_PATH_TABLE &&StartingOffset==0, _At_(ByteCount, _In_range_(>=, CdAudioDirentSize+sizeof(RAW_DIRENT))))
NTSTATUS	CdHijackIrpAndFlushDevice (_In_ PIRP_CONTEXT IrpContext, _Inout_ PIRP Irp, _In_ PDEVICE_OBJECT TargetDeviceObject)

Variables
IO_COMPLETION_ROUTINE	CdSyncCompletionRoutine

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_DEVIOSUP)

Definition at line 22 of file deviosup.c.

MAX_PARALLEL_IOS

#define MAX_PARALLEL_IOS   5

Definition at line 96 of file deviosup.c.

Typedef Documentation

IO_RUN

typedef struct _IO_RUN IO_RUN

PIO_RUN

typedef IO_RUN* PIO_RUN

Definition at line 94 of file deviosup.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 102 of file deviosup.c.

{
    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
}

_When_()

_When_	(	SafeNodeType(Fcb) !	= CDFS_NTC_FCB_PATH_TABLE && StartingOffset == 0,
		_At_(ByteCount, _In_range_(>=, CdAudioDirentSize+sizeof(RAW_DIRENT)))
	)

Definition at line 3785 of file deviosup.c.

{
    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;
}

CdCreateUserMdl()

NTSTATUS CdCreateUserMdl	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ ULONG	BufferLength,
		_In_ BOOLEAN	RaiseOnError,
		_In_ LOCK_OPERATION	Operation
	)

Definition at line 1221 of file deviosup.c.

{
    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;
}

CdFileTrackMode()

__inline TRACK_MODE_TYPE CdFileTrackMode

(

_In_ PFCB

Fcb

)

Definition at line 258 of file deviosup.c.

{
    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;
}

CdFinishBuffers()

BOOLEAN CdFinishBuffers	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIO_RUN	IoRuns,
		_In_ ULONG	RunCount,
		_In_ BOOLEAN	FinalCleanup,
		_In_ BOOLEAN	SaveXABuffer
	)

Definition at line 2219 of file deviosup.c.

{
    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;
}

CdHijackIrpAndFlushDevice()

NTSTATUS CdHijackIrpAndFlushDevice	(	_In_ PIRP_CONTEXT	IrpContext,
		_Inout_ PIRP	Irp,
		_In_ PDEVICE_OBJECT	TargetDeviceObject
	)

Definition at line 4105 of file deviosup.c.

{
    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;
}

Referenced by _Requires_lock_held_().

CdMultiAsyncCompletionRoutine()

NTSTATUS NTAPI CdMultiAsyncCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 3526 of file deviosup.c.

{
    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;
    }
 
}

CdMultipleXAAsync()

VOID CdMultipleXAAsync	(	_In_ PIRP_CONTEXT	IrpContext,
		_In_ ULONG	RunCount,
		_Inout_ PIO_RUN	IoRuns,
		_In_ PRAW_READ_INFO	RawReads,
		_In_ TRACK_MODE_TYPE	TrackMode
	)

Definition at line 3044 of file deviosup.c.

{
    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;
}

CdMultiSyncCompletionRoutine()

NTSTATUS NTAPI CdMultiSyncCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 3438 of file deviosup.c.

{
    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;
}

Referenced by CdMultipleXAAsync().

CdPerformDevIoCtrl()

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
	)

Definition at line 1446 of file deviosup.c.

{
    PAGED_CODE();
 
    return CdPerformDevIoCtrlEx( IrpContext,
                                 IoControlCode,
                                 Device,
                                 NULL,
                                 0,
                                 OutputBuffer,
                                 OutputBufferLength,
                                 InternalDeviceIoControl,
                                 OverrideVerify,
                                 Iosb);
}

Referenced by _Success_(), and CdVerifyVcb().

CdPerformDevIoCtrlEx()

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
	)

Definition at line 1329 of file deviosup.c.

{
    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;
}

Referenced by CdPerformDevIoCtrl(), and CdProcessToc().

CdReadSectors()

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
	)

Definition at line 1080 of file deviosup.c.

{
    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;
    }
}

Referenced by _Success_(), and CdFindActiveVolDescriptor().

CdSingleAsyncCompletionRoutine()

NTSTATUS NTAPI CdSingleAsyncCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 3710 of file deviosup.c.

{
    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;
 
}

CdSingleSyncCompletionRoutine()

NTSTATUS NTAPI CdSingleSyncCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 3646 of file deviosup.c.

{
    _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;
}

CdSyncCompletionRoutine()

NTSTATUS NTAPI CdSyncCompletionRoutine	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Contxt
	)

Definition at line 2392 of file deviosup.c.

{
    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;
}

CdWaitSync()

VOID CdWaitSync

(

_In_ PIRP_CONTEXT

IrpContext

)

Definition at line 3399 of file deviosup.c.

{
    PAGED_CODE();
 
 
    (VOID)KeWaitForSingleObject( &IrpContext->IoContext->SyncEvent,
                           Executive,
                           KernelMode,
                           FALSE,
                           NULL );
 
    KeClearEvent( &IrpContext->IoContext->SyncEvent );
}

Variable Documentation

CdSyncCompletionRoutine

IO_COMPLETION_ROUTINE CdSyncCompletionRoutine

Definition at line 2388 of file deviosup.c.

Referenced by CdHijackIrpAndFlushDevice().