Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/ntos/io/pnprlist.c
Microsoft 45f4a58588 First commit
2020-09-30 17:12:32 +02:00

1310 lines
35 KiB
C
Raw Blame History

/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
pnprlist.c
Abstract:
This module contains routines to manipulate relations list. Relation lists
are used by Plug and Play during the processing of device removal and
ejection.
These routines are all pageable and can't be called at raised IRQL or with
a spinlock held.
Author:
Robert Nelson (robertn) Apr, 1998.
Revision History:
--*/
#include "iop.h"
#ifdef POOL_TAGGING
#undef ExAllocatePool
#define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,'lrpP')
#endif
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, IopAddRelationToList)
#pragma alloc_text(PAGE, IopAllocateRelationList)
#pragma alloc_text(PAGE, IopCompressRelationList)
#pragma alloc_text(PAGE, IopEnumerateRelations)
#pragma alloc_text(PAGE, IopFreeRelationList)
#pragma alloc_text(PAGE, IopGetRelationsCount)
#pragma alloc_text(PAGE, IopGetRelationsTaggedCount)
#pragma alloc_text(PAGE, IopIsRelationInList)
#pragma alloc_text(PAGE, IopMergeRelationLists)
#pragma alloc_text(PAGE, IopRemoveIndirectRelationsFromList)
#pragma alloc_text(PAGE, IopRemoveRelationFromList)
#pragma alloc_text(PAGE, IopSetAllRelationsTags)
#pragma alloc_text(PAGE, IopSetRelationsTag)
#endif
#define RELATION_FLAGS 0x00000003
#define RELATION_FLAG_TAGGED 0x00000001
#define RELATION_FLAG_DESCENDANT 0x00000002
NTSTATUS
IopAddRelationToList(
IN PRELATION_LIST List,
IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN DirectDescendant,
IN BOOLEAN Tagged
)
/*++
Routine Description:
Adds an element to a relation list.
If this is the first DeviceObject of a particular level then a new
RELATION_LIST_ENTRY will be allocated.
This routine should only be called on an uncompressed relation list,
otherwise it is likely that STATUS_INVALID_PARAMETER will be returned.
Arguments:
List Relation list to which the DeviceObject is added.
DeviceObject DeviceObject to be added to List. It must be a
PhysicalDeviceObject (PDO).
DirectDescendant Indicates whether DeviceObject is a direct descendant of
the original target device of this remove.
Tagged Indicates whether DeviceObject should be tagged in List.
Return Value:
STATUS_SUCCESS
The DeviceObject was added successfully.
STATUS_OBJECT_NAME_COLLISION
The DeviceObject already exists in the relation list.
STATUS_INSUFFICIENT_RESOURCES
There isn't enough PagedPool available to allocate a new
RELATION_LIST_ENTRY.
STATUS_INVALID_PARAMETER
The level of the DEVICE_NODE associated with DeviceObject is less than
FirstLevel or greater than the MaxLevel.
STATUS_NO_SUCH_DEVICE
DeviceObject is not a PhysicalDeviceObject (PDO), it doesn't have a
DEVICE_NODE associated with it.
--*/
{
PDEVICE_NODE deviceNode;
PRELATION_LIST_ENTRY entry;
ULONG level;
ULONG index;
ULONG flags;
PAGED_CODE();
flags = 0;
if (Tagged) {
Tagged = 1;
flags |= RELATION_FLAG_TAGGED;
}
if (DirectDescendant) {
flags |= RELATION_FLAG_DESCENDANT;
}
if ((deviceNode = DeviceObject->DeviceObjectExtension->DeviceNode) != NULL) {
level = deviceNode->Level;
// Since this routine is called with the DeviceNode Tree locked and
// List is initially allocated with enough entries to hold the deepest
// DEVICE_NODE this ASSERT should never fire. If it does then either
// the tree is changing or we were given a compressed list.
ASSERT(List->FirstLevel <= level && level <= List->MaxLevel);
if (List->FirstLevel <= level && level <= List->MaxLevel) {
if ((entry = List->Entries[ level - List->FirstLevel ]) == NULL) {
// This is the first DeviceObject of its level, allocate a new
// RELATION_LIST_ENTRY.
entry = ExAllocatePool( PagedPool, sizeof(RELATION_LIST_ENTRY) + IopNumberDeviceNodes * sizeof(PDEVICE_OBJECT));
if (entry == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
// We always allocate enough Devices to hold the whole tree as
// a simplification. Since each entry is a PDEVICE_OBJECT and
// there is generally under 50 devices on a machine this means
// under 1K for each entry. The excess space will be freed when
// the list is compressed.
entry->Count = 0;
entry->MaxCount = IopNumberDeviceNodes;
List->Entries[ level - List->FirstLevel ] = entry;
}
// There should always be room for a DeviceObject since the Entry is
// initially dimensioned large enough to hold all the DEVICE_NODES
// in the system.
ASSERT(entry->Count < entry->MaxCount);
if (entry->Count < entry->MaxCount) {
// Search the list to see if DeviceObject has already been
// added.
for (index = 0; index < entry->Count; index++) {
if (((ULONG_PTR)entry->Devices[ index ] & ~RELATION_FLAGS) == (ULONG_PTR)DeviceObject) {
// DeviceObject already exists in the list. However
// the Direct Descendant flag may differ. We will
// override it if DirectDescendant is TRUE. This could
// happen if we merged two relation lists.
if (DirectDescendant) {
entry->Devices[ index ] = (PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ index ] | RELATION_FLAG_DESCENDANT);
}
return STATUS_OBJECT_NAME_COLLISION;
}
}
} else {
// There isn't room in the Entry for another DEVICE_OBJECT, the
// list has probably already been compressed.
return STATUS_INVALID_PARAMETER;
}
// Take out a reference on DeviceObject, we will release it when we
// free the list or remove the DeviceObject from the list.
ObReferenceObject( DeviceObject );
entry->Devices[ index ] = (PDEVICE_OBJECT)((ULONG_PTR)DeviceObject | flags);
entry->Count++;
List->Count++;
List->TagCount += Tagged;
return STATUS_SUCCESS;
} else {
// There isn't an Entry available for the level of this
// DEVICE_OBJECT, the list has probably already been compressed.
return STATUS_INVALID_PARAMETER;
}
} else {
// DeviceObject is not a PhysicalDeviceObject (PDO).
return STATUS_NO_SUCH_DEVICE;
}
}
PRELATION_LIST
IopAllocateRelationList(
VOID
)
/*++
Routine Description:
Allocate a new Relations List. The list is initially sized large enough to
hold the deepest DEVICE_NODE encountered since the system started.
Arguments:
NONE
Return Value:
Newly allocated list if enough PagedPool is available, otherwise NULL.
--*/
{
PRELATION_LIST list;
ULONG maxLevel;
ULONG listSize;
PAGED_CODE();
// Level number of the deepest DEVICE_NODE allocated since the system
// started.
maxLevel = IopMaxDeviceNodeLevel;
listSize = sizeof(RELATION_LIST) + maxLevel * sizeof(PRELATION_LIST_ENTRY);
if ((list = ExAllocatePool( PagedPool, listSize )) != NULL) {
RtlZeroMemory(list, listSize);
// list->FirstLevel = 0;
// list->Count = 0;
// list->Tagged = 0;
list->MaxLevel = maxLevel;
}
return list;
}
NTSTATUS
IopCompressRelationList(
IN OUT PRELATION_LIST *List
)
/*++
Routine Description:
Compresses the relation list by reallocating the list and all the entries so
that they a just large enough to hold their current contents.
Once a list has been compressed IopAddRelationToList and
IopMergeRelationLists targetting this list are both likely to fail.
Arguments:
List Relation List to compress.
Return Value:
STATUS_SUCCESS
The list was compressed. Although this routine does allocate memory and
the allocation can fail, the routine itself will never fail. Since the
memory we are allocating is always smaller then the memory it is
replacing we just keep the old memory if the allocation fails.
--*/
{
PRELATION_LIST oldList, newList;
PRELATION_LIST_ENTRY oldEntry, newEntry;
ULONG lowestLevel;
ULONG highestLevel;
ULONG index;
PAGED_CODE();
oldList = *List;
// Initialize lowestLevel and highestLevel with illegal values chosen so
// that the first real entry will override them.
lowestLevel = oldList->MaxLevel;
highestLevel = oldList->FirstLevel;
// Loop through the list looking for allocated entries.
for (index = 0; index <= (oldList->MaxLevel - oldList->FirstLevel); index++) {
if ((oldEntry = oldList->Entries[ index ]) != NULL) {
// This entry is allocated, update lowestLevel and highestLevel if
// necessary.
if (lowestLevel > index) {
lowestLevel = index;
}
if (highestLevel < index) {
highestLevel = index;
}
if (oldEntry->Count < oldEntry->MaxCount) {
// This entry is only partially full. Allocate a new entry
// which is just the right size to hold the current number of PDEVICE_OBJECTs.
newEntry = ExAllocatePool( PagedPool, sizeof(RELATION_LIST_ENTRY) + (oldEntry->Count - 1) * sizeof(PDEVICE_OBJECT));
if (newEntry != NULL) {
// Initialize Count and MaxCount to the number of
// PDEVICE_OBJECTs in the old entry.
newEntry->Count = oldEntry->Count;
newEntry->MaxCount = oldEntry->Count;
// Copy the PDEVICE_OBJECTs from the old entry to the new one.
RtlCopyMemory( newEntry->Devices,
oldEntry->Devices,
oldEntry->Count * sizeof(PDEVICE_OBJECT));
// Free the old entry and store the new entry in the list.
ExFreePool( oldEntry );
oldList->Entries[ index ] = newEntry;
}
}
}
}
// Assert that the old list isn't empty.
ASSERT(lowestLevel <= highestLevel);
if (lowestLevel > highestLevel) {
// The list is empty - we shouldn't get asked to compress an empty list
// but lets do it anyways.
lowestLevel = 0;
highestLevel = 0;
}
// Check if the old list had unused entries at the beginning or the end of
// the Entries array.
if (lowestLevel != oldList->FirstLevel || highestLevel != oldList->MaxLevel) {
// Allocate a new List with just enough Entries to hold those between
// FirstLevel and MaxLevel inclusive.
newList = ExAllocatePool( PagedPool, sizeof(RELATION_LIST) + (highestLevel - lowestLevel) * sizeof(PRELATION_LIST_ENTRY));
if (newList != NULL) {
// Copy the old list to the new list and return it to the caller.
newList->Count = oldList->Count;
newList->TagCount = oldList->TagCount;
newList->FirstLevel = lowestLevel;
newList->MaxLevel = highestLevel;
RtlCopyMemory( newList->Entries,
&oldList->Entries[ lowestLevel ],
(highestLevel - lowestLevel + 1) * sizeof(PRELATION_LIST_ENTRY));
ExFreePool( oldList );
*List = newList;
}
}
return STATUS_SUCCESS;
}
BOOLEAN
IopEnumerateRelations(
IN PRELATION_LIST List,
IN OUT PULONG Marker,
OUT PDEVICE_OBJECT *DeviceObject,
OUT BOOLEAN *DirectDescendant, OPTIONAL
OUT BOOLEAN *Tagged, OPTIONAL
IN BOOLEAN Reverse
)
/*++
Routine Description:
Enumerates the relations in a list.
Arguments:
List Relation list to be enumerated.
Marker Cookie used to maintain current place in the list. It
must be initialized to 0 the first time
IopEnumerateRelations is called.
DeviceObject Returned Relation.
DirectDescendant If specified then it is set if the relation is a direct
descendant of the original target device of this remove.
Tagged If specified then it is set if the relation is tagged
otherwise it is cleared.
Reverse Direction of traversal, TRUE means from deepest to
closest to the root, FALSE means from the root down.
If Reverse changes on a subsequent call then the
previously enumerated relation is skipped. For example,
given the sequence A, B, C, D, E. If
IopEnumerateRelations is called thrice with Reverse set
to FALSE and then called repeatedly with Reverse set to
TRUE until it returns FALSE, the sequence would be: A,
B, C, B, A.
Once the end has been reached it is not possible to
change directions.
Return Value:
TRUE
DeviceObject and optionally Tagged have been set to the next relation.
FALSE
There are no more relations.
--*/
{
PRELATION_LIST_ENTRY entry;
LONG levelIndex;
ULONG entryIndex;
PAGED_CODE();
// The basic assumptions of our use of Marker is that there will never be
// more than 16M DeviceNodes at any one level and that the tree will never
// be more than 127 deep.
// The format of Marker is
// Bit 31 = Valid (used to distinguish the initial call
// Bit 30-24 = Current index into entries
// Bit 23-0 = Current index into devices, 0xFFFFFF means last
if (*Marker == ~0U) {
// We've reached the end.
return FALSE;
}
if (*Marker == 0) {
// This is the initial call to IopEnumerateRelations
if (Reverse) {
// Initialize levelIndex to the last element of Entries
levelIndex = List->MaxLevel - List->FirstLevel;
} else {
// Initialize levelIndex to the first element of Entries
levelIndex = 0;
}
// Initialize entryIndex to unknown element of Devices. If we are going
// in reverse then this will appear to be beyond the last element and
// we'll adjust it the last one. If we are going forward then this will
// appear to be just prior to the first element so when we increment it,
// it will become zero.
entryIndex = ~0U;
} else {
// Bit 31 is our valid bit, used to distinguish level 0, device 0 from
// the first time call.
ASSERT(*Marker & ((ULONG)1 << 31));
// Current level stored in bits 30-24.
levelIndex = (*Marker >> 24) & 0x7F;
// Current device stored in bits 23-0.
entryIndex = *Marker & 0x00FFFFFF;
}
if (Reverse) {
// We are traversing the list bottom up, from the deepest device towards
// the root.
for ( ; levelIndex >= 0; levelIndex--) {
// Since the Entries array can be sparse find the next allocated
// Entry.
if ((entry = List->Entries[ levelIndex ]) != NULL) {
if (entryIndex > entry->Count) {
// entryIndex (the current one) is greater than Count, this
// will be the case where it is 0xFFFFFF, in other words
// unspecified. Adjust it so that it is one past the last
// one in this Entry.
entryIndex = entry->Count;
}
if (entryIndex > 0) {
// The current entry is beyond the first entry so the next
// entry (which is the one we are looking for is immediately
// prior, adjust entryIndex.
entryIndex--;
// Get the device object and remove the tag.
*DeviceObject = (PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ entryIndex ] & ~RELATION_FLAGS);
if (Tagged != NULL) {
// The caller is interested in the tag value.
*Tagged = (BOOLEAN)((ULONG_PTR)entry->Devices[ entryIndex ] & RELATION_FLAG_TAGGED);
}
if (DirectDescendant != NULL) {
// The caller is interested in the DirectDescendant value.
*DirectDescendant = (BOOLEAN)((ULONG_PTR)entry->Devices[ entryIndex ] & RELATION_FLAG_DESCENDANT);
}
// Update the marker (info for current device)
*Marker = ((ULONG)1 << 31) | (levelIndex << 24) | (entryIndex & 0x00FFFFFF);
return TRUE;
}
}
// The current device object has been deleted or the current
// device object is the first one in this Entry.
// We need to continue to search backwards through the other
// Entries.
entryIndex = ~0U;
}
} else {
for ( ; levelIndex <= (LONG)(List->MaxLevel - List->FirstLevel); levelIndex++) {
// Since the Entries array can be sparse find the next allocated
// Entry.
if ((entry = List->Entries[ levelIndex ]) != NULL) {
// entryIndex is the index of the current device or 0xFFFFFFFF
// if this is the first time we have been called or the current
// current device is the last one in its Entry. Increment the
// index to point to the next device.
entryIndex++;
if (entryIndex < entry->Count) {
// The next device is within this entry.
// Get the device object and remove the tag.
*DeviceObject = (PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ entryIndex ] & ~RELATION_FLAGS);
if (Tagged != NULL) {
// The caller is interested in the tag value.
*Tagged = (BOOLEAN)((ULONG_PTR)entry->Devices[ entryIndex ] & RELATION_FLAG_TAGGED);
}
if (DirectDescendant != NULL) {
// The caller is interested in the DirectDescendant value.
*DirectDescendant = (BOOLEAN)((ULONG_PTR)entry->Devices[ entryIndex ] & RELATION_FLAG_DESCENDANT);
}
// Update the marker (info for current device)
*Marker = ((ULONG)1 << 31) | (levelIndex << 24) | (entryIndex & 0x00FFFFFF);
return TRUE;
}
}
// The current device has been removed or we have processed the
// last device in the current entry.
// Set entryIndex so that it is just before the first device in
// the next entry. Continue the search looking for the next
// allocated Entry.
entryIndex = ~0U;
}
}
// We are at the end of the list
*Marker = ~0U;
*DeviceObject = NULL;
if (Tagged != NULL) {
*Tagged = FALSE;
}
if (DirectDescendant != NULL) {
*DirectDescendant = FALSE;
}
return FALSE;
}
VOID
IopFreeRelationList(
IN PRELATION_LIST List
)
/*++
Routine Description:
Free a relation list allocated by IopAllocateRelationList.
Arguments:
List The list to be freed.
Return Value:
NONE.
--*/
{
PRELATION_LIST_ENTRY entry;
ULONG levelIndex;
ULONG entryIndex;
PAGED_CODE();
// Search the list looking for allocated Entries.
for (levelIndex = 0; levelIndex <= (List->MaxLevel - List->FirstLevel); levelIndex++) {
if ((entry = List->Entries[ levelIndex ]) != NULL) {
// This entry has been allocated.
for (entryIndex = 0; entryIndex < entry->Count; entryIndex++) {
// Dereference all the Devices in the entry.
ObDereferenceObject((PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ entryIndex ] & ~RELATION_FLAGS));
}
// Free the Entry.
ExFreePool( entry );
}
}
// Free the list. It isn't necessary to dereference the DeviceObject that
// was the original target that caused the list to be created. This
// DeviceObject is also in one of the Entries and its reference is taken
// and released there.
ExFreePool( List );
}
ULONG
IopGetRelationsCount(
PRELATION_LIST List
)
/*++
Routine Description:
Returns the total number of relations (Device Objects) in all the entries.
Arguments:
List Relation List.
Return Value:
Count of relations (Device Objects).
--*/
{
PAGED_CODE();
return List->Count;
}
ULONG
IopGetRelationsTaggedCount(
PRELATION_LIST List
)
/*++
Routine Description:
Returns the total number of relations (Device Objects) in all the entries
which are tagged.
Arguments:
List Relation List.
Return Value:
Count of tagged relations (Device Objects).
--*/
{
PAGED_CODE();
return List->TagCount;
}
BOOLEAN
IopIsRelationInList(
PRELATION_LIST List,
PDEVICE_OBJECT DeviceObject
)
/*++
Routine Description:
Checks if a relation (Device Object) exists in the specified relation list.
Arguments:
List Relation list to check.
DeviceObject Relation to be checked.
Return Value:
TRUE
Relation exists.
FALSE
Relation is not in the list.
--*/
{
PDEVICE_NODE deviceNode;
PRELATION_LIST_ENTRY entry;
ULONG level;
ULONG index;
PAGED_CODE();
if ((deviceNode = DeviceObject->DeviceObjectExtension->DeviceNode) != NULL) {
// The device object is a PDO.
level = deviceNode->Level;
if (List->FirstLevel <= level && level <= List->MaxLevel) {
// The level is within the range of levels stored in this list.
if ((entry = List->Entries[ level - List->FirstLevel ]) != NULL) {
// There is an Entry for this level.
for (index = 0; index < entry->Count; index++) {
// For each Device in the entry, compare it to the given
// DeviceObject
if (((ULONG_PTR)entry->Devices[ index ] & ~RELATION_FLAGS) == (ULONG_PTR)DeviceObject) {
// It matches
return TRUE;
}
}
}
}
}
// It wasn't a PDO
// or the level wasn't in the range of levels in this list
// or there are no DeviceObjects at the same level in this list
// or the DeviceObject isn't in the Entry for its level in this list
return FALSE;
}
NTSTATUS
IopMergeRelationLists(
IN OUT PRELATION_LIST TargetList,
IN PRELATION_LIST SourceList,
IN BOOLEAN Tagged
)
/*++
Routine Description:
Merges two relation lists by copying all the relations from the source list
to the target list. Source list remains unchanged.
Arguments:
TargetList List to which the relations from Sourcelist are added.
SourceList List of relations to be added to TargetList.
Tagged TRUE if relations from SourceList should be tagged when added to
TargetList. If FALSE then relations added from SourceList are
untagged.
Return Value:
STATUS_SUCCESS
All the relations in SourceList were added to TargetList successfully.
STATUS_OBJECT_NAME_COLLISION
One of the relations in SourceList already exists in TargetList. This
is a fatal error and TargetList may already have some of the relations
from SourceList added. This could be dealt with more gracefully if
necessary but the current callers of IopMergeRelationLists avoid this
situation.
STATUS_INSUFFICIENT_RESOURCES
There isn't enough PagedPool available to allocate a new
RELATION_LIST_ENTRY.
STATUS_INVALID_PARAMETER
The level of one of the relations in SourceList is less than FirstLevel
or greater than the MaxLevel. This is a fatal error and TargetList may
already have some of the relations from SourceList added. The only way
this could happen is if the tree lock isn't held or if TargetList has
been compressed by IopCompressRelationList. Both situations would be
bugs in the caller.
STATUS_NO_SUCH_DEVICE
One of the relations in SourceList is not a PhysicalDeviceObject (PDO),
it doesn't have a DEVICE_NODE associated with it. This is a fatal error
and TargetList may already have some of the relations from SourceList
added. This should never happen since it was a PDO when it was added to
SourceList.
--*/
{
PRELATION_LIST_ENTRY entry;
ULONG levelIndex;
ULONG entryIndex;
NTSTATUS status = STATUS_SUCCESS;
PAGED_CODE();
// For each level entry in SourceList
for (levelIndex = 0;
levelIndex <= (SourceList->MaxLevel - SourceList->FirstLevel);
levelIndex++) {
if ((entry = SourceList->Entries[ levelIndex ]) != NULL) {
// The Entry has Devices
for (entryIndex = 0; entryIndex < entry->Count; entryIndex++) {
// For each Device in the Entry, add it to the target List.
status = IopAddRelationToList( TargetList,
(PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ entryIndex ] & ~RELATION_FLAGS),
FALSE,
Tagged);
// BUGBUG - Need to handle STATUS_INSUFFICIENT_RESOURCES more
// gracefully. Currently the only way this can happen is
// during Eject and that code isn't enabled yet.
ASSERT(NT_SUCCESS(status));
if (!NT_SUCCESS(status)) {
// BUGBUG - We should undo the damage we've done to
// TargetList by removing those relations we've added from
// SourceList.
break;
}
}
}
}
return status;
}
NTSTATUS
IopRemoveIndirectRelationsFromList(
IN PRELATION_LIST List
)
/*++
Routine Description:
Removes all the relations without the DirectDescendant flag from a relation
list.
Arguments:
List List from which to remove the relations.
Return Value:
STATUS_SUCCESS
The relations were removed successfully.
--*/
{
PDEVICE_OBJECT deviceObject;
PRELATION_LIST_ENTRY entry;
ULONG level;
LONG index;
PAGED_CODE();
// For each Entry in the list.
for (level = List->FirstLevel; level <= List->MaxLevel; level++) {
// If the entry is allocated.
if ((entry = List->Entries[ level - List->FirstLevel ]) != NULL) {
// For each Device in the list.
for (index = entry->Count - 1; index >= 0; index--) {
if (!((ULONG_PTR)entry->Devices[ index ] & RELATION_FLAG_DESCENDANT)) {
deviceObject = (PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ index ] & ~RELATION_FLAGS);
ObDereferenceObject( deviceObject );
if ((ULONG_PTR)entry->Devices[ index ] & RELATION_FLAG_TAGGED) {
List->TagCount--;
}
if (index < ((LONG)entry->Count - 1)) {
RtlMoveMemory( &entry->Devices[ index ],
&entry->Devices[ index + 1 ],
(entry->Count - index - 1) * sizeof(PDEVICE_OBJECT));
}
if (--entry->Count == 0) {
List->Entries[ level - List->FirstLevel ] = NULL;
ExFreePool(entry);
}
List->Count--;
}
}
}
}
return STATUS_SUCCESS;
}
NTSTATUS
IopRemoveRelationFromList(
PRELATION_LIST List,
PDEVICE_OBJECT DeviceObject
)
/*++
Routine Description:
Removes a relation from a relation list.
Arguments:
List List from which to remove the relation.
DeviceObject Relation to remove.
Return Value:
STATUS_SUCCESS
The relation was removed successfully.
STATUS_NO_SUCH_DEVICE
The relation doesn't exist in the list.
--*/
{
PDEVICE_NODE deviceNode;
PRELATION_LIST_ENTRY entry;
ULONG level;
LONG index;
PAGED_CODE();
if ((deviceNode = DeviceObject->DeviceObjectExtension->DeviceNode) != NULL) {
level = deviceNode->Level;
ASSERT(List->FirstLevel <= level && level <= List->MaxLevel);
if (List->FirstLevel <= level && level <= List->MaxLevel) {
if ((entry = List->Entries[ level - List->FirstLevel ]) != NULL) {
for (index = entry->Count - 1; index >= 0; index--) {
if (((ULONG_PTR)entry->Devices[ index ] & ~RELATION_FLAGS) == (ULONG_PTR)DeviceObject) {
ObDereferenceObject( DeviceObject );
if (((ULONG_PTR)entry->Devices[ index ] & RELATION_FLAG_TAGGED) != 0) {
List->TagCount--;
}
if (index < ((LONG)entry->Count - 1)) {
RtlMoveMemory( &entry->Devices[ index ],
&entry->Devices[ index + 1 ],
(entry->Count - index - 1) * sizeof(PDEVICE_OBJECT));
}
if (--entry->Count == 0) {
List->Entries[ level - List->FirstLevel ] = NULL;
ExFreePool(entry);
}
List->Count--;
return STATUS_SUCCESS;
}
}
}
}
}
return STATUS_NO_SUCH_DEVICE;
}
VOID
IopSetAllRelationsTags(
PRELATION_LIST List,
BOOLEAN Tagged
)
/*++
Routine Description:
Tags or untags all the relations in a relations list.
Arguments:
List Relation list containing relations to be tagged or untagged.
Tagged TRUE if the relations should be tagged, FALSE if they are to be
untagged.
Return Value:
NONE
--*/
{
PRELATION_LIST_ENTRY entry;
ULONG level;
ULONG index;
PAGED_CODE();
// For each Entry in the list.
for (level = List->FirstLevel; level <= List->MaxLevel; level++) {
// If the entry is allocated.
if ((entry = List->Entries[ level - List->FirstLevel ]) != NULL) {
// For each Device in the list.
for (index = 0; index < entry->Count; index++) {
// Set or clear the tag based on the argument Tagged.
if (Tagged) {
entry->Devices[ index ] = (PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ index ] | RELATION_FLAG_TAGGED);
} else {
entry->Devices[ index ] = (PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ index ] & ~RELATION_FLAG_TAGGED);
}
}
}
}
// If we are setting the tags then update the TagCount to the number of
// relations in the list. Otherwise reset it to zero.
List->TagCount = Tagged ? List->Count : 0;
}
NTSTATUS
IopSetRelationsTag(
IN PRELATION_LIST List,
IN PDEVICE_OBJECT DeviceObject,
IN BOOLEAN Tagged
)
/*++
Routine Description:
Sets or clears a tag on a specified relation in a relations list. This
routine is also used by some callers to determine if a relation exists in
a list and if so to set the tag.
Arguments:
List List containing relation to be tagged or untagged.
DeviceObject Relation to be tagged or untagged.
Tagged TRUE if relation is to be tagged, FALSE if it is to be
untagged.
Return Value:
STATUS_SUCCESS
The relation was tagged successfully.
STATUS_NO_SUCH_DEVICE
The relation doesn't exist in the list.
--*/
{
PDEVICE_NODE deviceNode;
PRELATION_LIST_ENTRY entry;
ULONG level;
LONG index;
PAGED_CODE();
if ((deviceNode = DeviceObject->DeviceObjectExtension->DeviceNode) != NULL) {
// DeviceObject is a PhysicalDeviceObject (PDO), get its level.
level = deviceNode->Level;
if (List->FirstLevel <= level && level <= List->MaxLevel) {
// The level is within the range of levels in this List.
if ((entry = List->Entries[ level - List->FirstLevel ]) != NULL) {
// The Entry for this level is allocated. Search each device
// in the Entry looking for a match.
for (index = entry->Count - 1; index >= 0; index--) {
if (((ULONG_PTR)entry->Devices[ index ] & ~RELATION_FLAGS) == (ULONG_PTR)DeviceObject) {
// We found a match
if ((ULONG_PTR)entry->Devices[ index ] & RELATION_FLAG_TAGGED) {
// The relation is already tagged so to simplify the
// logic below decrement the TagCount. We'll
// increment it later if the caller still wants it
// to be tagged.
List->TagCount--;
}
if (Tagged) {
// Set the tag and increment the number of tagged
// relations.
entry->Devices[ index ] = (PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ index ] | RELATION_FLAG_TAGGED);
List->TagCount++;
} else {
// Clear the tag.
entry->Devices[ index ] = (PDEVICE_OBJECT)((ULONG_PTR)entry->Devices[ index ] & ~RELATION_FLAG_TAGGED);
}
return STATUS_SUCCESS;
}
}
}
}
}
// It wasn't a PDO
// or the level wasn't in the range of levels in this list
// or there are no DeviceObjects at the same level in this list
// or the DeviceObject isn't in the Entry for its level in this list
return STATUS_NO_SUCH_DEVICE;
}
Reference in New Issue View Git Blame Copy Permalink