reactos/ntoskrnl/io/iomgr/device.c
2020-03-21 14:32:18 +01:00

1974 lines
58 KiB
C

/*
* PROJECT: ReactOS Kernel
* LICENSE: GPL - See COPYING in the top level directory
* FILE: ntoskrnl/io/iomgr/device.c
* PURPOSE: Device Object Management, including Notifications and Queues.
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
* Filip Navara (navaraf@reactos.org)
* Hervé Poussineau (hpoussin@reactos.org)
* Pierre Schweitzer
*/
/* INCLUDES *******************************************************************/
#include <ntoskrnl.h>
#define NDEBUG
#include <debug.h>
/* GLOBALS ********************************************************************/
ULONG IopDeviceObjectNumber = 0;
LIST_ENTRY ShutdownListHead, LastChanceShutdownListHead;
KSPIN_LOCK ShutdownListLock;
extern LIST_ENTRY IopDiskFileSystemQueueHead;
extern LIST_ENTRY IopCdRomFileSystemQueueHead;
extern LIST_ENTRY IopTapeFileSystemQueueHead;
extern ERESOURCE IopDatabaseResource;
#define DACL_SET 4
/* PRIVATE FUNCTIONS **********************************************************/
VOID
NTAPI
IopReadyDeviceObjects(IN PDRIVER_OBJECT Driver)
{
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;
}
}
VOID
NTAPI
IopDeleteDevice(IN PVOID ObjectBody)
{
PDEVICE_OBJECT DeviceObject = ObjectBody;
PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
PAGED_CODE();
/* Cleanup and free the device node */
if (DeviceNode)
IopFreeDeviceNode(DeviceNode);
/* Dereference the driver object, referenced in IoCreateDevice */
if (DeviceObject->DriverObject)
ObDereferenceObject(DeviceObject->DriverObject);
}
PDEVICE_OBJECT
NTAPI
IopAttachDeviceToDeviceStackSafe(IN PDEVICE_OBJECT SourceDevice,
IN PDEVICE_OBJECT TargetDevice,
OUT PDEVICE_OBJECT *AttachedToDeviceObject OPTIONAL)
{
PDEVICE_OBJECT AttachedDevice;
PEXTENDED_DEVOBJ_EXTENSION SourceDeviceExtension;
/* 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)))
{
/* Device was unloading or being removed */
AttachedDevice = NULL;
}
else
{
/* Update atached 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 */
if (IoGetDevObjExtension(AttachedDevice)->ExtensionFlags &
DOE_START_PENDING)
{
/* Propagate */
IoGetDevObjExtension(SourceDevice)->ExtensionFlags |=
DOE_START_PENDING;
}
/* Set the attachment in the device extension */
SourceDeviceExtension->AttachedTo = AttachedDevice;
}
/* Return the attached device */
if (AttachedToDeviceObject) *AttachedToDeviceObject = AttachedDevice;
return AttachedDevice;
}
VOID
NTAPI
IoShutdownPnpDevices(VOID)
{
/* This routine is only used by Driver Verifier to validate shutdown */
return;
}
VOID
NTAPI
IoShutdownSystem(IN ULONG Phase)
{
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);
}
}
}
NTSTATUS
NTAPI
IopGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName,
IN ACCESS_MASK DesiredAccess,
OUT PFILE_OBJECT *FileObject,
OUT PDEVICE_OBJECT *DeviceObject,
IN ULONG AttachFlag)
{
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);
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;
}
PDEVICE_OBJECT
NTAPI
IopGetLowestDevice(IN PDEVICE_OBJECT DeviceObject)
{
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;
}
VOID
NTAPI
IopEditDeviceList(IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT DeviceObject,
IN IOP_DEVICE_LIST_OPERATION Type)
{
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);
}
VOID
NTAPI
IopUnloadDevice(IN PDEVICE_OBJECT DeviceObject)
{
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);
}
VOID
NTAPI
IopDereferenceDeviceObject(IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN ForceUnload)
{
/* 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);
}
}
VOID
NTAPI
IopStartNextPacketByKey(IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN Cancelable,
IN ULONG Key)
{
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);
}
}
VOID
NTAPI
IopStartNextPacket(IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN Cancelable)
{
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);
}
}
VOID
NTAPI
IopStartNextPacketByKeyEx(IN PDEVICE_OBJECT DeviceObject,
IN ULONG Key,
IN ULONG Flags)
{
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;
}
}
}
NTSTATUS
NTAPI
IopGetRelatedTargetDevice(IN PFILE_OBJECT FileObject,
OUT PDEVICE_NODE *DeviceNode)
{
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;
}
BOOLEAN
NTAPI
IopVerifyDeviceObjectOnStack(IN PDEVICE_OBJECT BaseDeviceObject,
IN PDEVICE_OBJECT TopDeviceObjectHint)
{
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;
}
NTSTATUS
NTAPI
IopCreateSecurityDescriptorPerType(IN PSECURITY_DESCRIPTOR SecurityDescriptor,
IN SECURITY_DESCRIPTOR_TYPE Type,
OUT PULONG OutputFlags)
{
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;
}
PSECURITY_DESCRIPTOR
NTAPI
IopCreateDefaultDeviceSecurityDescriptor(IN DEVICE_TYPE DeviceType,
IN ULONG DeviceCharacteristics,
IN BOOLEAN HasDeviceName,
IN PSECURITY_DESCRIPTOR SecurityDescriptor,
OUT PACL * OutputDacl,
OUT PULONG OutputFlags)
{
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;
}
/* PUBLIC FUNCTIONS ***********************************************************/
/*
* IoAttachDevice
*
* Layers a device over the highest device in a device stack.
*
* Parameters
* SourceDevice
* Device to be attached.
*
* TargetDevice
* Name of the target device.
*
* AttachedDevice
* Caller storage for the device attached to.
*
* Status
* @implemented
*/
NTSTATUS
NTAPI
IoAttachDevice(PDEVICE_OBJECT SourceDevice,
PUNICODE_STRING TargetDeviceName,
PDEVICE_OBJECT *AttachedDevice)
{
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;
}
/*
* IoAttachDeviceByPointer
*
* Status
* @implemented
*/
NTSTATUS
NTAPI
IoAttachDeviceByPointer(IN PDEVICE_OBJECT SourceDevice,
IN PDEVICE_OBJECT TargetDevice)
{
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;
}
/*
* @implemented
*/
PDEVICE_OBJECT
NTAPI
IoAttachDeviceToDeviceStack(IN PDEVICE_OBJECT SourceDevice,
IN PDEVICE_OBJECT TargetDevice)
{
/* Attach it safely */
return IopAttachDeviceToDeviceStackSafe(SourceDevice,
TargetDevice,
NULL);
}
/*
* @implemented
*/
NTSTATUS
NTAPI
IoAttachDeviceToDeviceStackSafe(IN PDEVICE_OBJECT SourceDevice,
IN PDEVICE_OBJECT TargetDevice,
IN OUT PDEVICE_OBJECT *AttachedToDeviceObject)
{
/* Call the internal function */
if (!IopAttachDeviceToDeviceStackSafe(SourceDevice,
TargetDevice,
AttachedToDeviceObject))
{
/* Nothing found */
return STATUS_NO_SUCH_DEVICE;
}
/* Success! */
return STATUS_SUCCESS;
}
/*
* IoCreateDevice
*
* Allocates memory for and intializes a device object for use for
* a driver.
*
* Parameters
* DriverObject
* Driver object passed by IO Manager when the driver was loaded.
*
* DeviceExtensionSize
* Number of bytes for the device extension.
*
* DeviceName
* Unicode name of device.
*
* DeviceType
* Device type of the new device.
*
* DeviceCharacteristics
* Bit mask of device characteristics.
*
* Exclusive
* TRUE if only one thread can access the device at a time.
*
* DeviceObject
* On successful return this parameter is filled by pointer to
* allocated device object.
*
* Status
* @implemented
*/
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)
{
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 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;
}
/*
* IoDeleteDevice
*
* Status
* @implemented
*/
VOID
NTAPI
IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
{
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);
}
/*
* IoDetachDevice
*
* Status
* @implemented
*/
VOID
NTAPI
IoDetachDevice(IN PDEVICE_OBJECT TargetDevice)
{
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);
}
}
/*
* @implemented
*/
NTSTATUS
NTAPI
IoEnumerateDeviceObjectList(IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT *DeviceObjectList,
IN ULONG DeviceObjectListSize,
OUT PULONG ActualNumberDeviceObjects)
{
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;
}
/*
* IoGetAttachedDevice
*
* Status
* @implemented
*/
PDEVICE_OBJECT
NTAPI
IoGetAttachedDevice(PDEVICE_OBJECT DeviceObject)
{
/* Get the last attached device */
while (DeviceObject->AttachedDevice)
{
/* Move to the next one */
DeviceObject = DeviceObject->AttachedDevice;
}
/* Return it */
return DeviceObject;
}
/*
* IoGetAttachedDeviceReference
*
* Status
* @implemented
*/
PDEVICE_OBJECT
NTAPI
IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
{
/* Reference the Attached Device */
DeviceObject = IoGetAttachedDevice(DeviceObject);
ObReferenceObject(DeviceObject);
return DeviceObject;
}
/*
* @implemented
*/
PDEVICE_OBJECT
NTAPI
IoGetDeviceAttachmentBaseRef(IN PDEVICE_OBJECT DeviceObject)
{
/* Reference the lowest attached device */
DeviceObject = IopGetLowestDevice(DeviceObject);
ObReferenceObject(DeviceObject);
return DeviceObject;
}
/*
* IoGetDeviceObjectPointer
*
* Status
* @implemented
*/
NTSTATUS
NTAPI
IoGetDeviceObjectPointer(IN PUNICODE_STRING ObjectName,
IN ACCESS_MASK DesiredAccess,
OUT PFILE_OBJECT *FileObject,
OUT PDEVICE_OBJECT *DeviceObject)
{
/* Call the helper routine for a normal operation */
return IopGetDeviceObjectPointer(ObjectName,
DesiredAccess,
FileObject,
DeviceObject,
0);
}
/*
* @implemented
*/
NTSTATUS
NTAPI
IoGetDiskDeviceObject(IN PDEVICE_OBJECT FileSystemDeviceObject,
OUT PDEVICE_OBJECT *DiskDeviceObject)
{
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;
}
/*
* @implemented
*/
PDEVICE_OBJECT
NTAPI
IoGetLowerDeviceObject(IN PDEVICE_OBJECT DeviceObject)
{
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;
}
/*
* @implemented
*/
PDEVICE_OBJECT
NTAPI
IoGetRelatedDeviceObject(IN PFILE_OBJECT FileObject)
{
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;
}
/*
* @implemented
*/
NTSTATUS
NTAPI
IoGetRelatedTargetDevice(IN PFILE_OBJECT FileObject,
OUT PDEVICE_OBJECT *DeviceObject)
{
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;
}
/*
* @implemented
*/
PDEVICE_OBJECT
NTAPI
IoGetBaseFileSystemDeviceObject(IN PFILE_OBJECT FileObject)
{
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;
}
/*
* @implemented
*/
NTSTATUS
NTAPI
IoRegisterLastChanceShutdownNotification(IN PDEVICE_OBJECT DeviceObject)
{
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;
}
/*
* @implemented
*/
NTSTATUS
NTAPI
IoRegisterShutdownNotification(PDEVICE_OBJECT DeviceObject)
{
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;
}
/*
* @implemented
*/
VOID
NTAPI
IoUnregisterShutdownNotification(PDEVICE_OBJECT DeviceObject)
{
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);
}
/*
* @implemented
*/
VOID
NTAPI
IoSetStartIoAttributes(IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN DeferredStartIo,
IN BOOLEAN NonCancelable)
{
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;
}
/*
* @implemented
*/
VOID
NTAPI
IoStartNextPacketByKey(IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN Cancelable,
IN ULONG Key)
{
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);
}
}
/*
* @implemented
*/
VOID
NTAPI
IoStartNextPacket(IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN Cancelable)
{
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);
}
}
/*
* @implemented
*/
VOID
NTAPI
IoStartPacket(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PULONG Key,
IN PDRIVER_CANCEL CancelFunction)
{
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);
}
#if defined (_WIN64)
ULONG
NTAPI
IoWMIDeviceObjectToProviderId(
IN PDEVICE_OBJECT DeviceObject)
{
UNIMPLEMENTED;
return 0;
}
#endif
/* EOF */