device.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for device.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	DACL_SET   4

Functions
VOID NTAPI	IopReadyDeviceObjects (IN PDRIVER_OBJECT Driver)
VOID NTAPI	IopDeleteDevice (IN PVOID ObjectBody)
static PDEVICE_OBJECT NTAPI	IopAttachDeviceToDeviceStackSafe (_In_ PDEVICE_OBJECT SourceDevice, _In_ PDEVICE_OBJECT TargetDevice, _Out_opt_ PDEVICE_OBJECT *AttachedToDeviceObject)
VOID NTAPI	IoShutdownPnpDevices (VOID)
VOID NTAPI	IoShutdownSystem (IN ULONG Phase)
NTSTATUS NTAPI	IopGetDeviceObjectPointer (IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject, IN ULONG AttachFlag)
PDEVICE_OBJECT NTAPI	IopGetLowestDevice (IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	IopEditDeviceList (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT DeviceObject, IN IOP_DEVICE_LIST_OPERATION Type)
VOID NTAPI	IopUnloadDevice (IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	IopDereferenceDeviceObject (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN ForceUnload)
VOID NTAPI	IopStartNextPacketByKey (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN Cancelable, IN ULONG Key)
VOID NTAPI	IopStartNextPacket (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN Cancelable)
VOID NTAPI	IopStartNextPacketByKeyEx (IN PDEVICE_OBJECT DeviceObject, IN ULONG Key, IN ULONG Flags)
NTSTATUS NTAPI	IopGetRelatedTargetDevice (IN PFILE_OBJECT FileObject, OUT PDEVICE_NODE *DeviceNode)
BOOLEAN NTAPI	IopVerifyDeviceObjectOnStack (IN PDEVICE_OBJECT BaseDeviceObject, IN PDEVICE_OBJECT TopDeviceObjectHint)
NTSTATUS NTAPI	IopCreateSecurityDescriptorPerType (IN PSECURITY_DESCRIPTOR SecurityDescriptor, IN SECURITY_DESCRIPTOR_TYPE Type, OUT PULONG OutputFlags)
PSECURITY_DESCRIPTOR NTAPI	IopCreateDefaultDeviceSecurityDescriptor (IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN HasDeviceName, IN PSECURITY_DESCRIPTOR SecurityDescriptor, OUT PACL *OutputDacl, OUT PULONG OutputFlags)
NTSTATUS NTAPI	IoAttachDevice (PDEVICE_OBJECT SourceDevice, PUNICODE_STRING TargetDeviceName, PDEVICE_OBJECT *AttachedDevice)
NTSTATUS NTAPI	IoAttachDeviceByPointer (IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice)
PDEVICE_OBJECT NTAPI	IoAttachDeviceToDeviceStack (IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice)
NTSTATUS NTAPI	IoAttachDeviceToDeviceStackSafe (IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice, IN OUT PDEVICE_OBJECT *AttachedToDeviceObject)
NTSTATUS NTAPI	IoCreateDevice (IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
VOID NTAPI	IoDeleteDevice (IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	IoDetachDevice (IN PDEVICE_OBJECT TargetDevice)
NTSTATUS NTAPI	IoEnumerateDeviceObjectList (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT *DeviceObjectList, IN ULONG DeviceObjectListSize, OUT PULONG ActualNumberDeviceObjects)
PDEVICE_OBJECT NTAPI	IoGetAttachedDevice (PDEVICE_OBJECT DeviceObject)
PDEVICE_OBJECT NTAPI	IoGetAttachedDeviceReference (PDEVICE_OBJECT DeviceObject)
PDEVICE_OBJECT NTAPI	IoGetDeviceAttachmentBaseRef (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	IoGetDeviceObjectPointer (IN PUNICODE_STRING ObjectName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
NTSTATUS NTAPI	IoGetDiskDeviceObject (IN PDEVICE_OBJECT FileSystemDeviceObject, OUT PDEVICE_OBJECT *DiskDeviceObject)
PDEVICE_OBJECT NTAPI	IoGetLowerDeviceObject (IN PDEVICE_OBJECT DeviceObject)
PDEVICE_OBJECT NTAPI	IoGetRelatedDeviceObject (IN PFILE_OBJECT FileObject)
NTSTATUS NTAPI	IoGetRelatedTargetDevice (IN PFILE_OBJECT FileObject, OUT PDEVICE_OBJECT *DeviceObject)
PDEVICE_OBJECT NTAPI	IoGetBaseFileSystemDeviceObject (IN PFILE_OBJECT FileObject)
NTSTATUS NTAPI	IoRegisterLastChanceShutdownNotification (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	IoRegisterShutdownNotification (PDEVICE_OBJECT DeviceObject)
VOID NTAPI	IoUnregisterShutdownNotification (PDEVICE_OBJECT DeviceObject)
VOID NTAPI	IoSetStartIoAttributes (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN DeferredStartIo, IN BOOLEAN NonCancelable)
VOID NTAPI	IoStartNextPacketByKey (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN Cancelable, IN ULONG Key)
VOID NTAPI	IoStartNextPacket (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN Cancelable)
VOID NTAPI	IoStartPacket (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PULONG Key, IN PDRIVER_CANCEL CancelFunction)

Variables
ULONG	IopDeviceObjectNumber = 0
LIST_ENTRY	ShutdownListHead
LIST_ENTRY	LastChanceShutdownListHead
KSPIN_LOCK	ShutdownListLock
LIST_ENTRY	IopDiskFileSystemQueueHead
LIST_ENTRY	IopCdRomFileSystemQueueHead
LIST_ENTRY	IopTapeFileSystemQueueHead
ERESOURCE	IopDatabaseResource

Macro Definition Documentation

DACL_SET

#define DACL_SET   4

Definition at line 28 of file device.c.

NDEBUG

#define NDEBUG

Definition at line 15 of file device.c.

Function Documentation

IoAttachDevice()

NTSTATUS NTAPI IoAttachDevice	(	PDEVICE_OBJECT	SourceDevice,
		PUNICODE_STRING	TargetDeviceName,
		PDEVICE_OBJECT *	AttachedDevice
	)

Definition at line 920 of file device.c.

{
    NTSTATUS Status;
    PFILE_OBJECT FileObject = NULL;
    PDEVICE_OBJECT TargetDevice = NULL;
 
    /* Call the helper routine for an attach operation */
    Status = IopGetDeviceObjectPointer(TargetDeviceName,
                                       FILE_READ_ATTRIBUTES,
                                       &FileObject,
                                       &TargetDevice,
                                       IO_ATTACH_DEVICE_API);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Attach the device */
    Status = IoAttachDeviceToDeviceStackSafe(SourceDevice,
                                             TargetDevice,
                                             AttachedDevice);
 
    /* Dereference it */
    ObDereferenceObject(FileObject);
    return Status;
}

Referenced by ScreenAddDevice(), and TestAttachDevice().

IoAttachDeviceByPointer()

NTSTATUS NTAPI IoAttachDeviceByPointer	(	IN PDEVICE_OBJECT	SourceDevice,
		IN PDEVICE_OBJECT	TargetDevice
	)

Definition at line 954 of file device.c.

{
    PDEVICE_OBJECT AttachedDevice;
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* Do the Attach */
    AttachedDevice = IoAttachDeviceToDeviceStack(SourceDevice, TargetDevice);
    if (!AttachedDevice) Status = STATUS_NO_SUCH_DEVICE;
 
    /* Return the status */
    return Status;
}

Referenced by UDFCheckOtherFS().

IoAttachDeviceToDeviceStack()

PDEVICE_OBJECT NTAPI IoAttachDeviceToDeviceStack	(	IN PDEVICE_OBJECT	SourceDevice,
		IN PDEVICE_OBJECT	TargetDevice
	)

Definition at line 973 of file device.c.

{
    /* Attach it safely */
    return IopAttachDeviceToDeviceStackSafe(SourceDevice,
                                            TargetDevice,
                                            NULL);
}

Referenced by _Function_class_(), AtaAddChannel(), Bus_AddDevice(), CmBattCreateFdo(), CODE_SEG(), CompBattAddDevice(), CreateFlopDeviceObject(), CreateGreenFdo(), CreateTestDevices(), DiskCreateFdo(), FreeBT_AddDevice(), HalpAddDevice(), HidClassAddDevice(), InPortAddDevice(), IntVideoPortCreateAdapterDeviceObject(), IoAttachDeviceByPointer(), KbdHid_AddDevice(), KeyboardAddDevice(), KMix_AddDevice(), KopAddDevice(), KsCreateBusEnumObject(), KsCreateDevice(), MouHid_AddDevice(), Mx::MxAttachDeviceToDeviceStack(), NdisIAddDevice(), PartMgrAddDevice(), PcAddAdapterDevice(), PciAddDevice(), PcmciaAddDevice(), RamdiskAddDevice(), ScreenAddDevice(), ScsiPortInitialize(), StreamClassAddDevice(), SysAudio_AddDevice(), USBCCGP_AddDevice(), USBH_AddDevice(), USBPORT_AddDevice(), USBSTOR_AddDevice(), and WdmaudAddDevice().

IoAttachDeviceToDeviceStackSafe()

NTSTATUS NTAPI IoAttachDeviceToDeviceStackSafe	(	IN PDEVICE_OBJECT	SourceDevice,
		IN PDEVICE_OBJECT	TargetDevice,
		IN OUT PDEVICE_OBJECT *	AttachedToDeviceObject
	)

Definition at line 987 of file device.c.

{
    /* Call the internal function */
    if (!IopAttachDeviceToDeviceStackSafe(SourceDevice,
                                          TargetDevice,
                                          AttachedToDeviceObject))
    {
        /* Nothing found */
        return STATUS_NO_SUCH_DEVICE;
    }
 
    /* Success! */
    return STATUS_SUCCESS;
}

Referenced by _Dispatch_type_(), AddDeviceInternal(), ClassAddDevice(), FdcAddDevice(), FltpAttachDeviceObject(), IoAttachDevice(), PciIdeXAddDeviceEx(), PortAddDevice(), ProcessorAddDevice(), SerenumAddDevice(), SerialAddDeviceInternal(), and SermouseAddDevice().

IoCreateDevice()

NTSTATUS NTAPI IoCreateDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN ULONG	DeviceExtensionSize,
		IN PUNICODE_STRING	DeviceName,
		IN DEVICE_TYPE	DeviceType,
		IN ULONG	DeviceCharacteristics,
		IN BOOLEAN	Exclusive,
		OUT PDEVICE_OBJECT *	DeviceObject
	)

Definition at line 1038 of file device.c.

{
    WCHAR AutoNameBuffer[20];
    UNICODE_STRING AutoName;
    PDEVICE_OBJECT CreatedDeviceObject;
    PDEVOBJ_EXTENSION DeviceObjectExtension;
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    ULONG AlignedDeviceExtensionSize;
    ULONG TotalSize;
    HANDLE TempHandle;
    PACL Dacl;
    SECURITY_DESCRIPTOR SecurityDescriptor, *ReturnedSD;
    PAGED_CODE();
 
    /* Check if we have to generate a name */
    if (DeviceCharacteristics & FILE_AUTOGENERATED_DEVICE_NAME)
    {
        /* Generate it */
        _swprintf(AutoNameBuffer,
                  L"\\Device\\%08lx",
                  InterlockedIncrementUL(&IopDeviceObjectNumber));
 
        /* Initialize the name */
        RtlInitUnicodeString(&AutoName, AutoNameBuffer);
        DeviceName = &AutoName;
    }
 
    /* Get the security descriptor */
    ReturnedSD = IopCreateDefaultDeviceSecurityDescriptor(DeviceType,
                                                          DeviceCharacteristics,
                                                          DeviceName != NULL,
                                                          &SecurityDescriptor,
                                                          &Dacl,
                                                          NULL);
 
    /* Initialize the Object Attributes */
    InitializeObjectAttributes(&ObjectAttributes,
                               DeviceName,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               ReturnedSD);
 
    /* Honor the internal I/O System case (in)sensitivity */
    if (IopCaseInsensitive) ObjectAttributes.Attributes |= OBJ_CASE_INSENSITIVE;
 
    /* Honor the exclusive flag */
    if (Exclusive) ObjectAttributes.Attributes |= OBJ_EXCLUSIVE;
 
    /* Create a permanent object for named devices */
    if (DeviceName) ObjectAttributes.Attributes |= OBJ_PERMANENT;
 
    /* Align the Extension Size to 8-bytes */
    AlignedDeviceExtensionSize = ALIGN_UP_BY(DeviceExtensionSize,
                                             MEMORY_ALLOCATION_ALIGNMENT);
 
    /* Total Size */
    TotalSize = AlignedDeviceExtensionSize +
                sizeof(DEVICE_OBJECT) +
                sizeof(EXTENDED_DEVOBJ_EXTENSION);
 
    /* Create the Device Object */
    *DeviceObject = NULL;
    Status = ObCreateObject(KernelMode,
                            IoDeviceObjectType,
                            &ObjectAttributes,
                            KernelMode,
                            NULL,
                            TotalSize,
                            0,
                            0,
                            (PVOID*)&CreatedDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        if (Dacl != NULL) ExFreePoolWithTag(Dacl, 'eSoI');
 
        return Status;
    }
 
    /* Clear the whole Object and extension so we don't null stuff manually */
    RtlZeroMemory(CreatedDeviceObject, TotalSize);
 
    /*
     * Setup the Type and Size. Note that we don't use the aligned size,
     * because that's only padding for the DevObjExt and not part of the Object.
     */
    CreatedDeviceObject->Type = IO_TYPE_DEVICE;
    CreatedDeviceObject->Size = sizeof(DEVICE_OBJECT) + (USHORT)DeviceExtensionSize;
 
    /* The kernel extension is after the driver internal extension */
    DeviceObjectExtension = (PDEVOBJ_EXTENSION)
                            ((ULONG_PTR)(CreatedDeviceObject + 1) +
                             AlignedDeviceExtensionSize);
 
    /* Set the Type and Size. Question: why is Size 0 on Windows? */
    DeviceObjectExtension->Type = IO_TYPE_DEVICE_OBJECT_EXTENSION;
    DeviceObjectExtension->Size = 0;
 
    /* Initialize with Power Manager */
    PoInitializeDeviceObject(DeviceObjectExtension);
 
    /* Link the Object and Extension */
    DeviceObjectExtension->DeviceObject = CreatedDeviceObject;
    CreatedDeviceObject->DeviceObjectExtension = DeviceObjectExtension;
 
    /* Set Device Object Data */
    CreatedDeviceObject->DeviceType = DeviceType;
    CreatedDeviceObject->Characteristics = DeviceCharacteristics;
    CreatedDeviceObject->DeviceExtension = DeviceExtensionSize ?
                                           CreatedDeviceObject + 1 :
                                           NULL;
    CreatedDeviceObject->StackSize = 1;
    CreatedDeviceObject->AlignmentRequirement = 0;
 
    /* Set the Flags */
    CreatedDeviceObject->Flags = DO_DEVICE_INITIALIZING;
    if (Exclusive) CreatedDeviceObject->Flags |= DO_EXCLUSIVE;
    if (DeviceName) CreatedDeviceObject->Flags |= DO_DEVICE_HAS_NAME;
 
    /* Attach a Vpb for Disks and Tapes, and create the Device Lock */
    if ((CreatedDeviceObject->DeviceType == FILE_DEVICE_DISK) ||
        (CreatedDeviceObject->DeviceType == FILE_DEVICE_VIRTUAL_DISK) ||
        (CreatedDeviceObject->DeviceType == FILE_DEVICE_CD_ROM) ||
        (CreatedDeviceObject->DeviceType == FILE_DEVICE_TAPE))
    {
        /* Create Vpb */
        Status = IopCreateVpb(CreatedDeviceObject);
        if (!NT_SUCCESS(Status))
        {
            if (Dacl != NULL) ExFreePoolWithTag(Dacl, 'eSoI');
 
            /* Dereference the device object and fail */
            ObDereferenceObject(CreatedDeviceObject);
            return Status;
        }
 
        /* Initialize Lock Event */
        KeInitializeEvent(&CreatedDeviceObject->DeviceLock,
                          SynchronizationEvent,
                          TRUE);
    }
 
    /* Set the right Sector Size */
    switch (DeviceType)
    {
        /* All disk systems */
        case FILE_DEVICE_DISK_FILE_SYSTEM:
        case FILE_DEVICE_DISK:
        case FILE_DEVICE_VIRTUAL_DISK:
 
            /* The default is 512 bytes */
            CreatedDeviceObject->SectorSize  = 512;
            break;
 
        /* CD-ROM file systems */
        case FILE_DEVICE_CD_ROM_FILE_SYSTEM:
 
            /* The default is 2048 bytes */
            CreatedDeviceObject->SectorSize = 2048;
    }
 
    /* Create the Device Queue */
    if ((CreatedDeviceObject->DeviceType == FILE_DEVICE_DISK_FILE_SYSTEM) ||
        (CreatedDeviceObject->DeviceType == FILE_DEVICE_FILE_SYSTEM) ||
        (CreatedDeviceObject->DeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM) ||
        (CreatedDeviceObject->DeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM) ||
        (CreatedDeviceObject->DeviceType == FILE_DEVICE_TAPE_FILE_SYSTEM))
    {
        /* Simple FS Devices, they don't need a real Device Queue */
        InitializeListHead(&CreatedDeviceObject->Queue.ListEntry);
    }
    else
    {
        /* An actual Device, initialize its DQ */
        KeInitializeDeviceQueue(&CreatedDeviceObject->DeviceQueue);
    }
 
    /* Insert the Object */
    Status = ObInsertObject(CreatedDeviceObject,
                            NULL,
                            FILE_READ_DATA | FILE_WRITE_DATA,
                            1,
                            (PVOID*)&CreatedDeviceObject,
                            &TempHandle);
    if (!NT_SUCCESS(Status))
    {
        if (Dacl != NULL) ExFreePoolWithTag(Dacl, 'eSoI');
 
        return Status;
    }
 
    /* Now do the final linking */
    ObReferenceObject(DriverObject);
    ASSERT((DriverObject->Flags & DRVO_UNLOAD_INVOKED) == 0);
    CreatedDeviceObject->DriverObject = DriverObject;
    IopEditDeviceList(DriverObject, CreatedDeviceObject, IopAdd);
 
    /* Link with the power manager */
    if (CreatedDeviceObject->Vpb) PoVolumeDevice(CreatedDeviceObject);
 
    /* Close the temporary handle and return to caller */
    ObCloseHandle(TempHandle, KernelMode);
    *DeviceObject = CreatedDeviceObject;
 
    if (Dacl != NULL) ExFreePoolWithTag(Dacl, 'eSoI');
 
    return STATUS_SUCCESS;
}

Referenced by _Dispatch_type_(), _Function_class_(), add_volume_device(), AddControllers(), AddDeviceInternal(), AtaAddChannel(), AtaPdoCreateDevice(), Bus_AddDevice(), Bus_PlugInDevice(), ClassAddDevice(), CmBattCreateFdo(), CODE_SEG(), CompBattAddDevice(), ConDrvCreateController(), CreateClassDeviceObject(), CreateGreenFdo(), CreateSoundDevice(), CreateTestDevices(), DriverEntry(), Ext2MountVolume(), FdcAddDevice(), FdcFdoQueryBusRelations(), FDO_CreateChildPdo(), FdoCreateRawParallelPdo(), FdoQueryBusRelations(), FltpAttachToFileSystemDevice(), FltpEnumerateFileSystemVolumes(), FltpSetupCommunicationObjects(), FreeBT_AddDevice(), FsdMount(), FsRecRegisterFs(), FxLibraryCreateDevice(), GreenQueryBusRelations(), HalpAddDevice(), HidClassAddDevice(), HidClassPDO_CreatePDO(), InitDevice(), InitializeSoundBlaster(), InPortAddDevice(), IntVideoPortCreateAdapterDeviceObject(), IntVideoPortEnumerateChildren(), IopInitializePlugPlayServices(), IsaPnpCreateReadPortDO(), IsaPnpFillDeviceRelations(), KbdHid_AddDevice(), KeyboardAddDevice(), KMix_AddDevice(), KopAddDevice(), KsCreateDevice(), KspCreatePDO(), MouHid_AddDevice(), mount_vol(), Mx::MxCreateDevice(), Mx::MxCreateDeviceSecure(), NdisIAddDevice(), NdisMRegisterDevice(), NtfsMountVolume(), PartitionCreateDevice(), PartMgrAddDevice(), PcAddAdapterDevice(), PciAddDevice(), PciIdeXAddDeviceEx(), PciIdeXPdoCreateDevice(), PciPdoCreate(), PcmciaAddDevice(), PdoCreateLunDevice(), PnpRootCreateDeviceObject(), PnpRootDriverEntry(), PortAddDevice(), PortCreatePdo(), ProcessorAddDevice(), RamdiskAddDevice(), RamdiskCreateDiskDevice(), RawFsDriverEntry(), RawMountVolume(), ReportDetectedDevice(), RxRegisterMinirdr(), ScreenAddDevice(), ScsiPortInitialize(), SerenumAddDevice(), SerialAddDeviceInternal(), SermouseAddDevice(), StreamClassAddDevice(), SwAddDevice(), SysAudio_AddDevice(), TestDeviceCreateDelete(), UDFCheckOtherFS(), UDFCreateFsDeviceObject(), UDFMountVolume(), UniataClaimLegacyPCIIDE(), UniataConnectIntr2(), USBCCGP_AddDevice(), USBH_AddDevice(), USBH_CreateDevice(), USBPORT_AddDevice(), USBPORT_CreatePdo(), USBSTOR_AddDevice(), USBSTOR_CreatePDO(), VfatMount(), VfdCreateDevice(), ViCreateDriveLetter(), and WdmaudAddDevice().

IoDeleteDevice()

VOID NTAPI IoDeleteDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 1261 of file device.c.

{
    PIO_TIMER Timer;
 
    /* Check if the device is registered for shutdown notifications */
    if (DeviceObject->Flags & DO_SHUTDOWN_REGISTERED)
    {
        /* Call the shutdown notifications */
        IoUnregisterShutdownNotification(DeviceObject);
    }
 
    /* Check if it has a timer */
    Timer = DeviceObject->Timer;
    if (Timer)
    {
        /* Remove it and free it */
        IopRemoveTimerFromTimerList(Timer);
        ExFreePoolWithTag(Timer, TAG_IO_TIMER);
    }
 
    /* Check if the device has a name */
    if (DeviceObject->Flags & DO_DEVICE_HAS_NAME)
    {
        /* It does, make it temporary so we can remove it */
        ObMakeTemporaryObject(DeviceObject);
    }
 
    /* Set the pending delete flag */
    IoGetDevObjExtension(DeviceObject)->ExtensionFlags |= DOE_DELETE_PENDING;
 
    /* Unlink with the power manager */
    if (DeviceObject->Vpb) PoRemoveVolumeDevice(DeviceObject);
 
    /* Check if the device object can be unloaded */
    if (!DeviceObject->ReferenceCount) IopUnloadDevice(DeviceObject);
}

Referenced by _Dispatch_type_(), _Function_class_(), _Requires_lock_held_(), AddDeviceInternal(), AtaAddChannel(), AtaFdoRemoveDevice(), AtaPdoFreeDevice(), BeepUnload(), Bus_AddDevice(), Bus_DestroyPdo(), Bus_PlugInDevice(), CdDeleteVcb(), Cleanup(), CmBattDestroyFdo(), CmBattRemoveDevice(), CODE_SEG(), CompBattAddDevice(), ConDrvCreateController(), ConDrvDeleteController(), CreateFlopDeviceObject(), CreateGreenFdo(), CreateSoundDevice(), CreateTestDevices(), DestroyPortDriver(), DestroySoundDevice(), DiskCreateFdo(), do_shutdown(), DriverEntry(), DriverUnload(), Ext2DestroyVcb(), Ext2MountVolume(), FdcAddDevice(), FdcFdoPnp(), FdcFdoQueryBusRelations(), FdcPdoDeleteDevice(), FDO_HandlePnp(), FdoCreateRawParallelPdo(), FdoHandleRemoveDevice(), FdoPnpControl(), FdoRemoveAdapter(), FdoScanAdapter(), FltpAttachToFileSystemDevice(), FltpDetachFromFileSystemDevice(), FltpEnumerateFileSystemVolumes(), FltpFastIoDetachDevice(), FltpFastIoDetachDeviceWorker(), FltpSetupCommunicationObjects(), free_vol(), FreeBT_AddDevice(), FsRecUnload(), FxLibraryCleanup(), GreenQueryBusRelations(), HalpAddDevice(), HalpDriverEntry(), HandleRemoveDevice(), HidClassAddDevice(), HidClassFDO_RemoveDevice(), HidClassPDO_CreatePDO(), HidClassPDO_PnP(), i8042RemoveDevice(), InitDevice(), InitializeSoundBlaster(), InPortAddDevice(), InPortRemoveDevice(), IntVideoPortCreateAdapterDeviceObject(), IntVideoPortDispatchPdoPnp(), IntVideoPortEnumerateChildren(), IntVideoPortFindAdapter(), IsaFdoRemoveDevice(), IsaPnpFillDeviceRelations(), IsaPnpRemoveLogicalDeviceDO(), IsaPnpRemoveReadPortDO(), KbdHid_AddDevice(), KbdHid_Pnp(), KMix_AddDevice(), KopAddDevice(), KsCreateDevice(), KsDefaultDispatchPnp(), KspCreatePDO(), KsServiceBusEnumPnpRequest(), MouHid_AddDevice(), MouHid_Pnp(), mount_vol(), MountMgrUnload(), MupUnload(), Mx::MxDeleteDevice(), NdisIAddDevice(), NdisIPnPRemoveDevice(), NdisMDeregisterDevice(), NdisMRegisterDevice(), NullUnload(), PartitionHandleRemove(), PartMgrAddDevice(), PcAddAdapterDevice(), PciAddDevice(), PciDeleteBusChildren(), PciFdoIrpRemoveDevice(), PciIdeXAddDeviceEx(), PciIdeXFdoDispatchPnp(), PciIdeXPdoRemoveDevice(), PDO_HandlePnp(), PiControlInitializeDevice(), PnpRootCreateDevice(), PnpRootPdoPnpControl(), PnpRootQueryDeviceRelations(), PortAddDevice(), PortDeletePdo(), ProcessorAddDevice(), RamdiskAddDevice(), RamdiskRemoveBusDevice(), RawCheckForDismount(), RawFsDriverEntry(), RawMountVolume(), RawShutdown(), remove_volume_child(), ReportDetectedDevice(), ReportGreenPdo(), ScreenAddDevice(), SerenumAddDevice(), SerialAddDeviceInternal(), SermouseAddDevice(), StreamClassAddDevice(), SwAddDevice(), SwDispatchPnp(), SysAudio_AddDevice(), TestDeviceCreateDelete(), TestMessageHandler(), TestUnload(), TiUnload(), UDFCheckOtherFS(), UDFCommonDeviceControl(), UDFMountVolume(), UDFReleaseVCB(), UniataClaimLegacyPCIIDE(), UniataConnectIntr2(), UniataDisconnectIntr2(), uninit(), Unload(), UnloadHandler(), USBCCGP_AddDevice(), USBH_AddDevice(), USBH_FdoQueryBusRelations(), USBH_FdoRemoveDevice(), USBH_PdoRemoveDevice(), USBPORT_FdoPnP(), USBSTOR_AddDevice(), USBSTOR_FdoHandleRemoveDevice(), USBSTOR_PdoHandlePnp(), VfatCheckForDismount(), VfatMount(), VfdCreateDevice(), VfdDeleteDevice(), ViCreateDriveLetter(), ViDeleteDevice(), and WdmaudAddDevice().

IoDetachDevice()

VOID NTAPI IoDetachDevice

(

IN PDEVICE_OBJECT

TargetDevice

)

Definition at line 1306 of file device.c.

{
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
 
    /* Sanity check */
    DeviceExtension = IoGetDevObjExtension(TargetDevice->AttachedDevice);
    ASSERT(DeviceExtension->AttachedTo == TargetDevice);
 
    /* Remove the attachment */
    DeviceExtension->AttachedTo = NULL;
    TargetDevice->AttachedDevice = NULL;
 
    /* Check if it's ok to delete this device */
    if ((IoGetDevObjExtension(TargetDevice)->ExtensionFlags & DOE_DELETE_PENDING) &&
        !(TargetDevice->ReferenceCount))
    {
        /* It is, do it */
        IopUnloadDevice(TargetDevice);
    }
}

Referenced by _Dispatch_type_(), AtaAddChannel(), AtaFdoRemoveDevice(), Bus_AddDevice(), CmBattAddBattery(), CmBattCreateFdo(), CmBattRemoveDevice(), CompBattAddDevice(), CreateGreenFdo(), CreateTestDevices(), DestroyPortDriver(), do_shutdown(), FdcFdoPnp(), FDO_HandlePnp(), FdoHandleRemoveDevice(), FdoPnpControl(), FltpAttachToFileSystemDevice(), FltpDetachFromFileSystemDevice(), FltpFastIoDetachDevice(), FltpFastIoDetachDeviceWorker(), free_vol(), FreeBT_AddDevice(), HandleRemoveDevice(), HidClassAddDevice(), HidClassFDO_RemoveDevice(), i8042RemoveDevice(), InPortAddDevice(), InPortRemoveDevice(), IntVideoPortCreateAdapterDeviceObject(), IntVideoPortFindAdapter(), IsaFdoRemoveDevice(), KbdHid_Pnp(), KsCreateBusEnumObject(), KsCreateDevice(), KsDefaultDispatchPnp(), MouHid_Pnp(), Mx::MxDetachDevice(), NdisIPnPRemoveDevice(), PciAddDevice(), PciFdoIrpRemoveDevice(), PciIdeXAddDeviceEx(), PciIdeXFdoDispatchPnp(), RamdiskRemoveBusDevice(), remove_volume_child(), ScreenAddDevice(), SermouseAddDevice(), StreamClassAddDevice(), TestDetachDevice(), TestMessageHandler(), uninit(), USBH_FdoRemoveDevice(), USBPORT_FdoPnP(), and USBSTOR_FdoHandleRemoveDevice().

IoEnumerateDeviceObjectList()

NTSTATUS NTAPI IoEnumerateDeviceObjectList	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT *	DeviceObjectList,
		IN ULONG	DeviceObjectListSize,
		OUT PULONG	ActualNumberDeviceObjects
	)

Definition at line 1332 of file device.c.

{
    ULONG ActualDevices = 1;
    PDEVICE_OBJECT CurrentDevice = DriverObject->DeviceObject;
    KIRQL OldIrql;
 
    /* Lock the device list while we enumerate it */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueIoDatabaseLock);
 
    /* Find out how many devices we'll enumerate */
    while ((CurrentDevice = CurrentDevice->NextDevice)) ActualDevices++;
 
    /* Go back to the first */
    CurrentDevice = DriverObject->DeviceObject;
 
    /* Start by at least returning this */
    *ActualNumberDeviceObjects = ActualDevices;
 
    /* Check if we can support so many */
    if ((ActualDevices * sizeof(PDEVICE_OBJECT)) > DeviceObjectListSize)
    {
        /* Fail because the buffer was too small */
        KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* Check if the caller wanted the device list */
    if (DeviceObjectList)
    {
        /* Loop through all the devices */
        while (ActualDevices)
        {
            /* Reference each Device */
            ObReferenceObject(CurrentDevice);
 
            /* Add it to the list */
            *DeviceObjectList = CurrentDevice;
 
            /* Go to the next one */
            CurrentDevice = CurrentDevice->NextDevice;
            ActualDevices--;
            DeviceObjectList++;
        }
    }
 
    /* Release the device list lock */
    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
 
    /* Return the status */
    return STATUS_SUCCESS;
}

Referenced by FltpEnumerateFileSystemVolumes().

IoGetAttachedDevice()

PDEVICE_OBJECT NTAPI IoGetAttachedDevice

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 1395 of file device.c.

{
    /* Get the last attached device */
    while (DeviceObject->AttachedDevice)
    {
        /* Move to the next one */
        DeviceObject = DeviceObject->AttachedDevice;
    }
 
    /* Return it */
    return DeviceObject;
}

Referenced by IoGetAttachedDeviceReference(), IoGetRelatedDeviceObject(), IopAttachDeviceToDeviceStackSafe(), IopCloseFile(), IopDeleteFile(), IopDeviceFsIoControl(), IopGetSetSecurityObject(), IopParseDevice(), IopShutdownBaseFileSystems(), IoShutdownSystem(), NtQueryInformationFile(), NtSetInformationFile(), NtUnlockFile(), PiCallDriverAddDevice(), and UDFCheckOtherFS().

IoGetAttachedDeviceReference()

PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 1416 of file device.c.

{
    KIRQL OldIrql;
 
    /* Retrieve and reference the attached device under the device list lock */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueIoDatabaseLock);
    DeviceObject = IoGetAttachedDevice(DeviceObject);
    ObReferenceObject(DeviceObject);
    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
 
    return DeviceObject;
}

Referenced by _IRQL_requires_max_(), AtaPnpRepeatRequest(), AtaStorageNotificationWorker(), Bus_GetDeviceCapabilities(), ClasspFailurePredict(), ClasspUpdateDiskProperties(), DiskCreateFdo(), DiskIoctlPredictFailure(), DiskSendFailurePredictIoctl(), FltpDetachFromFileSystemDevice(), FltpIsAttachedToDevice(), MxDeviceObject::GetAttachedDeviceReference(), GetDeviceId(), FxIoTargetRemote::GetTargetDeviceRelations(), HalpIsOldStyleFloppy(), HalpQueryDriveLayout(), HalpQueryPartitionType(), i8042SendHookWorkItem(), IopComputeHarddiskDerangements(), IopInitiatePnpIrp(), IopSynchronousCall(), IsFtVolume(), IssueUniqueIdChangeNotify(), IssueUniqueIdChangeNotifyWorker(), MountMgrNotifyNameChange(), Mx::MxGetAttachedDeviceReference(), PciGetDeviceCapabilities(), PciIdeXPnpRepeatRequest(), PciQueryForPciBusInterface(), PciSendDeviceUsageToParent(), PciSendIoctl(), PiCallDriverAddDevice(), PopQuerySystemPowerStateTraverse(), PopSetSystemPowerState(), PopSetSystemPowerStateTraverse(), PoRequestPowerIrp(), QueryDeviceInformation(), FxPkgPnp::QueryForD3ColdInterface(), QuerySuggestedLinkName(), SendLinkCreated(), SendLinkDeleted(), SendOnlineNotification(), USBPORT_IsCompanionController(), and USBPORT_QueryPciBusInterface().

IoGetBaseFileSystemDeviceObject()

PDEVICE_OBJECT NTAPI IoGetBaseFileSystemDeviceObject

(

IN PFILE_OBJECT

FileObject

)

Definition at line 1646 of file device.c.

{
    PDEVICE_OBJECT DeviceObject;
 
    /*
    * If the FILE_OBJECT's VPB is defined,
    * get the device from it.
    */
    if ((FileObject->Vpb) && (FileObject->Vpb->DeviceObject))
    {
        /* Use the VPB's Device Object's */
        DeviceObject = FileObject->Vpb->DeviceObject;
    }
    else if (!(FileObject->Flags & FO_DIRECT_DEVICE_OPEN) &&
             (FileObject->DeviceObject->Vpb) &&
             (FileObject->DeviceObject->Vpb->DeviceObject))
    {
        /* Use the VPB's File System Object */
        DeviceObject = FileObject->DeviceObject->Vpb->DeviceObject;
    }
    else
    {
        /* Use the FO's Device Object */
        DeviceObject = FileObject->DeviceObject;
    }
 
    /* Return the device object we found */
    ASSERT(DeviceObject != NULL);
    return DeviceObject;
}

Referenced by FsRtlAcquireFileForCcFlushEx(), FsRtlAcquireFileForModWriteEx(), FsRtlMdlRead(), FsRtlMdlReadComplete(), FsRtlMdlWriteComplete(), FsRtlPrepareMdlWrite(), FsRtlReleaseFileForCcFlush(), and FsRtlReleaseFileForModWrite().

IoGetDeviceAttachmentBaseRef()

PDEVICE_OBJECT NTAPI IoGetDeviceAttachmentBaseRef

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 1434 of file device.c.

{
    KIRQL OldIrql;
 
    /* Retrieve and reference the lowest attached device under the device list lock */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueIoDatabaseLock);
    DeviceObject = IopGetLowestDevice(DeviceObject);
    ObReferenceObject(DeviceObject);
    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
 
    return DeviceObject;
}

Referenced by FltpEnumerateFileSystemVolumes(), FltpGetBaseDeviceObjectName(), ReferenceInterfacePdo(), and TestLowerDeviceKernelAPI().

IoGetDeviceObjectPointer()

NTSTATUS NTAPI IoGetDeviceObjectPointer	(	IN PUNICODE_STRING	ObjectName,
		IN ACCESS_MASK	DesiredAccess,
		OUT PFILE_OBJECT *	FileObject,
		OUT PDEVICE_OBJECT *	DeviceObject
	)

Definition at line 1455 of file device.c.

{
    /* Call the helper routine for a normal operation */
    return IopGetDeviceObjectPointer(ObjectName,
                                     DesiredAccess,
                                     FileObject,
                                     DeviceObject,
                                     0);
}

Referenced by _Function_class_(), add_device(), add_volume_device(), ClassOpen(), CODE_SEG(), disk_arrival(), do_shutdown(), DriverEntry(), EngpRegisterGraphicsDevice(), finish_removing_device(), get_device_pnp_name_guid(), HalpDeleteMountLetter(), HalpEnableAutomaticDriveLetterAssignment(), HalpIsOldStyleFloppy(), HalpNextMountLetter(), HalpQueryDriveLayout(), HalpQueryPartitionType(), HalpSetMountLetter(), IoGetBootDiskInformation(), IopComputeHarddiskDerangements(), IopCreateArcNamesCd(), IopCreateArcNamesDisk(), IoVolumeDeviceToDosName(), IsFtVolume(), IssueUniqueIdChangeNotify(), IssueUniqueIdChangeNotifyWorker(), LibraryOpen(), mountmgr_notification(), MountMgrNotifyNameChange(), probe_volume(), QueryDeviceInformation(), QuerySuggestedLinkName(), read_registry(), ReconcileThisDatabaseWithMasterWorker(), ReferenceInterfacePdo(), RegisterForTargetDeviceNotification(), remove_volume_child(), ReportToMountMgr(), SearchForLegacyDrivers(), SendLinkCreated(), SendLinkDeleted(), SendOnlineNotification(), TestIoVolumeDeviceToDosName(), UDFCheckOtherFSByName(), volume_arrival(), and VolumeDeleteMountPoints().

IoGetDiskDeviceObject()

NTSTATUS NTAPI IoGetDiskDeviceObject	(	IN PDEVICE_OBJECT	FileSystemDeviceObject,
		OUT PDEVICE_OBJECT *	DiskDeviceObject
	)

Definition at line 1473 of file device.c.

{
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
    PVPB Vpb;
    KIRQL OldIrql;
    NTSTATUS Status;
 
    /* Make sure there's a VPB */
    if (!FileSystemDeviceObject->Vpb) return STATUS_INVALID_PARAMETER;
 
    /* Acquire it */
    IoAcquireVpbSpinLock(&OldIrql);
 
    /* Get the Device Extension */
    DeviceExtension = IoGetDevObjExtension(FileSystemDeviceObject);
 
    /* Make sure this one has a VPB too */
    Vpb = DeviceExtension->Vpb;
    if (Vpb)
    {
        /* Make sure that it's mounted */
        if ((Vpb->ReferenceCount) &&
            (Vpb->Flags & VPB_MOUNTED))
        {
            /* Return the Disk Device Object */
            *DiskDeviceObject = Vpb->RealDevice;
 
            /* Reference it and return success */
            ObReferenceObject(Vpb->RealDevice);
            Status = STATUS_SUCCESS;
        }
        else
        {
            /* It's not, so return failure */
            Status = STATUS_VOLUME_DISMOUNTED;
        }
    }
    else
    {
        /* Fail */
        Status = STATUS_INVALID_PARAMETER;
    }
 
    /* Release the lock */
    IoReleaseVpbSpinLock(OldIrql);
    return Status;
}

Referenced by FltpEnumerateFileSystemVolumes().

IoGetLowerDeviceObject()

PDEVICE_OBJECT NTAPI IoGetLowerDeviceObject

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 1527 of file device.c.

{
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
    PDEVICE_OBJECT LowerDeviceObject = NULL;
 
    /* Make sure it's not getting deleted */
    DeviceExtension = IoGetDevObjExtension(DeviceObject);
    if (!(DeviceExtension->ExtensionFlags &
         (DOE_UNLOAD_PENDING | DOE_DELETE_PENDING |
          DOE_REMOVE_PENDING | DOE_REMOVE_PROCESSED)))
    {
        /* Get the Lower Device Object */
        LowerDeviceObject = DeviceExtension->AttachedTo;
 
        /* Check that we got a valid device object */
        if (LowerDeviceObject)
        {
            /* We did so let's reference it */
            ObReferenceObject(LowerDeviceObject);
        }
    }
 
    /* Return it */
    return LowerDeviceObject;
}

Referenced by FltpDetachFromFileSystemDevice(), FltpIsAttachedToDevice(), mount_vol(), still_has_superblock(), and TestLowerDeviceKernelAPI().

IoGetRelatedDeviceObject()

PDEVICE_OBJECT NTAPI IoGetRelatedDeviceObject

(

IN PFILE_OBJECT

FileObject

)

Definition at line 1558 of file device.c.

{
    PDEVICE_OBJECT DeviceObject = FileObject->DeviceObject;
 
    /* Check if we have a VPB with a device object */
    if ((FileObject->Vpb) && (FileObject->Vpb->DeviceObject))
    {
        /* Then use the DO from the VPB */
        ASSERT(!(FileObject->Flags & FO_DIRECT_DEVICE_OPEN));
        DeviceObject = FileObject->Vpb->DeviceObject;
    }
    else if (!(FileObject->Flags & FO_DIRECT_DEVICE_OPEN) &&
              (FileObject->DeviceObject->Vpb) &&
              (FileObject->DeviceObject->Vpb->DeviceObject))
    {
        /* The disk device actually has a VPB, so get the DO from there */
        DeviceObject = FileObject->DeviceObject->Vpb->DeviceObject;
    }
    else
    {
        /* Otherwise, this was a direct open */
        DeviceObject = FileObject->DeviceObject;
    }
 
    /* Sanity check */
    ASSERT(DeviceObject != NULL);
 
    /* Check if we were attached */
    if (DeviceObject->AttachedDevice)
    {
        /* Check if the file object has an extension present */
        if (FileObject->Flags & FO_FILE_OBJECT_HAS_EXTENSION)
        {
            /* Sanity check, direct open files can't have this */
            ASSERT(!(FileObject->Flags & FO_DIRECT_DEVICE_OPEN));
 
            /* Check if the extension is really present */
            if (FileObject->FileObjectExtension)
            {
                PFILE_OBJECT_EXTENSION FileObjectExtension;
 
                /* Cast the buffer to something we understand */
                FileObjectExtension = FileObject->FileObjectExtension;
 
                /* Check if have a valid replacement top level device */
                if (FileObjectExtension->TopDeviceObjectHint &&
                    IopVerifyDeviceObjectOnStack(DeviceObject,
                                                 FileObjectExtension->TopDeviceObjectHint))
                {
                    /* Use this instead of returning the top level device */
                    return FileObjectExtension->TopDeviceObjectHint;
                }
            }
        }
 
        /* Return the highest attached device */
        DeviceObject = IoGetAttachedDevice(DeviceObject);
    }
 
    /* Return the DO we found */
    return DeviceObject;
}

Referenced by _In_reads_(), BroadcastOpen(), BuildAndSubmitIrp(), CcMdlReadComplete(), CcMdlWriteComplete(), CompBattGetDeviceObjectPointer(), EngpFileIoRequest(), FsRtlAcquireFileExclusiveCommon(), FsRtlAcquireFileForCcFlushEx(), FsRtlAcquireFileForModWriteEx(), FsRtlCopyRead(), FsRtlCopyRead2(), FsRtlCopyWrite(), FsRtlCopyWrite2(), FsRtlGetFileSize(), FsRtlMdlRead(), FsRtlMdlReadComplete(), FsRtlMdlReadDev(), FsRtlMdlWriteComplete(), FsRtlPrepareMdlWrite(), FsRtlPrepareMdlWriteDev(), FsRtlReleaseFile(), FsRtlReleaseFileForCcFlush(), FsRtlReleaseFileForModWrite(), FsRtlTest_StartTest(), IoPageRead(), IopCloseFile(), IopDeleteFile(), IopDeviceFsIoControl(), IopGetBasicInformationFile(), IopGetDeviceObjectPointer(), IopGetFileInformation(), IopGetRelatedTargetDevice(), IopGetSetSecurityObject(), IopOpenLinkOrRenameTarget(), IopParseDevice(), IopParseFile(), IopQueryDeviceInformation(), IoSetInformation(), IoSynchronousPageWrite(), KsAllocateObjectHeader(), KsQueryInformationFile(), KsReadFile(), KsSetInformationFile(), KsStreamIo(), KsSynchronousIoControlDevice(), KsWriteFile(), MmGetDeviceObjectForFile(), MupBuildIoControlRequest(), NtCreatePagingFile(), NtFlushBuffersFile(), NtLockFile(), NtNotifyChangeDirectoryFile(), NtQueryDirectoryFile(), NtQueryInformationFile(), NtQueryVolumeInformationFile(), NtReadFile(), NtSetInformationFile(), NtSetVolumeInformationFile(), NtUnlockFile(), NtWriteFile(), FxIoTargetRemote::OpenTargetHandle(), Pin_fnWrite(), PopAddRemoveSysCapsCallback(), RawSetInformation(), RegisterUncProvider(), TdiAccept(), TdiAssociateAddressFile(), TdiConnect(), TdiDisassociateAddressFile(), TdiDisconnect(), TdiListen(), TdiQueryDeviceControl(), TdiQueryInformation(), TdiReceive(), TdiReceiveDatagram(), TdiSend(), TdiSendDatagram(), TdiSetEventHandler(), TestProviderInfo(), TestTcpConnect(), VfatSetRenameInformation(), ViReadFile(), and WdmAudReadWrite().

IoGetRelatedTargetDevice()

NTSTATUS NTAPI IoGetRelatedTargetDevice	(	IN PFILE_OBJECT	FileObject,
		OUT PDEVICE_OBJECT *	DeviceObject
	)

Definition at line 1626 of file device.c.

{
    NTSTATUS Status;
    PDEVICE_NODE DeviceNode = NULL;
 
    /* Call the internal helper function */
    Status = IopGetRelatedTargetDevice(FileObject, &DeviceNode);
    if (NT_SUCCESS(Status) && DeviceNode)
    {
        *DeviceObject = DeviceNode->PhysicalDeviceObject;
    }
    return Status;
}

Referenced by FsRtlNotifyVolumeEvent(), and NtSetVolumeInformationFile().

IopAttachDeviceToDeviceStackSafe()

static PDEVICE_OBJECT NTAPI IopAttachDeviceToDeviceStackSafe ( _In_ PDEVICE_OBJECT  SourceDevice, _In_ PDEVICE_OBJECT  TargetDevice, _Out_opt_ PDEVICE_OBJECT *  AttachedToDeviceObject  )

static

Definition at line 71 of file device.c.

{
    PDEVICE_OBJECT AttachedDevice;
    PEXTENDED_DEVOBJ_EXTENSION SourceDeviceExtension;
    KIRQL OldIrql;
 
    /* Lock the device list while attaching the device */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueIoDatabaseLock);
 
    /* Get the attached device and source extension */
    AttachedDevice = IoGetAttachedDevice(TargetDevice);
    SourceDeviceExtension = IoGetDevObjExtension(SourceDevice);
    ASSERT(SourceDeviceExtension->AttachedTo == NULL);
 
    /* Make sure that it's in a correct state */
    if ((AttachedDevice->Flags & DO_DEVICE_INITIALIZING) ||
        (IoGetDevObjExtension(AttachedDevice)->ExtensionFlags &
         (DOE_UNLOAD_PENDING | DOE_DELETE_PENDING |
          DOE_REMOVE_PENDING | DOE_REMOVE_PROCESSED)))
    {
        /* The device is unloading or being removed */
        AttachedDevice = NULL;
    }
    else
    {
        /* Update the attached device fields */
        AttachedDevice->AttachedDevice = SourceDevice;
        AttachedDevice->Spare1++;
 
        /* Update the source with the attached data */
        SourceDevice->StackSize = AttachedDevice->StackSize + 1;
        SourceDevice->AlignmentRequirement = AttachedDevice->AlignmentRequirement;
        SourceDevice->SectorSize = AttachedDevice->SectorSize;
 
        /* Check for pending start flag and propagate it */
        if (IoGetDevObjExtension(AttachedDevice)->ExtensionFlags & DOE_START_PENDING)
            IoGetDevObjExtension(SourceDevice)->ExtensionFlags |= DOE_START_PENDING;
 
        /* Set the attachment in the device extension */
        SourceDeviceExtension->AttachedTo = AttachedDevice;
    }
 
    /* Return the attached device (under the lock) */
    if (AttachedToDeviceObject)
        *AttachedToDeviceObject = AttachedDevice;
 
    /* Release the device list lock */
    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
 
    return AttachedDevice;
}

Referenced by IoAttachDeviceToDeviceStack(), and IoAttachDeviceToDeviceStackSafe().

IopCreateDefaultDeviceSecurityDescriptor()

PSECURITY_DESCRIPTOR NTAPI IopCreateDefaultDeviceSecurityDescriptor	(	IN DEVICE_TYPE	DeviceType,
		IN ULONG	DeviceCharacteristics,
		IN BOOLEAN	HasDeviceName,
		IN PSECURITY_DESCRIPTOR	SecurityDescriptor,
		OUT PACL *	OutputDacl,
		OUT PULONG	OutputFlags
	)

Definition at line 785 of file device.c.

{
    PACL Dacl;
    ULONG AceId;
    NTSTATUS Status;
    PACCESS_ALLOWED_ACE Ace;
    BOOLEAN AdminsSet, WorldSet;
 
    PAGED_CODE();
 
    /* Zero our output vars */
    if (OutputFlags) *OutputFlags = 0;
 
    *OutputDacl = NULL;
 
    /* For FSD, easy use SePublicDefaultUnrestrictedDacl */
    if (DeviceType == FILE_DEVICE_TAPE_FILE_SYSTEM ||
        DeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM ||
        DeviceType == FILE_DEVICE_DISK_FILE_SYSTEM ||
        DeviceType == FILE_DEVICE_FILE_SYSTEM)
    {
        Status = IopCreateSecurityDescriptorPerType(SecurityDescriptor,
                                                    UnrestrictedPublic,
                                                    OutputFlags);
        goto Quit;
    }
    /* For storage devices with a name and floppy attribute,
     * use SePublicOpenUnrestrictedDacl
     */
    else if ((DeviceType != FILE_DEVICE_VIRTUAL_DISK &&
              DeviceType != FILE_DEVICE_MASS_STORAGE &&
              DeviceType != FILE_DEVICE_CD_ROM &&
              DeviceType != FILE_DEVICE_DISK &&
              DeviceType != FILE_DEVICE_DFS_FILE_SYSTEM &&
              DeviceType != FILE_DEVICE_NETWORK &&
              DeviceType != FILE_DEVICE_NETWORK_FILE_SYSTEM) ||
              (HasDeviceName && BooleanFlagOn(DeviceCharacteristics, FILE_FLOPPY_DISKETTE)))
    {
        Status = IopCreateSecurityDescriptorPerType(SecurityDescriptor,
                                                    UnrestrictedPublicOpen,
                                                    OutputFlags);
        goto Quit;
    }
 
    /* The rest...
     * We will rely on SePublicDefaultUnrestrictedDacl as well
     */
    Dacl = ExAllocatePoolWithTag(PagedPool, SePublicDefaultUnrestrictedDacl->AclSize, 'eSoI');
    if (Dacl == NULL)
    {
        return NULL;
    }
 
    /* Copy our DACL */
    RtlCopyMemory(Dacl, SePublicDefaultUnrestrictedDacl, SePublicDefaultUnrestrictedDacl->AclSize);
 
    /* Now, browse the DACL to make sure we have everything we want in them,
     * including permissions
     */
    AceId = 0;
    AdminsSet = FALSE;
    WorldSet = FALSE;
    while (NT_SUCCESS(RtlGetAce(Dacl, AceId, (PVOID *)&Ace)))
    {
        /* Admins must acess and in RWX, set it */
        if (RtlEqualSid(SeAliasAdminsSid, &Ace->SidStart))
        {
            SetFlag(Ace->Mask, (GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE));
            AdminsSet = TRUE;
        }
 
        /* World can read a CD_ROM device */
        if (DeviceType == FILE_DEVICE_CD_ROM && RtlEqualSid(SeWorldSid, &Ace->SidStart))
        {
            SetFlag(Ace->Mask, GENERIC_READ);
            WorldSet = TRUE;
        }
 
        ++AceId;
    }
 
    /* AdminSid was present and set (otherwise, we have big trouble) */
    ASSERT(AdminsSet);
 
    /* If CD_ROM device, we've set world permissions */
    if (DeviceType == FILE_DEVICE_CD_ROM) ASSERT(WorldSet);
 
    /* Now our DACL is correct, setup the security descriptor */
    RtlCreateSecurityDescriptor(SecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
    RtlSetDaclSecurityDescriptor(SecurityDescriptor, TRUE, Dacl, FALSE);
 
    /* We've set DACL */
    if (OutputFlags) *OutputFlags |= DACL_SET;
 
    /* Return DACL to allow later freeing */
    *OutputDacl = Dacl;
    Status = STATUS_SUCCESS;
 
Quit:
    /* Only return SD if we succeed */
    if (!NT_SUCCESS(Status))
    {
        return NULL;
    }
 
    return SecurityDescriptor;
}

Referenced by IoCreateDevice().

IopCreateSecurityDescriptorPerType()

NTSTATUS NTAPI IopCreateSecurityDescriptorPerType	(	IN PSECURITY_DESCRIPTOR	SecurityDescriptor,
		IN SECURITY_DESCRIPTOR_TYPE	Type,
		OUT PULONG	OutputFlags
	)

Definition at line 736 of file device.c.

{
    PACL Dacl;
    NTSTATUS Status;
 
    /* Select the DACL the caller wants */
    switch (Type)
    {
        case RestrictedPublic:
            Dacl = SePublicDefaultDacl;
            break;
 
        case UnrestrictedPublic:
            Dacl = SePublicDefaultUnrestrictedDacl;
            break;
 
        case RestrictedPublicOpen:
            Dacl = SePublicOpenDacl;
            break;
 
        case UnrestrictedPublicOpen:
            Dacl = SePublicOpenUnrestrictedDacl;
            break;
 
        case SystemDefault:
            Dacl = SeSystemDefaultDacl;
            break;
 
        default:
            ASSERT(FALSE);
            return STATUS_INVALID_PARAMETER;
    }
 
    /* Create the SD and set the DACL caller wanted */
    Status = RtlCreateSecurityDescriptor(SecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
    ASSERT(NT_SUCCESS(Status));
    Status = RtlSetDaclSecurityDescriptor(SecurityDescriptor, TRUE, Dacl, FALSE);
 
    /* We've set DACL */
    if (OutputFlags) *OutputFlags |= DACL_SET;
 
    /* Done */
    return Status;
}

Referenced by IopCreateDefaultDeviceSecurityDescriptor().

IopDeleteDevice()

VOID NTAPI IopDeleteDevice

(

IN PVOID

ObjectBody

)

Definition at line 52 of file device.c.

{
    PDEVICE_OBJECT DeviceObject = ObjectBody;
    PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
    PAGED_CODE();
 
    /* Cleanup and free the device node */
    if (DeviceNode)
        IopFreeDeviceNode(DeviceNode);
 
    PiPropReleaseDevice(DeviceObject);
 
    /* Dereference the driver object, referenced in IoCreateDevice */
    if (DeviceObject->DriverObject)
        ObDereferenceObject(DeviceObject->DriverObject);
}

Referenced by IopCreateObjectTypes().

IopDereferenceDeviceObject()

VOID NTAPI IopDereferenceDeviceObject	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	ForceUnload
	)

Definition at line 469 of file device.c.

{
    /* Sanity check */
    ASSERT(DeviceObject->ReferenceCount);
 
    /* Dereference the device */
    InterlockedDecrement(&DeviceObject->ReferenceCount);
 
    /*
     * Check if we can unload it and it's safe to unload (or if we're forcing
     * an unload, which is OK too).
     */
    ASSERT(!ForceUnload);
    if (!(DeviceObject->ReferenceCount) &&
        (IoGetDevObjExtension(DeviceObject)->ExtensionFlags & DOE_DELETE_PENDING))
    {
        /* Unload it */
        IopUnloadDevice(DeviceObject);
    }
}

Referenced by IoCreateStreamFileObjectEx(), IoCreateStreamFileObjectLite(), IopCheckVpbMounted(), IopDeleteFile(), and IopParseDevice().

IopEditDeviceList()

VOID NTAPI IopEditDeviceList	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	DeviceObject,
		IN IOP_DEVICE_LIST_OPERATION	Type
	)

Definition at line 341 of file device.c.

{
    PDEVICE_OBJECT Previous;
    KIRQL OldIrql;
 
    /* Lock the device list while we edit it */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueIoDatabaseLock);
 
    /* Check the type of operation */
    if (Type == IopRemove)
    {
        /* Get the current device and check if it's the current one */
        Previous = DeviceObject->DriverObject->DeviceObject;
        if (Previous == DeviceObject)
        {
            /* It is, simply unlink this one directly */
            DeviceObject->DriverObject->DeviceObject =
                DeviceObject->NextDevice;
        }
        else
        {
            /* It's not, so loop until we find the device */
            while (Previous->NextDevice != DeviceObject)
            {
                /* Not this one, keep moving */
                if (!Previous->NextDevice)
                {
                    DPRINT1("Failed to remove PDO %p (not found)\n",
                            DeviceObject);
 
                    ASSERT(FALSE);
                    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
                    return;
                }
                Previous = Previous->NextDevice;
            }
 
            /* We found it, now unlink us */
            Previous->NextDevice = DeviceObject->NextDevice;
        }
    }
    else
    {
        /* Link the device object and the driver object */
        DeviceObject->NextDevice = DriverObject->DeviceObject;
        DriverObject->DeviceObject = DeviceObject;
    }
 
    /* Release the device list lock */
    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
}

Referenced by IoCreateDevice(), and IopUnloadDevice().

IopGetDeviceObjectPointer()

NTSTATUS NTAPI IopGetDeviceObjectPointer	(	IN PUNICODE_STRING	ObjectName,
		IN ACCESS_MASK	DesiredAccess,
		OUT PFILE_OBJECT *	FileObject,
		OUT PDEVICE_OBJECT *	DeviceObject,
		IN ULONG	AttachFlag
	)

Definition at line 266 of file device.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK StatusBlock;
    PFILE_OBJECT LocalFileObject;
    HANDLE FileHandle;
    NTSTATUS Status;
 
    /* Open the Device */
    InitializeObjectAttributes(&ObjectAttributes,
                               ObjectName,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    /* Honor the internal I/O System case (in)sensitivity */
    if (IopCaseInsensitive) ObjectAttributes.Attributes |= OBJ_CASE_INSENSITIVE;
 
    Status = ZwOpenFile(&FileHandle,
                        DesiredAccess,
                        &ObjectAttributes,
                        &StatusBlock,
                        0,
                        FILE_NON_DIRECTORY_FILE | AttachFlag);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Get File Object */
    Status = ObReferenceObjectByHandle(FileHandle,
                                       0,
                                       IoFileObjectType,
                                       KernelMode,
                                       (PVOID*)&LocalFileObject,
                                       NULL);
    if (NT_SUCCESS(Status))
    {
        /* Return the requested data */
        *DeviceObject = IoGetRelatedDeviceObject(LocalFileObject);
        *FileObject = LocalFileObject;
    }
 
    /* Close the handle */
    ZwClose(FileHandle);
 
    return Status;
}

Referenced by IoAttachDevice(), and IoGetDeviceObjectPointer().

IopGetLowestDevice()

PDEVICE_OBJECT NTAPI IopGetLowestDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 318 of file device.c.

{
    PDEVICE_OBJECT LowestDevice;
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
 
    /* Get the current device and its extension */
    LowestDevice = DeviceObject;
    DeviceExtension = IoGetDevObjExtension(LowestDevice);
 
    /* Keep looping as long as we're attached */
    while (DeviceExtension->AttachedTo)
    {
        /* Get the lowest device and its extension */
        LowestDevice = DeviceExtension->AttachedTo;
        DeviceExtension = IoGetDevObjExtension(LowestDevice);
    }
 
    /* Return the lowest device */
    return LowestDevice;
}

Referenced by IoGetDeviceAttachmentBaseRef().

IopGetRelatedTargetDevice()

NTSTATUS NTAPI IopGetRelatedTargetDevice	(	IN PFILE_OBJECT	FileObject,
		OUT PDEVICE_NODE *	DeviceNode
	)

Definition at line 660 of file device.c.

{
    NTSTATUS Status;
    IO_STACK_LOCATION Stack = {0};
    PDEVICE_RELATIONS DeviceRelations;
    PDEVICE_OBJECT DeviceObject = NULL;
 
    ASSERT(FileObject);
 
    /* Get DeviceObject related to given FileObject */
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    if (!DeviceObject) return STATUS_NO_SUCH_DEVICE;
 
    /* Define input parameters */
    Stack.MajorFunction = IRP_MJ_PNP;
    Stack.MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS;
    Stack.Parameters.QueryDeviceRelations.Type = TargetDeviceRelation;
    Stack.FileObject = FileObject;
 
    /* Call the driver to query all relations (IRP_MJ_PNP) */
    Status = IopSynchronousCall(DeviceObject,
                                &Stack,
                                (PVOID)&DeviceRelations);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Make sure it's not NULL and contains only one object */
    ASSERT(DeviceRelations);
    ASSERT(DeviceRelations->Count == 1);
 
    /* Finally get the device node */
    *DeviceNode = IopGetDeviceNode(DeviceRelations->Objects[0]);
    if (!*DeviceNode) Status = STATUS_NO_SUCH_DEVICE;
 
    /* Free the DEVICE_RELATIONS structure, it's not needed anymore */
    ExFreePool(DeviceRelations);
 
    return Status;
}

Referenced by IoGetRelatedTargetDevice(), and IoRegisterPlugPlayNotification().

IopReadyDeviceObjects()

VOID NTAPI IopReadyDeviceObjects

(

IN PDRIVER_OBJECT

Driver

)

Definition at line 34 of file device.c.

{
    PDEVICE_OBJECT DeviceObject;
    PAGED_CODE();
 
    /* Set the driver as initialized */
    Driver->Flags |= DRVO_INITIALIZED;
    DeviceObject = Driver->DeviceObject;
    while (DeviceObject)
    {
        /* Set every device as initialized too */
        DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
        DeviceObject = DeviceObject->NextDevice;
    }
}

Referenced by IopInitializeDriverModule().

IopStartNextPacket()

VOID NTAPI IopStartNextPacket	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	Cancelable
	)

Definition at line 542 of file device.c.

{
    PKDEVICE_QUEUE_ENTRY Entry;
    PIRP Irp;
    KIRQL OldIrql;
 
    /* Acquire the cancel lock if this is cancelable */
    if (Cancelable) IoAcquireCancelSpinLock(&OldIrql);
 
    /* Clear the current IRP */
    DeviceObject->CurrentIrp = NULL;
 
    /* Remove an entry from the queue */
    Entry = KeRemoveDeviceQueue(&DeviceObject->DeviceQueue);
    if (Entry)
    {
        /* Get the IRP and set it */
        Irp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.DeviceQueueEntry);
        DeviceObject->CurrentIrp = Irp;
 
        /* Check if this is a cancelable packet */
        if (Cancelable)
        {
            /* Check if the caller requested no cancellation */
            if (IoGetDevObjExtension(DeviceObject)->StartIoFlags &
                DOE_SIO_NO_CANCEL)
            {
                /* He did, so remove the cancel routine */
                Irp->CancelRoutine = NULL;
            }
 
            /* Release the cancel lock */
            IoReleaseCancelSpinLock(OldIrql);
        }
 
        /* Call the Start I/O Routine */
        DeviceObject->DriverObject->DriverStartIo(DeviceObject, Irp);
    }
    else
    {
        /* Otherwise, release the cancel lock if we had acquired it */
        if (Cancelable) IoReleaseCancelSpinLock(OldIrql);
    }
}

Referenced by IopStartNextPacketByKeyEx(), and IoStartNextPacket().

IopStartNextPacketByKey()

VOID NTAPI IopStartNextPacketByKey	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	Cancelable,
		IN ULONG	Key
	)

Definition at line 493 of file device.c.

{
    PKDEVICE_QUEUE_ENTRY Entry;
    PIRP Irp;
    KIRQL OldIrql;
 
    /* Acquire the cancel lock if this is cancelable */
    if (Cancelable) IoAcquireCancelSpinLock(&OldIrql);
 
    /* Clear the current IRP */
    DeviceObject->CurrentIrp = NULL;
 
    /* Remove an entry from the queue */
    Entry = KeRemoveByKeyDeviceQueue(&DeviceObject->DeviceQueue, Key);
    if (Entry)
    {
        /* Get the IRP and set it */
        Irp = CONTAINING_RECORD(Entry, IRP, Tail.Overlay.DeviceQueueEntry);
        DeviceObject->CurrentIrp = Irp;
 
        /* Check if this is a cancelable packet */
        if (Cancelable)
        {
            /* Check if the caller requested no cancellation */
            if (IoGetDevObjExtension(DeviceObject)->StartIoFlags &
                DOE_SIO_NO_CANCEL)
            {
                /* He did, so remove the cancel routine */
                Irp->CancelRoutine = NULL;
            }
 
            /* Release the cancel lock */
            IoReleaseCancelSpinLock(OldIrql);
        }
 
        /* Call the Start I/O Routine */
        DeviceObject->DriverObject->DriverStartIo(DeviceObject, Irp);
    }
    else
    {
        /* Otherwise, release the cancel lock if we had acquired it */
        if (Cancelable) IoReleaseCancelSpinLock(OldIrql);
    }
}

Referenced by IopStartNextPacketByKeyEx(), and IoStartNextPacketByKey().

IopStartNextPacketByKeyEx()

VOID NTAPI IopStartNextPacketByKeyEx	(	IN PDEVICE_OBJECT	DeviceObject,
		IN ULONG	Key,
		IN ULONG	Flags
	)

Definition at line 590 of file device.c.

{
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
    ULONG CurrentKey = Key;
    ULONG CurrentFlags = Flags;
 
    /* Get the device extension and start the packet loop */
    DeviceExtension = IoGetDevObjExtension(DeviceObject);
    while (TRUE)
    {
        /* Increase the count */
        if (InterlockedIncrement(&DeviceExtension->StartIoCount) > 1)
        {
            /*
             * We've already called the routine once...
             * All we have to do is save the key and add the new flags
             */
            DeviceExtension->StartIoFlags |= CurrentFlags;
            DeviceExtension->StartIoKey = CurrentKey;
        }
        else
        {
            /* Mask out the current packet flags and key */
            DeviceExtension->StartIoFlags &= ~(DOE_SIO_WITH_KEY |
                                               DOE_SIO_NO_KEY |
                                               DOE_SIO_CANCELABLE);
            DeviceExtension->StartIoKey = 0;
 
            /* Check if this is a packet start with key */
            if (Flags & DOE_SIO_WITH_KEY)
            {
                /* Start the packet with a key */
                IopStartNextPacketByKey(DeviceObject,
                                        (Flags & DOE_SIO_CANCELABLE) ?
                                        TRUE : FALSE,
                                        CurrentKey);
            }
            else if (Flags & DOE_SIO_NO_KEY)
            {
                /* Start the packet */
                IopStartNextPacket(DeviceObject,
                                   (Flags & DOE_SIO_CANCELABLE) ?
                                   TRUE : FALSE);
            }
        }
 
        /* Decrease the Start I/O count and check if it's 0 now */
        if (!InterlockedDecrement(&DeviceExtension->StartIoCount))
        {
            /* Get the current active key and flags */
            CurrentKey = DeviceExtension->StartIoKey;
            CurrentFlags = DeviceExtension->StartIoFlags & (DOE_SIO_WITH_KEY |
                                                            DOE_SIO_NO_KEY |
                                                            DOE_SIO_CANCELABLE);
 
            /* Check if we should still loop */
            if (!(CurrentFlags & (DOE_SIO_WITH_KEY | DOE_SIO_NO_KEY))) break;
        }
        else
        {
            /* There are still Start I/Os active, so quit this loop */
            break;
        }
    }
}

Referenced by IoStartNextPacket(), and IoStartNextPacketByKey().

IopUnloadDevice()

VOID NTAPI IopUnloadDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 397 of file device.c.

{
    PDRIVER_OBJECT DriverObject = DeviceObject->DriverObject;
    PEXTENDED_DEVOBJ_EXTENSION ThisExtension = IoGetDevObjExtension(DeviceObject);
 
    /* Check if deletion is pending */
    if (ThisExtension->ExtensionFlags & DOE_DELETE_PENDING)
    {
        if (DeviceObject->AttachedDevice)
        {
            DPRINT("Device object is in the middle of a device stack\n");
            return;
        }
 
        if (DeviceObject->ReferenceCount)
        {
            DPRINT("Device object still has %d references\n", DeviceObject->ReferenceCount);
            return;
        }
 
        /* Check if we have a Security Descriptor */
        if (DeviceObject->SecurityDescriptor)
        {
            /* Dereference it */
            ObDereferenceSecurityDescriptor(DeviceObject->SecurityDescriptor, 1);
        }
 
        /* Remove the device from the list */
        IopEditDeviceList(DeviceObject->DriverObject, DeviceObject, IopRemove);
 
        /* Dereference the keep-alive */
        ObDereferenceObject(DeviceObject);
    }
 
    /* We can't unload a non-PnP driver here */
    if (DriverObject->Flags & DRVO_LEGACY_DRIVER)
    {
        DPRINT("Not a PnP driver! '%wZ' will not be unloaded!\n", &DriverObject->DriverName);
        return;
    }
 
    /* Return if we've already called unload (maybe we're in it?) */
    if (DriverObject->Flags & DRVO_UNLOAD_INVOKED) return;
 
    /* We can't unload unless there's an unload handler */
    if (!DriverObject->DriverUnload)
    {
        DPRINT1("No DriverUnload function on PnP driver! '%wZ' will not be unloaded!\n", &DriverObject->DriverName);
        return;
    }
 
    /* Bail if there are still devices present */
    if (DriverObject->DeviceObject)
    {
        DPRINT("Devices still present! '%wZ' will not be unloaded!\n", &DriverObject->DriverName);
        return;
    }
 
    DPRINT1("Unloading driver '%wZ' (automatic)\n", &DriverObject->DriverName);
 
    /* Set the unload invoked flag */
    DriverObject->Flags |= DRVO_UNLOAD_INVOKED;
 
    /* Unload it */
    DriverObject->DriverUnload(DriverObject);
 
    /* Make object temporary so it can be deleted */
    ObMakeTemporaryObject(DriverObject);
}

Referenced by IoDeleteDevice(), IoDetachDevice(), IopDecrementDeviceObjectRef(), and IopDereferenceDeviceObject().

IopVerifyDeviceObjectOnStack()

BOOLEAN NTAPI IopVerifyDeviceObjectOnStack	(	IN PDEVICE_OBJECT	BaseDeviceObject,
		IN PDEVICE_OBJECT	TopDeviceObjectHint
	)

Definition at line 702 of file device.c.

{
    KIRQL OldIrql;
    BOOLEAN Result;
    PDEVICE_OBJECT LoopObject;
 
    ASSERT(BaseDeviceObject != NULL);
 
    Result = FALSE;
    /* Simply loop on the device stack and try to find our hint */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueIoDatabaseLock);
    for (LoopObject = BaseDeviceObject; ; LoopObject = LoopObject->AttachedDevice)
    {
        /* It was found, it's a success */
        if (LoopObject == TopDeviceObjectHint)
        {
            Result = TRUE;
            break;
        }
 
        /* End of the stack, that's a failure - default */
        if (LoopObject == NULL)
        {
            break;
        }
    }
    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
 
    return Result;
}

Referenced by IoGetRelatedDeviceObject(), and IopCheckTopDeviceHint().

IoRegisterLastChanceShutdownNotification()

NTSTATUS NTAPI IoRegisterLastChanceShutdownNotification

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 1682 of file device.c.

{
    PSHUTDOWN_ENTRY Entry;
 
    /* Allocate the shutdown entry */
    Entry = ExAllocatePoolWithTag(NonPagedPool,
                                  sizeof(SHUTDOWN_ENTRY),
                                  TAG_SHUTDOWN_ENTRY);
    if (!Entry) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Set the DO */
    Entry->DeviceObject = DeviceObject;
 
    /* Reference it so it doesn't go away */
    ObReferenceObject(DeviceObject);
 
    /* Insert it into the list */
    ExInterlockedInsertHeadList(&LastChanceShutdownListHead,
                                &Entry->ShutdownList,
                                &ShutdownListLock);
 
    /* Set the shutdown registered flag */
    DeviceObject->Flags |= DO_SHUTDOWN_REGISTERED;
    return STATUS_SUCCESS;
}

Referenced by FxPkgGeneral::PostCreateDeviceInitialize().

IoRegisterShutdownNotification()

NTSTATUS NTAPI IoRegisterShutdownNotification

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 1713 of file device.c.

{
    PSHUTDOWN_ENTRY Entry;
 
    /* Allocate the shutdown entry */
    Entry = ExAllocatePoolWithTag(NonPagedPool,
                                  sizeof(SHUTDOWN_ENTRY),
                                  TAG_SHUTDOWN_ENTRY);
    if (!Entry) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Set the DO */
    Entry->DeviceObject = DeviceObject;
 
    /* Reference it so it doesn't go away */
    ObReferenceObject(DeviceObject);
 
    /* Insert it into the list */
    ExInterlockedInsertHeadList(&ShutdownListHead,
                                &Entry->ShutdownList,
                                &ShutdownListLock);
 
    /* Set the shutdown registered flag */
    DeviceObject->Flags |= DO_SHUTDOWN_REGISTERED;
    return STATUS_SUCCESS;
}

Referenced by _Function_class_(), DriverEntry(), NdisMRegisterAdapterShutdownHandler(), PcAddAdapterDevice(), FxPkgGeneral::PostCreateDeviceInitialize(), SysAudio_AddDevice(), and UDFMountVolume().

IoSetStartIoAttributes()

VOID NTAPI IoSetStartIoAttributes	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	DeferredStartIo,
		IN BOOLEAN	NonCancelable
	)

Definition at line 1817 of file device.c.

{
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
 
    /* Get the Device Extension */
    DeviceExtension = IoGetDevObjExtension(DeviceObject);
 
    /* Set the flags the caller requested */
    DeviceExtension->StartIoFlags |= (DeferredStartIo) ? DOE_SIO_DEFERRED : 0;
    DeviceExtension->StartIoFlags |= (NonCancelable) ? DOE_SIO_NO_CANCEL : 0;
}

Referenced by ClassAddDevice().

IoShutdownPnpDevices()

VOID NTAPI IoShutdownPnpDevices

(

VOID

)

Definition at line 128 of file device.c.

{
    /* This routine is only used by Driver Verifier to validate shutdown */
    return;
}

Referenced by IoShutdownSystem().

IoShutdownSystem()

VOID NTAPI IoShutdownSystem

(

IN ULONG

Phase

)

Definition at line 136 of file device.c.

{
    PLIST_ENTRY ListEntry;
    PDEVICE_OBJECT DeviceObject;
    PSHUTDOWN_ENTRY ShutdownEntry;
    IO_STATUS_BLOCK StatusBlock;
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
 
    /* Initialize an event to wait on */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* What phase? */
    if (Phase == 0)
    {
        /* Shutdown PnP */
        IoShutdownPnpDevices();
 
        /* Loop first-chance shutdown notifications */
        ListEntry = ExInterlockedRemoveHeadList(&ShutdownListHead,
                                                &ShutdownListLock);
        while (ListEntry)
        {
            /* Get the shutdown entry */
            ShutdownEntry = CONTAINING_RECORD(ListEntry,
                                              SHUTDOWN_ENTRY,
                                              ShutdownList);
 
            /* Get the attached device */
            DeviceObject = IoGetAttachedDevice(ShutdownEntry->DeviceObject);
 
            /* Build the shutdown IRP and call the driver */
            Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SHUTDOWN,
                                               DeviceObject,
                                               NULL,
                                               0,
                                               NULL,
                                               &Event,
                                               &StatusBlock);
            if (Irp)
            {
                Status = IoCallDriver(DeviceObject, Irp);
                if (Status == STATUS_PENDING)
                {
                    /* Wait on the driver */
                    KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
                }
            }
 
            /* Remove the flag */
            ShutdownEntry->DeviceObject->Flags &= ~DO_SHUTDOWN_REGISTERED;
 
            /* Get rid of our reference to it */
            ObDereferenceObject(ShutdownEntry->DeviceObject);
 
            /* Free the shutdown entry and reset the event */
            ExFreePoolWithTag(ShutdownEntry, TAG_SHUTDOWN_ENTRY);
            KeClearEvent(&Event);
 
            /* Go to the next entry */
            ListEntry = ExInterlockedRemoveHeadList(&ShutdownListHead,
                                                    &ShutdownListLock);
         }
    }
    else if (Phase == 1)
    {
        /* Acquire resource forever */
        ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);
 
        /* Shutdown disk file systems */
        IopShutdownBaseFileSystems(&IopDiskFileSystemQueueHead);
 
        /* Shutdown cdrom file systems */
        IopShutdownBaseFileSystems(&IopCdRomFileSystemQueueHead);
 
        /* Shutdown tape filesystems */
        IopShutdownBaseFileSystems(&IopTapeFileSystemQueueHead);
 
        /* Loop last-chance shutdown notifications */
        ListEntry = ExInterlockedRemoveHeadList(&LastChanceShutdownListHead,
                                                &ShutdownListLock);
        while (ListEntry)
        {
            /* Get the shutdown entry */
            ShutdownEntry = CONTAINING_RECORD(ListEntry,
                                              SHUTDOWN_ENTRY,
                                              ShutdownList);
 
            /* Get the attached device */
            DeviceObject = IoGetAttachedDevice(ShutdownEntry->DeviceObject);
 
            /* Build the shutdown IRP and call the driver */
            Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SHUTDOWN,
                                               DeviceObject,
                                               NULL,
                                               0,
                                               NULL,
                                               &Event,
                                               &StatusBlock);
            if (Irp)
            {
                Status = IoCallDriver(DeviceObject, Irp);
                if (Status == STATUS_PENDING)
                {
                    /* Wait on the driver */
                    KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
                }
            }
 
            /* Remove the flag */
            ShutdownEntry->DeviceObject->Flags &= ~DO_SHUTDOWN_REGISTERED;
 
            /* Get rid of our reference to it */
            ObDereferenceObject(ShutdownEntry->DeviceObject);
 
            /* Free the shutdown entry and reset the event */
            ExFreePoolWithTag(ShutdownEntry, TAG_SHUTDOWN_ENTRY);
            KeClearEvent(&Event);
 
            /* Go to the next entry */
            ListEntry = ExInterlockedRemoveHeadList(&LastChanceShutdownListHead,
                                                    &ShutdownListLock);
         }
 
    }
}

Referenced by PopGracefulShutdown().

IoStartNextPacket()

VOID NTAPI IoStartNextPacket	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	Cancelable
	)

Definition at line 1866 of file device.c.

{
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
 
    /* Get the Device Extension */
    DeviceExtension = IoGetDevObjExtension(DeviceObject);
 
    /* Check if deferred start was requested */
    if (DeviceExtension->StartIoFlags & DOE_SIO_DEFERRED)
    {
        /* Call our internal function to handle the defered case */
        IopStartNextPacketByKeyEx(DeviceObject,
                                  0,
                                  DOE_SIO_NO_KEY |
                                  (Cancelable ? DOE_SIO_CANCELABLE : 0));
    }
    else
    {
        /* Call the normal routine */
        IopStartNextPacket(DeviceObject, Cancelable);
    }
}

Referenced by BeepCancel(), BeepStartIo(), ClassIoComplete(), ClassIoCompleteAssociated(), ClasspStartIo(), i8042PacketDpc(), ScsiPortDpcForIsr(), ScsiPortStartIo(), SpiProcessCompletedRequest(), TransferPktComplete(), and USBSTOR_QueueNextRequest().

IoStartNextPacketByKey()

VOID NTAPI IoStartNextPacketByKey	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	Cancelable,
		IN ULONG	Key
	)

Definition at line 1836 of file device.c.

{
    PEXTENDED_DEVOBJ_EXTENSION DeviceExtension;
 
    /* Get the Device Extension */
    DeviceExtension = IoGetDevObjExtension(DeviceObject);
 
    /* Check if deferred start was requested */
    if (DeviceExtension->StartIoFlags & DOE_SIO_DEFERRED)
    {
        /* Call our internal function to handle the defered case */
        IopStartNextPacketByKeyEx(DeviceObject,
                                  Key,
                                  DOE_SIO_WITH_KEY |
                                  (Cancelable ? DOE_SIO_CANCELABLE : 0));
    }
    else
    {
        /* Call the normal routine */
        IopStartNextPacketByKey(DeviceObject, Cancelable, Key);
    }
}

IoStartPacket()

VOID NTAPI IoStartPacket	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PULONG	Key,
		IN PDRIVER_CANCEL	CancelFunction
	)

Definition at line 1895 of file device.c.

{
    BOOLEAN Stat;
    KIRQL OldIrql, CancelIrql;
 
    /* Raise to dispatch level */
    KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
 
    /* Check if we should acquire the cancel lock */
    if (CancelFunction)
    {
        /* Acquire and set it */
        IoAcquireCancelSpinLock(&CancelIrql);
        Irp->CancelRoutine = CancelFunction;
    }
 
    /* Check if we have a key */
    if (Key)
    {
        /* Insert by key */
        Stat = KeInsertByKeyDeviceQueue(&DeviceObject->DeviceQueue,
                                        &Irp->Tail.Overlay.DeviceQueueEntry,
                                        *Key);
    }
    else
    {
        /* Insert without a key */
        Stat = KeInsertDeviceQueue(&DeviceObject->DeviceQueue,
                                   &Irp->Tail.Overlay.DeviceQueueEntry);
    }
 
    /* Check if this was a first insert */
    if (!Stat)
    {
        /* Set the IRP */
        DeviceObject->CurrentIrp = Irp;
 
        /* Check if this is a cancelable packet */
        if (CancelFunction)
        {
            /* Check if the caller requested no cancellation */
            if (IoGetDevObjExtension(DeviceObject)->StartIoFlags &
                DOE_SIO_NO_CANCEL)
            {
                /* He did, so remove the cancel routine */
                Irp->CancelRoutine = NULL;
            }
 
            /* Release the cancel lock */
            IoReleaseCancelSpinLock(CancelIrql);
        }
 
        /* Call the Start I/O function */
        DeviceObject->DriverObject->DriverStartIo(DeviceObject, Irp);
    }
    else
    {
        /* The packet was inserted... check if we have a cancel function */
        if (CancelFunction)
        {
            /* Check if the IRP got cancelled */
            if (Irp->Cancel)
            {
                /*
                 * Set the cancel IRQL, clear the currnet cancel routine and
                 * call ours
                 */
                Irp->CancelIrql = CancelIrql;
                Irp->CancelRoutine = NULL;
                CancelFunction(DeviceObject, Irp);
            }
            else
            {
                /* Otherwise, release the lock */
                IoReleaseCancelSpinLock(CancelIrql);
            }
        }
    }
 
    /* Return back to previous IRQL */
    KeLowerIrql(OldIrql);
}

Referenced by BeepDeviceControl(), ClassReadWrite(), i8042KbdInternalDeviceControl(), ScsiPortDispatchScsi(), ScsiPortIoTimer(), SermouseInternalDeviceControl(), SpiGetNextRequestFromLun(), USBSTOR_HandleInternalDeviceControl(), USBSTOR_QueueNextRequest(), and USBSTOR_QueueRelease().

IoUnregisterShutdownNotification()

VOID NTAPI IoUnregisterShutdownNotification

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 1744 of file device.c.

{
    PSHUTDOWN_ENTRY ShutdownEntry;
    PLIST_ENTRY NextEntry;
    KIRQL OldIrql;
 
    /* Remove the flag */
    DeviceObject->Flags &= ~DO_SHUTDOWN_REGISTERED;
 
    /* Acquire the shutdown lock and loop the shutdown list */
    KeAcquireSpinLock(&ShutdownListLock, &OldIrql);
    NextEntry = ShutdownListHead.Flink;
    while (NextEntry != &ShutdownListHead)
    {
        /* Get the entry */
        ShutdownEntry = CONTAINING_RECORD(NextEntry,
                                          SHUTDOWN_ENTRY,
                                          ShutdownList);
 
        /* Get if the DO matches */
        if (ShutdownEntry->DeviceObject == DeviceObject)
        {
            /* Remove it from the list */
            RemoveEntryList(NextEntry);
            NextEntry = NextEntry->Blink;
 
            /* Free the entry */
            ExFreePoolWithTag(ShutdownEntry, TAG_SHUTDOWN_ENTRY);
 
            /* Get rid of our reference to it */
            ObDereferenceObject(DeviceObject);
        }
 
        /* Go to the next entry */
        NextEntry = NextEntry->Flink;
    }
 
    /* Now loop the last chance list */
    NextEntry = LastChanceShutdownListHead.Flink;
    while (NextEntry != &LastChanceShutdownListHead)
    {
        /* Get the entry */
        ShutdownEntry = CONTAINING_RECORD(NextEntry,
                                          SHUTDOWN_ENTRY,
                                          ShutdownList);
 
        /* Get if the DO matches */
        if (ShutdownEntry->DeviceObject == DeviceObject)
        {
            /* Remove it from the list */
            RemoveEntryList(NextEntry);
            NextEntry = NextEntry->Blink;
 
            /* Free the entry */
            ExFreePoolWithTag(ShutdownEntry, TAG_SHUTDOWN_ENTRY);
 
            /* Get rid of our reference to it */
            ObDereferenceObject(DeviceObject);
        }
 
        /* Go to the next entry */
        NextEntry = NextEntry->Flink;
    }
 
    /* Release the shutdown lock */
    KeReleaseSpinLock(&ShutdownListLock, OldIrql);
}

Referenced by FreeDeviceData(), IoDeleteDevice(), MountMgrUnload(), NdisMDeregisterAdapterShutdownHandler(), FxPkgGeneral::PostCreateDeviceInitialize(), UDFCleanupVCB(), and UDFDoDismountSequence().

Variable Documentation

IopCdRomFileSystemQueueHead

LIST_ENTRY IopCdRomFileSystemQueueHead

extern

Definition at line 22 of file volume.c.

Referenced by IoShutdownSystem().

IopDatabaseResource

ERESOURCE IopDatabaseResource

extern

Definition at line 20 of file volume.c.

Referenced by IoShutdownSystem().

IopDeviceObjectNumber

ULONG IopDeviceObjectNumber = 0

Definition at line 20 of file device.c.

Referenced by IoCreateDevice().

IopDiskFileSystemQueueHead

LIST_ENTRY IopDiskFileSystemQueueHead

extern

Definition at line 21 of file volume.c.

Referenced by IoShutdownSystem().

IopTapeFileSystemQueueHead

LIST_ENTRY IopTapeFileSystemQueueHead

extern

Definition at line 22 of file volume.c.

Referenced by IoShutdownSystem().

LastChanceShutdownListHead

LIST_ENTRY LastChanceShutdownListHead

Definition at line 21 of file device.c.

Referenced by IoInitSystem(), IoRegisterLastChanceShutdownNotification(), IoShutdownSystem(), and IoUnregisterShutdownNotification().

ShutdownListHead

LIST_ENTRY ShutdownListHead

Definition at line 21 of file device.c.

Referenced by IoInitSystem(), IoRegisterShutdownNotification(), IoShutdownSystem(), and IoUnregisterShutdownNotification().

ShutdownListLock

KSPIN_LOCK ShutdownListLock

Definition at line 22 of file device.c.

Referenced by IoInitSystem(), IoRegisterLastChanceShutdownNotification(), IoRegisterShutdownNotification(), IoShutdownSystem(), and IoUnregisterShutdownNotification().