Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 21:12:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

[NTOS:IO] change DEVICE_ACTION values and rename functions

Browse source
This commit is contained in:
Victor Perevertkin 2020-06-24 04:49:18 +03:00
parent ca68686a98
commit 2ed132e90e
No known key found for this signature in database
GPG key ID: C750B7222E9C7830
3 changed files with 89 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

28
ntoskrnl/include/internal/io.h
View file

@ -539,28 +539,14 @@ typedef enum _SECURITY_DESCRIPTOR_TYPE
} SECURITY_DESCRIPTOR_TYPE, *PSECURITY_DESCRIPTOR_TYPE; } SECURITY_DESCRIPTOR_TYPE, *PSECURITY_DESCRIPTOR_TYPE;
// //
// Action types and data for IopQueueDeviceAction() // Action types and data for PiQueueDeviceAction()
// //
typedef enum _DEVICE_ACTION typedef enum _DEVICE_ACTION
{ {
DeviceActionInvalidateDeviceRelations, PiActionEnumDeviceTree,
MaxDeviceAction PiActionEnumRootDevices
} DEVICE_ACTION; } DEVICE_ACTION;
typedef struct _DEVICE_ACTION_DATA
{
LIST_ENTRY RequestListEntry;
PDEVICE_OBJECT DeviceObject;
DEVICE_ACTION Action;
union
{
struct
{
DEVICE_RELATION_TYPE Type;
} InvalidateDeviceRelations;
};
} DEVICE_ACTION_DATA, *PDEVICE_ACTION_DATA;
// //
// Resource code // Resource code
// //
@ -1432,9 +1418,11 @@ IopStoreSystemPartitionInformation(IN PUNICODE_STRING NtSystemPartitionDeviceNam
// Device action // Device action
// //
VOID VOID
IopQueueDeviceAction( PiQueueDeviceAction(
_In_ PDEVICE_ACTION_DATA ActionData _In_ PDEVICE_OBJECT DeviceObject,
); _In_ DEVICE_ACTION Action,
_In_opt_ PKEVENT CompletionEvent,
_Out_opt_ NTSTATUS *CompletionStatus);
// //
// Global I/O Data // Global I/O Data

102
ntoskrnl/io/pnpmgr/devaction.c
View file

@ -30,6 +30,17 @@ WORK_QUEUE_ITEM IopDeviceActionWorkItem;
BOOLEAN IopDeviceActionInProgress; BOOLEAN IopDeviceActionInProgress;
KSPIN_LOCK IopDeviceActionLock; KSPIN_LOCK IopDeviceActionLock;
/* TYPES *********************************************************************/
typedef struct _DEVICE_ACTION_REQUEST
{
LIST_ENTRY RequestListEntry;
PDEVICE_OBJECT DeviceObject;
PKEVENT CompletionEvent;
NTSTATUS *CompletionStatus;
DEVICE_ACTION Action;
} DEVICE_ACTION_REQUEST, *PDEVICE_ACTION_REQUEST;
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
PDEVICE_OBJECT PDEVICE_OBJECT
@ -2298,14 +2309,32 @@ cleanup:
&DeviceNode->InstancePath); &DeviceNode->InstancePath);
} }
#ifdef DBG
static
PCSTR
ActionToStr(
_In_ DEVICE_ACTION Action)
{
switch (Action)
{
case PiActionEnumDeviceTree:
return "PiActionEnumDeviceTree";
case PiActionEnumRootDevices:
return "PiActionEnumRootDevices";
default:
return "(request unknown)";
}
}
#endif
static static
VOID VOID
NTAPI NTAPI
IopDeviceActionWorker( PipDeviceActionWorker(
_In_ PVOID Context) _In_opt_ PVOID Context)
{ {
PLIST_ENTRY ListEntry; PLIST_ENTRY ListEntry;
PDEVICE_ACTION_DATA Data; PDEVICE_ACTION_REQUEST Request;
KIRQL OldIrql; KIRQL OldIrql;
KeAcquireSpinLock(&IopDeviceActionLock, &OldIrql); KeAcquireSpinLock(&IopDeviceActionLock, &OldIrql);
@ -2313,52 +2342,66 @@ IopDeviceActionWorker(
{ {
ListEntry = RemoveHeadList(&IopDeviceActionRequestList); ListEntry = RemoveHeadList(&IopDeviceActionRequestList);
KeReleaseSpinLock(&IopDeviceActionLock, OldIrql); KeReleaseSpinLock(&IopDeviceActionLock, OldIrql);
Data = CONTAINING_RECORD(ListEntry, Request = CONTAINING_RECORD(ListEntry, DEVICE_ACTION_REQUEST, RequestListEntry);
DEVICE_ACTION_DATA,
RequestListEntry);
switch (Data->Action) switch (Request->Action)
{ {
case DeviceActionInvalidateDeviceRelations: case PiActionEnumDeviceTree:
IoSynchronousInvalidateDeviceRelations(Data->DeviceObject, // this will be reworked in next commits
Data->InvalidateDeviceRelations.Type); IoSynchronousInvalidateDeviceRelations(Request->DeviceObject, BusRelations);
break; break;
default: default:
DPRINT1("Unimplemented device action %u\n", Data->Action); DPRINT1("Unimplemented device action %u\n", Request->Action);
break; break;
} }
ObDereferenceObject(Data->DeviceObject); ObDereferenceObject(Request->DeviceObject);
ExFreePoolWithTag(Data, TAG_IO); ExFreePoolWithTag(Request, TAG_IO);
KeAcquireSpinLock(&IopDeviceActionLock, &OldIrql); KeAcquireSpinLock(&IopDeviceActionLock, &OldIrql);
} }
IopDeviceActionInProgress = FALSE; IopDeviceActionInProgress = FALSE;
KeReleaseSpinLock(&IopDeviceActionLock, OldIrql); KeReleaseSpinLock(&IopDeviceActionLock, OldIrql);
} }
/**
* @brief Queue a device operation to a worker thread.
*
* @param[in] DeviceObject The device object
* @param[in] Action The action
* @param[in] CompletionEvent The completion event object (optional)
* @param[out] CompletionStatus Status returned be the action will be written here
*/
VOID VOID
IopQueueDeviceAction( PiQueueDeviceAction(
_In_ PDEVICE_ACTION_DATA ActionData) _In_ PDEVICE_OBJECT DeviceObject,
_In_ DEVICE_ACTION Action,
_In_opt_ PKEVENT CompletionEvent,
_Out_opt_ NTSTATUS *CompletionStatus)
{ {
PDEVICE_ACTION_DATA Data; PDEVICE_ACTION_REQUEST Request;
KIRQL OldIrql; KIRQL OldIrql;
DPRINT("IopQueueDeviceAction(%p)\n", ActionData); Request = ExAllocatePoolWithTag(NonPagedPool, sizeof(*Request), TAG_IO);
if (!Request)
Data = ExAllocatePoolWithTag(NonPagedPool, {
sizeof(DEVICE_ACTION_DATA), KeBugCheckEx(PNP_DETECTED_FATAL_ERROR, 0x3, 0, 0, 0);
TAG_IO);
if (!Data)
return; return;
}
ObReferenceObject(ActionData->DeviceObject); DPRINT("PiQueueDeviceAction: DeviceObject - %p, Request - %p, Action - %s\n",
RtlCopyMemory(Data, ActionData, sizeof(DEVICE_ACTION_DATA)); DeviceObject, Request, ActionToStr(Action));
DPRINT("Action %u\n", Data->Action); ObReferenceObject(DeviceObject);
Request->DeviceObject = DeviceObject;
Request->Action = Action;
Request->CompletionEvent = CompletionEvent;
Request->CompletionStatus = CompletionStatus;
KeAcquireSpinLock(&IopDeviceActionLock, &OldIrql); KeAcquireSpinLock(&IopDeviceActionLock, &OldIrql);
InsertTailList(&IopDeviceActionRequestList, &Data->RequestListEntry); InsertTailList(&IopDeviceActionRequestList, &Request->RequestListEntry);
if (IopDeviceActionInProgress) if (IopDeviceActionInProgress)
{ {
KeReleaseSpinLock(&IopDeviceActionLock, OldIrql); KeReleaseSpinLock(&IopDeviceActionLock, OldIrql);
@ -2367,9 +2410,6 @@ IopQueueDeviceAction(
IopDeviceActionInProgress = TRUE; IopDeviceActionInProgress = TRUE;
KeReleaseSpinLock(&IopDeviceActionLock, OldIrql); KeReleaseSpinLock(&IopDeviceActionLock, OldIrql);
ExInitializeWorkItem(&IopDeviceActionWorkItem, ExInitializeWorkItem(&IopDeviceActionWorkItem, PipDeviceActionWorker, NULL);
IopDeviceActionWorker, ExQueueWorkItem(&IopDeviceActionWorkItem, DelayedWorkQueue);
NULL);
ExQueueWorkItem(&IopDeviceActionWorkItem,
DelayedWorkQueue);
} }

17
ntoskrnl/io/pnpmgr/pnpmgr.c
View file

@ -2474,13 +2474,16 @@ IoInvalidateDeviceRelations(
IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT DeviceObject,
IN DEVICE_RELATION_TYPE Type) IN DEVICE_RELATION_TYPE Type)
{ {
DEVICE_ACTION_DATA ActionData; switch (Type)
{
ActionData.DeviceObject = DeviceObject; case BusRelations:
ActionData.Action = DeviceActionInvalidateDeviceRelations; /* Enumerate the device */
ActionData.InvalidateDeviceRelations.Type = Type; PiQueueDeviceAction(DeviceObject, PiActionEnumDeviceTree, NULL, NULL);
break;
IopQueueDeviceAction(&ActionData); default:
/* Everything else is not implemented */
break;
}
} }
/* /*