pnp.c File Reference

#include "cdprocs.h"

Include dependency graph for pnp.c:

Go to the source code of this file.

Macros
#define	BugCheckFileId   (CDFS_BUG_CHECK_PNP)

Functions
	_Requires_lock_held_ (_Global_critical_region_)
NTSTATUS NTAPI	CdPnpCompletionRoutine (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Contxt)

Macro Definition Documentation

BugCheckFileId

#define BugCheckFileId   (CDFS_BUG_CHECK_PNP)

Definition at line 23 of file pnp.c.

Function Documentation

_Requires_lock_held_()

_Requires_lock_held_

(

_Global_critical_region_

)

Definition at line 25 of file pnp.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    BOOLEAN PassThrough = FALSE;
 
    PIO_STACK_LOCATION IrpSp;
 
    PVOLUME_DEVICE_OBJECT OurDeviceObject;
    PVCB Vcb;
 
    PAGED_CODE();
 
    // Global lock object is acquired based on internal book-keeping
    _Analysis_suppress_lock_checking_(CdData.DataResource);
 
    //
    //  Get the current Irp stack location.
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    //
    //  Find our Vcb.  This is tricky since we have no file object in the Irp.
    //
 
    OurDeviceObject = (PVOLUME_DEVICE_OBJECT) IrpSp->DeviceObject;
 
    //
    //  IO holds a handle reference on our VDO and holds the device lock, which
    //  syncs us against mounts/verifies.  However we hold no reference on the
    //  volume, which may already have been torn down (and the Vpb freed), for
    //  example by a force dismount. Check for this condition. We must hold this
    //  lock until the pnp worker functions take additional locks/refs on the Vcb.
    //
 
    CdAcquireCdData( IrpContext);
 
    //
    //  Make sure this device object really is big enough to be a volume device
    //  object.  If it isn't, we need to get out before we try to reference some
    //  field that takes us past the end of an ordinary device object.
    //
 
#ifdef _MSC_VER
#pragma prefast(suppress: 28175, "this is a filesystem driver, touching the size member is allowed")
#endif
    if (OurDeviceObject->DeviceObject.Size != sizeof(VOLUME_DEVICE_OBJECT) ||
        NodeType( &OurDeviceObject->Vcb ) != CDFS_NTC_VCB) {
 
        //
        //  We were called with something we don't understand.
        //
 
        Status = STATUS_INVALID_PARAMETER;
        CdReleaseCdData( IrpContext);
        CdCompleteRequest( IrpContext, Irp, Status );
        return Status;
    }
 
    //
    //  Force all PnP operations to be synchronous.
    //
 
    SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
 
    Vcb = &OurDeviceObject->Vcb;
 
    //
    //  Check that the Vcb hasn't already been deleted.  If so,  just pass the
    //  request through to the driver below,  we don't need to do anything.
    //
 
    if (NULL == Vcb->Vpb) {
 
        PassThrough = TRUE;
    }
    else {
 
        //
        //  Case on the minor code.
        //
 
        switch ( IrpSp->MinorFunction ) {
 
            case IRP_MN_QUERY_REMOVE_DEVICE:
 
                Status = CdPnpQueryRemove( IrpContext, Irp, Vcb );
                break;
 
            case IRP_MN_SURPRISE_REMOVAL:
 
                Status = CdPnpSurpriseRemove( IrpContext, Irp, Vcb );
                break;
 
            case IRP_MN_REMOVE_DEVICE:
 
                Status = CdPnpRemove( IrpContext, Irp, Vcb );
                break;
 
            case IRP_MN_CANCEL_REMOVE_DEVICE:
 
                Status = CdPnpCancelRemove( IrpContext, Irp, Vcb );
                break;
 
            default:
 
                PassThrough = TRUE;
                break;
        }
    }
 
    if (PassThrough) {
 
        CdReleaseCdData( IrpContext);
 
        //
        //  Just pass the IRP on.  As we do not need to be in the
        //  way on return, ellide ourselves out of the stack.
        //
 
        IoSkipCurrentIrpStackLocation( Irp );
 
        Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
 
        //
        //  Cleanup our Irp Context.  The driver has completed the Irp.
        //
 
        CdCompleteRequest( IrpContext, NULL, STATUS_SUCCESS );
    }
 
    return Status;
}

CdPnpCompletionRoutine()

NTSTATUS NTAPI CdPnpCompletionRoutine	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Contxt
	)

Definition at line 819 of file pnp.c.

{
    PKEVENT Event = (PKEVENT) Contxt;
    _Analysis_assume_(Contxt != NULL);
 
    KeSetEvent( Event, 0, FALSE );
 
    return STATUS_MORE_PROCESSING_REQUIRED;
 
    UNREFERENCED_PARAMETER( DeviceObject );
    UNREFERENCED_PARAMETER( Irp );
    UNREFERENCED_PARAMETER( Contxt );
}