create.c File Reference

#include "classp.h"
#include "debug.h"

Include dependency graph for create.c:

Go to the source code of this file.

Macros
#define	CLASS_INIT_GUID   0

Functions
VOID	ClasspCleanupDisableMcn (IN PFILE_OBJECT_EXTENSION FsContext)
NTSTATUS NTAPI	ClassCreateClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	ClasspCreateClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID	ClasspCleanupProtectedLocks (IN PFILE_OBJECT_EXTENSION FsContext)
NTSTATUS	ClasspEjectionControl (IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN MEDIA_LOCK_TYPE LockType, IN BOOLEAN Lock)
	_IRQL_requires_max_ (PASSIVE_LEVEL)

Variables
ULONG	BreakOnClose = 0
const PCSZ	LockTypeStrings []

Macro Definition Documentation

CLASS_INIT_GUID

#define CLASS_INIT_GUID   0

Definition at line 24 of file create.c.

Function Documentation

_IRQL_requires_max_()

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 1011 of file create.c.

{
    PAGED_CODE();
    return GetDictionaryEntry(&(CommonExtension->FileObjectDictionary),
                              (ULONGLONG) FileObject);
}

ClassCreateClose()

NTSTATUS NTAPI ClassCreateClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 57 of file create.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    ULONG removeState;
    NTSTATUS status;
 
    PAGED_CODE();
 
    //
    // If we're getting a close request then we know the device object hasn't
    // been completely destroyed.  Let the driver cleanup if necessary.
    //
 
    removeState = ClassAcquireRemoveLock(DeviceObject, Irp);
 
    //
    // Invoke the device-specific routine, if one exists. Otherwise complete
    // with SUCCESS
    //
 
    if((removeState == NO_REMOVE) ||
       IS_CLEANUP_REQUEST(IoGetCurrentIrpStackLocation(Irp)->MajorFunction)) {
 
        status = ClasspCreateClose(DeviceObject, Irp);
 
        if((NT_SUCCESS(status)) &&
           (commonExtension->DevInfo->ClassCreateClose)) {
 
            return commonExtension->DevInfo->ClassCreateClose(DeviceObject, Irp);
        }
 
    } else {
        status = STATUS_DEVICE_DOES_NOT_EXIST;
    }
 
    Irp->IoStatus.Status = status;
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
    return status;
}

Referenced by ClassInitializeDispatchTables().

ClasspCleanupDisableMcn()

VOID ClasspCleanupDisableMcn

(

IN PFILE_OBJECT_EXTENSION

FsContext

)

Definition at line 434 of file create.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension =
        FsContext->DeviceObject->DeviceExtension;
 
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension =
        commonExtension->PartitionZeroExtension;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                "ClasspCleanupDisableMcn called for %p\n",
                FsContext->DeviceObject));
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                "ClasspCleanupDisableMcn - FsContext %p is disabled "
                "%d times\n", FsContext, FsContext->McnDisableCount));
 
    //
    // For each secure lock on this handle decrement the secured lock count
    // for the FDO.  Keep track of the new value.
    //
 
    while(FsContext->McnDisableCount != 0) {
        FsContext->McnDisableCount--;
        ClassEnableMediaChangeDetection(fdoExtension);
    }
 
    return;
}

Referenced by ClasspCreateClose().

ClasspCleanupProtectedLocks()

VOID ClasspCleanupProtectedLocks

(

IN PFILE_OBJECT_EXTENSION

FsContext

)

Definition at line 296 of file create.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension =
        FsContext->DeviceObject->DeviceExtension;
 
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension =
        commonExtension->PartitionZeroExtension;
 
    ULONG newDeviceLockCount = 1;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "ClasspCleanupProtectedLocks called for %p\n",
                FsContext->DeviceObject));
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "ClasspCleanupProtectedLocks - FsContext %p is locked "
                "%d times\n", FsContext, FsContext->LockCount));
 
    NT_ASSERT(BreakOnClose == FALSE);
 
    //
    // Synchronize with ejection and ejection control requests.
    //
 
    KeEnterCriticalRegion();
    (VOID)KeWaitForSingleObject(&(fdoExtension->EjectSynchronizationEvent),
                                UserRequest,
                                KernelMode,
                                FALSE,
                          NULL);
 
    //
    // For each secure lock on this handle decrement the secured lock count
    // for the FDO.  Keep track of the new value.
    //
 
    if (FsContext->LockCount != 0) {
 
        do {
 
            InterlockedDecrement((volatile LONG *)&FsContext->LockCount);
 
            newDeviceLockCount =
                InterlockedDecrement(&fdoExtension->ProtectedLockCount);
 
        } while (FsContext->LockCount > 0);
 
        //
        // If the new lock count has been dropped to zero then issue a lock
        // command to the device.
        //
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCleanupProtectedLocks: FDO secured lock count = %d "
                    "lock count = %d\n",
                    fdoExtension->ProtectedLockCount,
                    fdoExtension->LockCount));
 
        if ((newDeviceLockCount == 0) && (fdoExtension->LockCount == 0)) {
 
            SCSI_REQUEST_BLOCK srb = {0};
            UCHAR srbExBuffer[CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE] = {0};
            PSTORAGE_REQUEST_BLOCK srbEx = (PSTORAGE_REQUEST_BLOCK)srbExBuffer;
            PCDB cdb = NULL;
            NTSTATUS status;
            PSCSI_REQUEST_BLOCK srbPtr;
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "ClasspCleanupProtectedLocks: FDO lock count dropped "
                        "to zero\n"));
 
            if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
#ifdef _MSC_VER
                #pragma prefast(suppress:26015, "InitializeStorageRequestBlock ensures buffer access is bounded")
#endif
                status = InitializeStorageRequestBlock(srbEx,
                                                       STORAGE_ADDRESS_TYPE_BTL8,
                                                       sizeof(srbExBuffer),
                                                       1,
                                                       SrbExDataTypeScsiCdb16);
                if (NT_SUCCESS(status)) {
                    srbEx->TimeOutValue = fdoExtension->TimeOutValue;
                    SrbSetCdbLength(srbEx, 6);
                    cdb = SrbGetCdb(srbEx);
                    srbPtr = (PSCSI_REQUEST_BLOCK)srbEx;
                } else {
                    //
                    // Should not happen. Revert to legacy SRB.
                    //
                    NT_ASSERT(FALSE);
                    srb.TimeOutValue = fdoExtension->TimeOutValue;
                    srb.CdbLength = 6;
                    cdb = (PCDB) &(srb.Cdb);
                    srbPtr = &srb;
                }
 
            } else {
 
                srb.TimeOutValue = fdoExtension->TimeOutValue;
                srb.CdbLength = 6;
                cdb = (PCDB) &(srb.Cdb);
                srbPtr = &srb;
 
            }
 
            cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;
 
            //
            // TRUE - prevent media removal.
            // FALSE - allow media removal.
            //
 
            cdb->MEDIA_REMOVAL.Prevent = FALSE;
 
            status = ClassSendSrbSynchronous(fdoExtension->DeviceObject,
                                             srbPtr,
                                             NULL,
                                             0,
                                             FALSE);
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "ClasspCleanupProtectedLocks: unlock request to drive "
                        "returned status %lx\n", status));
        }
    }
 
    KeSetEvent(&fdoExtension->EjectSynchronizationEvent,
               IO_NO_INCREMENT,
               FALSE);
    KeLeaveCriticalRegion();
    return;
}

Referenced by ClasspCreateClose().

ClasspCreateClose()

NTSTATUS ClasspCreateClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 123 of file create.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
 
    PFILE_OBJECT fileObject = irpStack->FileObject;
 
    NTSTATUS status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
 
    //
    // ISSUE-2000/3/28-henrygab - if lower stack fails create/close, we end up
    // in an inconsistent state.  re-write to verify all args and allocate all
    // required resources, then pass the irp down, then complete the
    // transaction.  this is because we also cannot forward the irp, then fail
    // it after it has succeeded a lower-level driver.
    //
 
    if(irpStack->MajorFunction == IRP_MJ_CREATE) {
 
        PIO_SECURITY_CONTEXT securityContext =
            irpStack->Parameters.Create.SecurityContext;
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCREATEClose: create received for device %p\n",
                    DeviceObject));
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCREATEClose: desired access %lx\n",
                    securityContext->DesiredAccess));
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCREATEClose: file object %p\n",
                    irpStack->FileObject));
 
        NT_ASSERT(BreakOnClose == FALSE);
 
        if(irpStack->FileObject != NULL) {
 
            PFILE_OBJECT_EXTENSION fsContext;
 
            //
            // Allocate our own file object extension for this device object.
            //
 
            status = AllocateDictionaryEntry(
                        &commonExtension->FileObjectDictionary,
                        (ULONGLONG) irpStack->FileObject,
                        sizeof(FILE_OBJECT_EXTENSION),
                        CLASS_TAG_FILE_OBJECT_EXTENSION,
                        (PVOID *)&fsContext);
 
            if(NT_SUCCESS(status)) {
 
                RtlZeroMemory(fsContext,
                              sizeof(FILE_OBJECT_EXTENSION));
 
                fsContext->FileObject = irpStack->FileObject;
                fsContext->DeviceObject = DeviceObject;
            } else if (status == STATUS_OBJECT_NAME_COLLISION) {
                status = STATUS_SUCCESS;
            }
        }
 
    } else {
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCreateCLOSE: close received for device %p\n",
                    DeviceObject));
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCreateCLOSE: file object %p\n",
                    fileObject));
 
        if(irpStack->FileObject != NULL) {
 
            PFILE_OBJECT_EXTENSION fsContext =
                ClassGetFsContext(commonExtension, irpStack->FileObject);
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "ClasspCreateCLOSE: file extension %p\n",
                        fsContext));
 
            if(fsContext != NULL) {
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                            "ClasspCreateCLOSE: extension is ours - "
                            "freeing\n"));
                NT_ASSERT(BreakOnClose == FALSE);
 
                ClasspCleanupProtectedLocks(fsContext);
 
                ClasspCleanupDisableMcn(fsContext);
 
                FreeDictionaryEntry(&(commonExtension->FileObjectDictionary),
                                    fsContext);
            }
        }
    }
 
    //
    // Notify the lower levels about the create or close operation - give them
    // a chance to cleanup too.
    //
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "ClasspCreateClose: %s for devobj %p\n",
                (NT_SUCCESS(status) ? "Success" : "FAILED"),
                DeviceObject));
 
 
    if(NT_SUCCESS(status)) {
 
        KEVENT event;
 
        //
        // Set up the event to wait on
        //
 
        KeInitializeEvent(&event, SynchronizationEvent, FALSE);
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine( Irp, ClassSignalCompletion, &event,
                                TRUE, TRUE, TRUE);
 
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 
        if(status == STATUS_PENDING) {
            (VOID)KeWaitForSingleObject(&event,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL);
            status = Irp->IoStatus.Status;
        }
 
        if (!NT_SUCCESS(status)) {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT,
                        "ClasspCreateClose: Lower driver failed, but we "
                        "succeeded.  This is a problem, lock counts will be "
                        "out of sync between levels.\n"));
        }
 
    }
 
 
    return status;
}

Referenced by ClassCreateClose().

ClasspEjectionControl()

NTSTATUS ClasspEjectionControl	(	IN PDEVICE_OBJECT	Fdo,
		IN PIRP	Irp,
		IN MEDIA_LOCK_TYPE	LockType,
		IN BOOLEAN	Lock
	)

Definition at line 474 of file create.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION FdoExtension = Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension =
        (PCOMMON_DEVICE_EXTENSION) FdoExtension;
 
    PFILE_OBJECT_EXTENSION fsContext = NULL;
    NTSTATUS status;
    PSCSI_REQUEST_BLOCK srb = NULL;
    BOOLEAN countChanged = FALSE;
 
    PAGED_CODE();
 
    /*
     *  Ensure that the user thread is not suspended while we are holding EjectSynchronizationEvent.
     */
    KeEnterCriticalRegion();
 
    status = KeWaitForSingleObject(
                &(FdoExtension->EjectSynchronizationEvent),
                UserRequest,
                KernelMode,
                FALSE,
                NULL);
 
    NT_ASSERT(status == STATUS_SUCCESS);
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                "ClasspEjectionControl: "
                "Received request for %s lock type\n",
                LockTypeStrings[LockType]
                ));
 
    _SEH2_TRY {
        PCDB cdb = NULL;
 
        //
        // Determine if this is a "secured" request.
        //
 
        if (LockType == SecureMediaLock) {
 
            PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
            PFILE_OBJECT fileObject = irpStack->FileObject;
 
            //
            // Make sure that the file object we are supplied has a
            // proper FsContext before we try doing a secured lock.
            //
 
            if (fileObject != NULL) {
                fsContext = ClassGetFsContext(commonExtension, fileObject);
            }
 
            if (fsContext == NULL) {
 
                //
                // This handle isn't setup correctly.  We can't let the
                // operation go.
                //
 
                status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        }
 
        if (Lock) {
 
            //
            // This is a lock command.  Reissue the command in case bus or
            // device was reset and the lock was cleared.
            // note: may need to decrement count if actual lock operation
            //       failed....
            //
 
            switch (LockType) {
 
                case SimpleMediaLock: {
                    FdoExtension->LockCount++;
                    countChanged = TRUE;
                    break;
                }
 
                case SecureMediaLock: {
                    fsContext->LockCount++;
                    FdoExtension->ProtectedLockCount++;
                    countChanged = TRUE;
                    break;
                }
 
                case InternalMediaLock: {
                    FdoExtension->InternalLockCount++;
                    countChanged = TRUE;
                    break;
                }
            }
 
        } else {
 
            //
            // This is an unlock command.  If it's a secured one then make sure
            // the caller has a lock outstanding or return an error.
            // note: may need to re-increment the count if actual unlock
            //       operation fails....
            //
 
            switch (LockType) {
 
                case SimpleMediaLock: {
                    if(FdoExtension->LockCount != 0) {
                        FdoExtension->LockCount--;
                        countChanged = TRUE;
                    }
                    break;
                }
 
                case SecureMediaLock: {
                    if(fsContext->LockCount == 0) {
                        status = STATUS_INVALID_DEVICE_STATE;
                        _SEH2_LEAVE;
                    }
                    fsContext->LockCount--;
                    FdoExtension->ProtectedLockCount--;
                    countChanged = TRUE;
                    break;
                }
 
                case InternalMediaLock: {
                    NT_ASSERT(FdoExtension->InternalLockCount != 0);
                    FdoExtension->InternalLockCount--;
                    countChanged = TRUE;
                    break;
                }
            }
 
            //
            // We only send an unlock command to the drive if both the
            // secured and unsecured lock counts have dropped to zero.
            //
 
            if ((FdoExtension->ProtectedLockCount != 0) ||
                (FdoExtension->InternalLockCount != 0) ||
                (FdoExtension->LockCount != 0)) {
 
                status = STATUS_SUCCESS;
                _SEH2_LEAVE;
            }
        }
 
        status = STATUS_SUCCESS;
        if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {
 
            srb = (PSCSI_REQUEST_BLOCK)ClasspAllocateSrb(FdoExtension);
 
            if (srb == NULL) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
 
            if (FdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
 
                //
                // NOTE - this is based on size used in ClasspAllocateSrb
                //
 
                status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)srb,
                                                       STORAGE_ADDRESS_TYPE_BTL8,
                                                       CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE,
                                                       1,
                                                       SrbExDataTypeScsiCdb16);
                if (!NT_SUCCESS(status)) {
                    NT_ASSERT(FALSE);
                    _SEH2_LEAVE;
                }
 
            } else {
                RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
            }
 
            SrbSetCdbLength(srb, 6);
            cdb = SrbGetCdb(srb);
            NT_ASSERT(cdb != NULL);
 
            cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;
 
            //
            // TRUE - prevent media removal.
            // FALSE - allow media removal.
            //
 
            cdb->MEDIA_REMOVAL.Prevent = Lock;
 
            //
            // Set timeout value.
            //
 
            SrbSetTimeOutValue(srb, FdoExtension->TimeOutValue);
 
            //
            // The actual lock operation on the device isn't so important
            // as the internal lock counts.  Ignore failures.
            //
 
            status = ClassSendSrbSynchronous(FdoExtension->DeviceObject,
                                             srb,
                                             NULL,
                                             0,
                                             FALSE);
        }
 
    } _SEH2_FINALLY {
 
        if (!NT_SUCCESS(status)) {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                        "ClasspEjectionControl: FAILED status %x -- "
                        "reverting lock counts\n", status));
 
            if (countChanged) {
 
                //
                // have to revert to previous counts if the
                // lock/unlock operation actually failed.
                //
 
                if (Lock) {
 
                    switch (LockType) {
 
                        case SimpleMediaLock: {
                            FdoExtension->LockCount--;
                            break;
                        }
 
                        case SecureMediaLock: {
                            fsContext->LockCount--;
                            FdoExtension->ProtectedLockCount--;
                            break;
                        }
 
                        case InternalMediaLock: {
                            FdoExtension->InternalLockCount--;
                            break;
                        }
                    }
 
                } else {
 
                    switch (LockType) {
 
                        case SimpleMediaLock: {
                            FdoExtension->LockCount++;
                            break;
                        }
 
                        case SecureMediaLock: {
                            fsContext->LockCount++;
                            FdoExtension->ProtectedLockCount++;
                            break;
                        }
 
                        case InternalMediaLock: {
                            FdoExtension->InternalLockCount++;
                            break;
                        }
                    }
                }
 
            }
 
        } else {
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                        "ClasspEjectionControl: Succeeded\n"));
 
        }
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "ClasspEjectionControl: "
                    "Current Counts: Internal: %x  Secure: %x  Simple: %x\n",
                    FdoExtension->InternalLockCount,
                    FdoExtension->ProtectedLockCount,
                    FdoExtension->LockCount
                    ));
 
        KeSetEvent(&(FdoExtension->EjectSynchronizationEvent),
                   IO_NO_INCREMENT,
                   FALSE);
        KeLeaveCriticalRegion();
 
        if (srb) {
            ClassFreeOrReuseSrb(FdoExtension, srb);
        }
 
    } _SEH2_END;
    return status;
}

Referenced by ClassDeviceControl(), and ClassDispatchPnp().

Variable Documentation

BreakOnClose

ULONG BreakOnClose = 0

Definition at line 32 of file create.c.

Referenced by ClasspCleanupProtectedLocks(), and ClasspCreateClose().

LockTypeStrings

const PCSZ LockTypeStrings[]

Initial value:

= {
    "Simple",
    "Secure",
    "Internal"
}

Definition at line 34 of file create.c.

Referenced by ClasspEjectionControl().