ReactOS  0.4.15-dev-4870-g846c9aa
plugplay.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS Kernel
3  * COPYRIGHT: GPL - See COPYING in the top level directory
4  * FILE: ntoskrnl/io/pnpmgr/plugplay.c
5  * PURPOSE: Plug-and-play interface routines
6  * PROGRAMMERS: Eric Kohl <eric.kohl@t-online.de>
7  */
8 
9 /* INCLUDES *****************************************************************/
10 
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14 
15 typedef struct _PNP_EVENT_ENTRY
16 {
20 
21 
22 /* GLOBALS *******************************************************************/
23 
26 
27 /* FUNCTIONS *****************************************************************/
28 
29 CODE_SEG("INIT")
32 {
34 
37  FALSE);
38 
39  return STATUS_SUCCESS;
40 }
41 
44  PUNICODE_STRING DeviceIds)
45 {
46  PPNP_EVENT_ENTRY EventEntry;
48  ULONG TotalSize;
50 
51  ASSERT(DeviceIds);
52 
53  /* Allocate a big enough buffer */
54  Copy.Length = 0;
55  Copy.MaximumLength = DeviceIds->Length + sizeof(UNICODE_NULL);
56  TotalSize =
58  Copy.MaximumLength;
59 
60  EventEntry = ExAllocatePool(NonPagedPool,
61  TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
62  if (!EventEntry)
64  RtlZeroMemory(EventEntry, TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
65 
66  /* Fill the buffer with the event GUID */
67  RtlCopyMemory(&EventEntry->Event.EventGuid,
68  Guid,
69  sizeof(GUID));
71  EventEntry->Event.TotalSize = TotalSize;
72 
73  /* Fill the device id */
74  Copy.Buffer = EventEntry->Event.TargetDevice.DeviceIds;
76  if (!NT_SUCCESS(Status))
77  {
78  ExFreePool(EventEntry);
79  return Status;
80  }
81 
83  &EventEntry->ListEntry);
85  0,
86  FALSE);
87 
88  return STATUS_SUCCESS;
89 }
90 
91 
92 static PDEVICE_OBJECT
94 {
96  PDEVICE_NODE ChildNode;
97 
98  if (RtlEqualUnicodeString(&Node->InstancePath,
100  {
101  ObReferenceObject(Node->PhysicalDeviceObject);
102  return Node->PhysicalDeviceObject;
103  }
104 
105  /* Traversal of all children nodes */
106  for (ChildNode = Node->Child;
107  ChildNode != NULL;
108  ChildNode = ChildNode->Sibling)
109  {
111  if (DeviceObject != NULL)
112  {
113  return DeviceObject;
114  }
115  }
116 
117  return NULL;
118 }
119 
120 
123 {
124  if (IopRootDeviceNode == NULL)
125  return NULL;
126 
127  if (DeviceInstance == NULL ||
128  DeviceInstance->Length == 0)
129  {
131  {
134  }
135  else
136  return NULL;
137  }
138 
140 }
141 
142 static NTSTATUS
144 {
146  volatile UNICODE_STRING Name;
147 
148  Name.Buffer = NULL;
149  _SEH2_TRY
150  {
151  Name.Length = SrcName->Length;
152  Name.MaximumLength = SrcName->MaximumLength;
153  if (Name.Length > Name.MaximumLength)
154  {
156  _SEH2_LEAVE;
157  }
158 
159  if (Name.MaximumLength)
160  {
161  ProbeForRead(SrcName->Buffer,
162  Name.MaximumLength,
163  sizeof(WCHAR));
164  Name.Buffer = ExAllocatePool(NonPagedPool, Name.MaximumLength);
165  if (Name.Buffer == NULL)
166  {
168  _SEH2_LEAVE;
169  }
170 
171  memcpy(Name.Buffer, SrcName->Buffer, Name.MaximumLength);
172  }
173 
174  *DstName = Name;
175  }
177  {
178  if (Name.Buffer)
179  {
180  ExFreePool(Name.Buffer);
181  }
183  }
184  _SEH2_END;
185 
186  return Status;
187 }
188 
189 
190 static
191 NTSTATUS
194 {
199 
200  DPRINT("IopInitializeDevice(%p)\n", ControlData);
201 
202  Status = IopCaptureUnicodeString(&DeviceInstance, &ControlData->DeviceInstance);
203  if (!NT_SUCCESS(Status))
204  {
205  return Status;
206  }
207 
208  DPRINT("Device: %wZ\n", &DeviceInstance);
209 
210  /* Leave, if the device already exists */
212  if (DeviceInstance.Buffer != NULL)
213  {
214  DPRINT1("Device %wZ already exists!\n", &DeviceInstance);
216  goto done;
217  }
218 
220 
221  DPRINT("Device %wZ does not exist!\n", &DeviceInstance);
222 
223  /* Create a device node for the device instance */
225  0,
226  NULL,
229  FALSE,
230  &DeviceObject);
231  if (!NT_SUCCESS(Status))
232  {
233  DPRINT1("IoCreateDevice() failed (Status 0x%08lx)\n", Status);
234  goto done;
235  }
236 
237  /* Allocate a new device node */
239  if (DeviceNode == NULL)
240  {
241  DPRINT1("Failed to allocate a device node!\n");
244  goto done;
245  }
246 
247  /* Set the device instance of the device node */
249  if (!NT_SUCCESS(Status))
250  {
251  DPRINT1("RtlDuplicateUnicodeString() failed (Status 0x%08lx)\n", Status);
254  goto done;
255  }
256 
257  /* Insert as a root enumerated device node */
259 
260 done:
262 
263  return Status;
264 }
265 
266 
267 /*
268  * Remove the current PnP event from the tail of the event queue
269  * and signal IopPnpNotifyEvent if there is yet another event in the queue.
270  */
271 static
272 NTSTATUS
275 {
276  /* Remove a pnp event entry from the tail of the queue */
278  {
280  }
281 
282  /* Signal the next pnp event in the queue */
284  {
286  0,
287  FALSE);
288  }
289 
290  return STATUS_SUCCESS;
291 }
292 
293 
294 static NTSTATUS
296 {
301  GUID FilterGuid;
302  PZZWSTR SymbolicLinkList = NULL, LinkList;
304 
305  _SEH2_TRY
306  {
308 
309  ProbeForRead(StackList.FilterGuid, sizeof(GUID), sizeof(UCHAR));
310  RtlCopyMemory(&FilterGuid, StackList.FilterGuid, sizeof(GUID));
311 
312  if (StackList.Buffer != NULL && StackList.BufferSize != 0)
313  {
314  ProbeForWrite(StackList.Buffer, StackList.BufferSize, sizeof(UCHAR));
315  }
316  }
318  {
320  }
321  _SEH2_END;
322 
324  if (NT_SUCCESS(Status))
325  {
326  /* Get the device object */
328  if (DeviceInstance.Buffer != NULL)
329  {
331  }
332  }
333 
334  Status = IoGetDeviceInterfaces(&FilterGuid, DeviceObject, StackList.Flags, &SymbolicLinkList);
336 
337  if (!NT_SUCCESS(Status))
338  {
339  /* failed */
340  return Status;
341  }
342 
343  LinkList = SymbolicLinkList;
344  while (*SymbolicLinkList != UNICODE_NULL)
345  {
346  SymbolicLinkList += wcslen(SymbolicLinkList) + (sizeof(UNICODE_NULL) / sizeof(WCHAR));
347  }
348  TotalLength = ((SymbolicLinkList - LinkList + 1) * sizeof(WCHAR));
349 
350  _SEH2_TRY
351  {
352  if (StackList.Buffer != NULL &&
353  StackList.BufferSize >= TotalLength)
354  {
355  // We've already probed the buffer for writing above.
356  RtlCopyMemory(StackList.Buffer, LinkList, TotalLength);
357  }
358 
359  DeviceList->BufferSize = TotalLength;
360  }
362  {
363  ExFreePool(LinkList);
365  }
366  _SEH2_END;
367 
368  ExFreePool(LinkList);
369  return STATUS_SUCCESS;
370 }
371 
372 static NTSTATUS
374 {
379  ULONG Property;
381  PVOID Buffer;
383 
384  DPRINT("IopGetDeviceProperty() called\n");
385  DPRINT("Device name: %wZ\n", &PropertyData->DeviceInstance);
386 
388  if (!NT_SUCCESS(Status))
389  {
390  return Status;
391  }
392 
393  _SEH2_TRY
394  {
395  Property = PropertyData->Property;
396  BufferSize = PropertyData->BufferSize;
397  ProbeForWrite(PropertyData->Buffer,
398  BufferSize,
399  sizeof(UCHAR));
400  }
402  {
403  if (DeviceInstance.Buffer != NULL)
404  {
406  }
408  }
409  _SEH2_END;
410 
411  /* Get the device object */
413  if (DeviceInstance.Buffer != NULL)
414  {
416  }
417  if (DeviceObject == NULL)
418  {
419  return STATUS_NO_SUCH_DEVICE;
420  }
421 
423  if (Buffer == NULL)
424  {
427  }
428 
429 
430  DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
431 
433  {
434  if (BufferSize < sizeof(CM_POWER_DATA))
435  {
436  BufferSize = 0;
438  }
439  else
440  {
442  PCM_POWER_DATA PowerData;
445 
446  PowerData = (PCM_POWER_DATA)Buffer;
447  RtlZeroMemory(PowerData, sizeof(CM_POWER_DATA));
448  PowerData->PD_Size = sizeof(CM_POWER_DATA);
449 
452  DeviceCapabilities.Version = 1;
453  DeviceCapabilities.Address = -1;
454  DeviceCapabilities.UINumber = -1;
455 
456  Stack.Parameters.DeviceCapabilities.Capabilities = &DeviceCapabilities;
457 
459  &IoStatusBlock,
461  &Stack);
462  if (NT_SUCCESS(Status))
463  {
464  DPRINT("Got device capabiliities\n");
465 
466  PowerData->PD_MostRecentPowerState = PowerDeviceD0; // FIXME
467  if (DeviceCapabilities.DeviceD1)
468  PowerData->PD_Capabilities |= PDCAP_D1_SUPPORTED;
469  if (DeviceCapabilities.DeviceD2)
470  PowerData->PD_Capabilities |= PDCAP_D2_SUPPORTED;
471  if (DeviceCapabilities.WakeFromD0)
473  if (DeviceCapabilities.WakeFromD1)
475  if (DeviceCapabilities.WakeFromD2)
477  if (DeviceCapabilities.WakeFromD3)
479  if (DeviceCapabilities.WarmEjectSupported)
481  PowerData->PD_D1Latency = DeviceCapabilities.D1Latency;
482  PowerData->PD_D2Latency = DeviceCapabilities.D2Latency;
483  PowerData->PD_D3Latency = DeviceCapabilities.D3Latency;
485  &DeviceCapabilities.DeviceState,
486  sizeof(DeviceCapabilities.DeviceState));
487  PowerData->PD_DeepestSystemWake = DeviceCapabilities.SystemWake;
488  }
489  else
490  {
491  DPRINT("IRP_MN_QUERY_CAPABILITIES failed (Status 0x%08lx)\n", Status);
492 
495  }
496  }
497  }
499  {
501  BufferSize = 0;
503  }
505  {
506  if (BufferSize < sizeof(DeviceNode->HardwareRemovalPolicy))
507  {
508  BufferSize = 0;
510  }
511  else
512  {
513  BufferSize = sizeof(DeviceNode->HardwareRemovalPolicy);
515  &DeviceNode->HardwareRemovalPolicy,
516  BufferSize);
517  }
518  }
519  else
520  {
521  switch (Property)
522  {
525  break;
526 
529  break;
530 
533  break;
534 
537  break;
538 
541  break;
542 
545  break;
546 
549  break;
550 
553  break;
554 
557  break;
558 
559 #if (WINVER >= _WIN32_WINNT_WS03)
562  BufferSize = 0;
564  break;
565 #endif
566 
567 #if (WINVER >= _WIN32_WINNT_WIN7)
570  break;
571 #endif
572 
573  default:
574  BufferSize = 0;
576  break;
577  }
578 
579  if (Status == STATUS_SUCCESS)
580  {
583  BufferSize,
584  Buffer,
585  &BufferSize);
586  }
587  }
588 
590 
591  if (NT_SUCCESS(Status))
592  {
593  _SEH2_TRY
594  {
596  PropertyData->BufferSize = BufferSize;
597  }
599  {
601  }
602  _SEH2_END;
603  }
604 
606  return Status;
607 }
608 
609 
610 static NTSTATUS
612 {
613  UNICODE_STRING RootDeviceName;
616  PDEVICE_NODE RelatedDeviceNode;
617  UNICODE_STRING TargetDeviceInstance;
619  ULONG Relation = 0;
620  ULONG MaximumLength = 0;
621 
622  DPRINT("IopGetRelatedDevice() called\n");
623  DPRINT("Device name: %wZ\n", &RelatedDeviceData->TargetDeviceInstance);
624 
625  Status = IopCaptureUnicodeString(&TargetDeviceInstance, &RelatedDeviceData->TargetDeviceInstance);
626  if (!NT_SUCCESS(Status))
627  {
628  return Status;
629  }
630 
631  _SEH2_TRY
632  {
633  Relation = RelatedDeviceData->Relation;
634  MaximumLength = RelatedDeviceData->RelatedDeviceInstanceLength;
635  ProbeForWrite(RelatedDeviceData->RelatedDeviceInstance,
637  sizeof(WCHAR));
638  }
640  {
641  if (TargetDeviceInstance.Buffer != NULL)
642  {
643  ExFreePool(TargetDeviceInstance.Buffer);
644  }
646  }
647  _SEH2_END;
648 
649  RtlInitUnicodeString(&RootDeviceName,
650  L"HTREE\\ROOT\\0");
651  if (RtlEqualUnicodeString(&TargetDeviceInstance,
652  &RootDeviceName,
653  TRUE))
654  {
656  if (TargetDeviceInstance.Buffer != NULL)
657  {
658  ExFreePool(TargetDeviceInstance.Buffer);
659  }
660  }
661  else
662  {
663  /* Get the device object */
664  DeviceObject = IopGetDeviceObjectFromDeviceInstance(&TargetDeviceInstance);
665  if (TargetDeviceInstance.Buffer != NULL)
666  {
667  ExFreePool(TargetDeviceInstance.Buffer);
668  }
669  if (DeviceObject == NULL)
670  return STATUS_NO_SUCH_DEVICE;
671 
672  DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
673  }
674 
675  switch (Relation)
676  {
678  RelatedDeviceNode = DeviceNode->Parent;
679  break;
680 
682  RelatedDeviceNode = DeviceNode->Child;
683  break;
684 
686  RelatedDeviceNode = DeviceNode->Sibling;
687  break;
688 
689  default:
690  if (DeviceObject != NULL)
691  {
693  }
694 
696  }
697 
698  if (RelatedDeviceNode == NULL)
699  {
700  if (DeviceObject)
701  {
703  }
704 
705  return STATUS_NO_SUCH_DEVICE;
706  }
707 
708  if (RelatedDeviceNode->InstancePath.Length > MaximumLength)
709  {
710  if (DeviceObject)
711  {
713  }
714 
716  }
717 
718  /* Copy related device instance name */
719  _SEH2_TRY
720  {
721  RtlCopyMemory(RelatedDeviceData->RelatedDeviceInstance,
722  RelatedDeviceNode->InstancePath.Buffer,
723  RelatedDeviceNode->InstancePath.Length);
724  RelatedDeviceData->RelatedDeviceInstanceLength = RelatedDeviceNode->InstancePath.Length;
725  }
727  {
729  }
730  _SEH2_END;
731 
732  if (DeviceObject != NULL)
733  {
735  }
736 
737  DPRINT("IopGetRelatedDevice() done\n");
738 
739  return Status;
740 }
741 
742 static
743 BOOLEAN
746 {
747  return (DeviceNode->State == DeviceNodeStartPending ||
750  DeviceNode->State == DeviceNodeStarted ||
754  DeviceNode->State == DeviceNodeStopped ||
756 }
757 
758 static ULONG
760 {
762 
763  if (DeviceNode->Parent == IopRootDeviceNode)
765 
766  // FIXME: review for deleted and removed states
767  if (DeviceNode->State >= DeviceNodeDriversAdded)
769 
771  Output |= DN_STARTED;
772 
773  if (DeviceNode->UserFlags & DNUF_WILL_BE_REMOVED)
775 
776  if (DeviceNode->Flags & DNF_HAS_PROBLEM)
778 
779  if (DeviceNode->Flags & DNF_HAS_PRIVATE_PROBLEM)
781 
782  if (DeviceNode->Flags & DNF_DRIVER_BLOCKED)
784 
787 
788  if (DeviceNode->Flags & DNF_HAS_PRIVATE_PROBLEM)
790 
791  if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
793 
794  if (DeviceNode->UserFlags & DNUF_DONT_SHOW_IN_UI)
796 
797  if (!(DeviceNode->UserFlags & DNUF_NOT_DISABLEABLE))
799 
800  return Output;
801 }
802 
803 static NTSTATUS
805 {
808  ULONG Operation = 0;
809  ULONG DeviceStatus = 0;
810  ULONG DeviceProblem = 0;
813 
814  DPRINT("IopDeviceStatus() called\n");
815 
817  if (!NT_SUCCESS(Status))
818  {
819  return Status;
820  }
821 
822  DPRINT("Device name: '%wZ'\n", &DeviceInstance);
823 
824  _SEH2_TRY
825  {
826  Operation = StatusData->Operation;
828  {
829  DeviceStatus = StatusData->DeviceStatus;
830  DeviceProblem = StatusData->DeviceProblem;
831  }
832  }
834  {
835  if (DeviceInstance.Buffer != NULL)
836  {
838  }
840  }
841  _SEH2_END;
842 
843  /* Get the device object */
845  if (DeviceInstance.Buffer != NULL)
846  {
848  }
849  if (DeviceObject == NULL)
850  {
851  return STATUS_NO_SUCH_DEVICE;
852  }
853 
855 
856  switch (Operation)
857  {
859  DPRINT("Get status data\n");
860  DeviceStatus = IopGetDeviceNodeStatus(DeviceNode);
861  DeviceProblem = DeviceNode->Problem;
862  break;
863 
865  DPRINT1("Set status data is NOT SUPPORTED\n");
866  break;
867 
869  DPRINT1("FIXME: Clear status data!\n");
870  break;
871  }
872 
874 
876  {
877  _SEH2_TRY
878  {
879  StatusData->DeviceStatus = DeviceStatus;
880  StatusData->DeviceProblem = DeviceProblem;
881  }
883  {
885  }
886  _SEH2_END;
887  }
888 
889  return Status;
890 }
891 
892 static
893 NTSTATUS
895 {
900  PDEVICE_RELATIONS DeviceRelations = NULL;
901  PDEVICE_OBJECT ChildDeviceObject;
902  PDEVICE_NODE ChildDeviceNode;
903  ULONG i;
904  ULONG Relations;
906  ULONG BufferLeft;
907  PWCHAR Buffer, Ptr;
909 
910  DPRINT("IopGetDeviceRelations() called\n");
911  DPRINT("Device name: %wZ\n", &RelationsData->DeviceInstance);
912  DPRINT("Relations: %lu\n", RelationsData->Relations);
913  DPRINT("BufferSize: %lu\n", RelationsData->BufferSize);
914  DPRINT("Buffer: %p\n", RelationsData->Buffer);
915 
916  _SEH2_TRY
917  {
918  Relations = RelationsData->Relations;
919  BufferSize = RelationsData->BufferSize;
920  Buffer = RelationsData->Buffer;
921 
922  ProbeForWrite(Buffer, BufferSize, sizeof(CHAR));
923  }
925  {
927  }
928  _SEH2_END;
929 
931  if (!NT_SUCCESS(Status))
932  {
933  DPRINT1("IopCaptureUnicodeString() failed (Status 0x%08lx)\n", Status);
934  return Status;
935  }
936 
937  /* Get the device object */
939  if (DeviceObject == NULL)
940  {
941  DPRINT1("IopGetDeviceObjectFromDeviceInstance() returned NULL\n");
943  goto done;
944  }
945 
946  switch (Relations)
947  {
948  case PNP_EJECT_RELATIONS:
949  Stack.Parameters.QueryDeviceRelations.Type = EjectionRelations;
950  break;
951 
953  Stack.Parameters.QueryDeviceRelations.Type = RemovalRelations;
954  break;
955 
956  case PNP_POWER_RELATIONS:
957  Stack.Parameters.QueryDeviceRelations.Type = PowerRelations;
958  break;
959 
960  case PNP_BUS_RELATIONS:
961  Stack.Parameters.QueryDeviceRelations.Type = BusRelations;
962  break;
963 
964  default:
966  goto done;
967  }
968 
970  &IoStatusBlock,
972  &Stack);
973  if (!NT_SUCCESS(Status))
974  {
975  DPRINT1("IopInitiatePnpIrp() failed (Status 0x%08lx)\n", Status);
976  goto done;
977  }
978 
979  DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
980 
981  DPRINT("Found %d device relations\n", DeviceRelations->Count);
982 
983  _SEH2_TRY
984  {
985  RequiredSize = 0;
986  BufferLeft = BufferSize;
987  Ptr = Buffer;
988 
989  for (i = 0; i < DeviceRelations->Count; i++)
990  {
991  ChildDeviceObject = DeviceRelations->Objects[i];
992 
993  ChildDeviceNode = IopGetDeviceNode(ChildDeviceObject);
994  if (ChildDeviceNode)
995  {
996  DPRINT("Device instance: %wZ\n", &ChildDeviceNode->InstancePath);
997  DPRINT("RequiredSize: %hu\n", ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
998 
999  if (Ptr != NULL)
1000  {
1001  if (BufferLeft < ChildDeviceNode->InstancePath.Length + 2 * sizeof(WCHAR))
1002  {
1004  break;
1005  }
1006 
1008  ChildDeviceNode->InstancePath.Buffer,
1009  ChildDeviceNode->InstancePath.Length);
1010  Ptr = (PWCHAR)((ULONG_PTR)Ptr + ChildDeviceNode->InstancePath.Length);
1011  *Ptr = UNICODE_NULL;
1012  Ptr = (PWCHAR)((ULONG_PTR)Ptr + sizeof(WCHAR));
1013 
1014  BufferLeft -= (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
1015  }
1016 
1017  RequiredSize += (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
1018  }
1019  }
1020 
1021  if (Ptr != NULL && BufferLeft >= sizeof(WCHAR))
1022  *Ptr = UNICODE_NULL;
1023 
1024  if (RequiredSize > 0)
1025  RequiredSize += sizeof(WCHAR);
1026 
1027  DPRINT("BufferSize: %lu RequiredSize: %lu\n", RelationsData->BufferSize, RequiredSize);
1028 
1029  RelationsData->BufferSize = RequiredSize;
1030  }
1032  {
1034  }
1035  _SEH2_END;
1036 
1037 done:
1038  if (DeviceRelations != NULL)
1039  ExFreePool(DeviceRelations);
1040 
1041  if (DeviceObject != NULL)
1043 
1044  if (DeviceInstance.Buffer != NULL)
1046 
1047  return Status;
1048 }
1049 
1050 static NTSTATUS
1052 {
1057 
1058  DPRINT("IopGetDeviceDepth() called\n");
1059  DPRINT("Device name: %wZ\n", &DepthData->DeviceInstance);
1060 
1062  if (!NT_SUCCESS(Status))
1063  {
1064  return Status;
1065  }
1066 
1067  /* Get the device object */
1069  if (DeviceInstance.Buffer != NULL)
1070  {
1072  }
1073  if (DeviceObject == NULL)
1074  {
1075  return STATUS_NO_SUCH_DEVICE;
1076  }
1077 
1079 
1080  _SEH2_TRY
1081  {
1082  DepthData->Depth = DeviceNode->Level;
1083  }
1085  {
1087  }
1088  _SEH2_END;
1089 
1091 
1092  return Status;
1093 }
1094 
1095 static
1096 NTSTATUS
1100 {
1102  NTSTATUS Status;
1104 
1108 
1110  if (!NT_SUCCESS(Status))
1111  {
1112  return Status;
1113  }
1114 
1116  if (DeviceInstance.Buffer != NULL)
1117  {
1119  }
1120  if (DeviceObject == NULL)
1121  {
1122  return STATUS_NO_SUCH_DEVICE;
1123  }
1124 
1126 
1127  switch (ControlClass)
1128  {
1131  break;
1134  break;
1137  break;
1138  default:
1139  UNREACHABLE;
1140  break;
1141  }
1142 
1144 
1146 
1147  return Status;
1148 }
1149 
1150 /* PUBLIC FUNCTIONS **********************************************************/
1151 
1152 /*
1153  * Plug and Play event structure used by NtGetPlugPlayEvent.
1154  *
1155  * EventGuid
1156  * Can be one of the following values:
1157  * GUID_HWPROFILE_QUERY_CHANGE
1158  * GUID_HWPROFILE_CHANGE_CANCELLED
1159  * GUID_HWPROFILE_CHANGE_COMPLETE
1160  * GUID_TARGET_DEVICE_QUERY_REMOVE
1161  * GUID_TARGET_DEVICE_REMOVE_CANCELLED
1162  * GUID_TARGET_DEVICE_REMOVE_COMPLETE
1163  * GUID_PNP_CUSTOM_NOTIFICATION
1164  * GUID_PNP_POWER_NOTIFICATION
1165  * GUID_DEVICE_* (see above)
1166  *
1167  * EventCategory
1168  * Type of the event that happened.
1169  *
1170  * Result
1171  * ?
1172  *
1173  * Flags
1174  * ?
1175  *
1176  * TotalSize
1177  * Size of the event block including the device IDs and other
1178  * per category specific fields.
1179  */
1180 
1181 /*
1182  * NtGetPlugPlayEvent
1183  *
1184  * Returns one Plug & Play event from a global queue.
1185  *
1186  * Parameters
1187  * Reserved1
1188  * Reserved2
1189  * Always set to zero.
1190  *
1191  * Buffer
1192  * The buffer that will be filled with the event information on
1193  * successful return from the function.
1194  *
1195  * BufferSize
1196  * Size of the buffer pointed by the Buffer parameter. If the
1197  * buffer size is not large enough to hold the whole event
1198  * information, error STATUS_BUFFER_TOO_SMALL is returned and
1199  * the buffer remains untouched.
1200  *
1201  * Return Values
1202  * STATUS_PRIVILEGE_NOT_HELD
1203  * STATUS_BUFFER_TOO_SMALL
1204  * STATUS_SUCCESS
1205  *
1206  * Remarks
1207  * This function isn't multi-thread safe!
1208  *
1209  * @implemented
1210  */
1211 NTSTATUS
1212 NTAPI
1214  IN ULONG Reserved2,
1217 {
1219  NTSTATUS Status;
1220 
1221  DPRINT("NtGetPlugPlayEvent() called\n");
1222 
1223  /* Function can only be called from user-mode */
1224  if (KeGetPreviousMode() == KernelMode)
1225  {
1226  DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
1227  return STATUS_ACCESS_DENIED;
1228  }
1229 
1230  /* Check for Tcb privilege */
1232  UserMode))
1233  {
1234  DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
1236  }
1237 
1238  /* Wait for a PnP event */
1239  DPRINT("Waiting for pnp notification event\n");
1241  UserRequest,
1242  UserMode,
1243  FALSE,
1244  NULL);
1246  {
1247  DPRINT("KeWaitForSingleObject() failed (Status %lx)\n", Status);
1249  return Status;
1250  }
1251 
1252  /* Get entry from the tail of the queue */
1255  ListEntry);
1256 
1257  /* Check the buffer size */
1258  if (BufferSize < Entry->Event.TotalSize)
1259  {
1260  DPRINT1("Buffer is too small for the pnp-event\n");
1261  return STATUS_BUFFER_TOO_SMALL;
1262  }
1263 
1264  /* Copy event data to the user buffer */
1265  _SEH2_TRY
1266  {
1268  Entry->Event.TotalSize,
1269  sizeof(UCHAR));
1271  &Entry->Event,
1272  Entry->Event.TotalSize);
1273  }
1275  {
1277  }
1278  _SEH2_END;
1279 
1280  DPRINT("NtGetPlugPlayEvent() done\n");
1281 
1282  return STATUS_SUCCESS;
1283 }
1284 
1285 /*
1286  * NtPlugPlayControl
1287  *
1288  * A function for doing various Plug & Play operations from user mode.
1289  *
1290  * Parameters
1291  * PlugPlayControlClass
1292  * 0x00 Reenumerate device tree
1293  *
1294  * Buffer points to UNICODE_STRING decribing the instance
1295  * path (like "HTREE\ROOT\0" or "Root\ACPI_HAL\0000"). For
1296  * more information about instance paths see !devnode command
1297  * in kernel debugger or look at "Inside Windows 2000" book,
1298  * chapter "Driver Loading, Initialization, and Installation".
1299  *
1300  * 0x01 Register new device
1301  * 0x02 Deregister device
1302  * 0x03 Initialize device
1303  * 0x04 Start device
1304  * 0x06 Query and remove device
1305  * 0x07 User response
1306  *
1307  * Called after processing the message from NtGetPlugPlayEvent.
1308  *
1309  * 0x08 Generate legacy device
1310  * 0x09 Get interface device list
1311  * 0x0A Get property data
1312  * 0x0B Device class association (Registration)
1313  * 0x0C Get related device
1314  * 0x0D Get device interface alias
1315  * 0x0E Get/set/clear device status
1316  * 0x0F Get device depth
1317  * 0x10 Query device relations
1318  * 0x11 Query target device relation
1319  * 0x12 Query conflict list
1320  * 0x13 Retrieve dock data
1321  * 0x14 Reset device
1322  * 0x15 Halt device
1323  * 0x16 Get blocked driver data
1324  *
1325  * Buffer
1326  * The buffer contains information that is specific to each control
1327  * code. The buffer is read-only.
1328  *
1329  * BufferSize
1330  * Size of the buffer pointed by the Buffer parameter. If the
1331  * buffer size specifies incorrect value for specified control
1332  * code, error ??? is returned.
1333  *
1334  * Return Values
1335  * STATUS_PRIVILEGE_NOT_HELD
1336  * STATUS_SUCCESS
1337  * ...
1338  *
1339  * @unimplemented
1340  */
1341 NTSTATUS
1342 NTAPI
1344  IN OUT PVOID Buffer,
1346 {
1347  DPRINT("NtPlugPlayControl(%d %p %lu) called\n",
1348  PlugPlayControlClass, Buffer, BufferLength);
1349 
1350  /* Function can only be called from user-mode */
1351  if (KeGetPreviousMode() == KernelMode)
1352  {
1353  DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
1354  return STATUS_ACCESS_DENIED;
1355  }
1356 
1357  /* Check for Tcb privilege */
1359  UserMode))
1360  {
1361  DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
1363  }
1364 
1365  /* Probe the buffer */
1366  _SEH2_TRY
1367  {
1369  BufferLength,
1370  sizeof(ULONG));
1371  }
1373  {
1375  }
1376  _SEH2_END;
1377 
1378  switch (PlugPlayControlClass)
1379  {
1382  return STATUS_INVALID_PARAMETER;
1383  // the Flags field is not used anyway
1385  PlugPlayControlClass);
1386 
1387 // case PlugPlayControlRegisterNewDevice:
1388 // case PlugPlayControlDeregisterDevice:
1389 
1392  return STATUS_INVALID_PARAMETER;
1394 
1398  return STATUS_INVALID_PARAMETER;
1400  PlugPlayControlClass);
1401 
1402 // case PlugPlayControlUnlockDevice:
1403 // case PlugPlayControlQueryAndRemoveDevice:
1404 
1407  return STATUS_INVALID_PARAMETER;
1409 
1410 // case PlugPlayControlGenerateLegacyDevice:
1411 
1414  return STATUS_INVALID_PARAMETER;
1416 
1419  return STATUS_INVALID_PARAMETER;
1421 
1422 // case PlugPlayControlDeviceClassAssociation:
1423 
1426  return STATUS_INVALID_PARAMETER;
1428 
1429 // case PlugPlayControlGetInterfaceDeviceAlias:
1430 
1433  return STATUS_INVALID_PARAMETER;
1435 
1438  return STATUS_INVALID_PARAMETER;
1440 
1443  return STATUS_INVALID_PARAMETER;
1445 
1446 // case PlugPlayControlTargetDeviceRelation:
1447 // case PlugPlayControlQueryConflictList:
1448 // case PlugPlayControlRetrieveDock:
1449 // case PlugPlayControlHaltDevice:
1450 // case PlugPlayControlGetBlockedDriverList:
1451 
1452  default:
1453  return STATUS_NOT_IMPLEMENTED;
1454  }
1455 
1456  return STATUS_NOT_IMPLEMENTED;
1457 }
DEVICE_REGISTRY_PROPERTY
Definition: iotypes.h:1194
static ULONG IopGetDeviceNodeStatus(PDEVICE_NODE DeviceNode)
Definition: plugplay.c:759
#define PNP_PROPERTY_POWER_DATA
Definition: cmtypes.h:39
#define IN
Definition: typedefs.h:39
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3767
#define PNP_REMOVAL_RELATIONS
Definition: cmtypes.h:67
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
#define PDCAP_WARM_EJECT_SUPPORTED
Definition: advprop.cpp:44
PDEVICE_OBJECT PhysicalDeviceObject
Definition: iotypes.h:855
PDEVICE_NODE IopRootDeviceNode
Definition: devnode.c:18
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_In_opt_ PDEVICE_OBJECT _In_ ULONG _Outptr_result_nullonfailure_ _At_ * SymbolicLinkList(return==0, __drv_allocatesMem(Mem))) PZZWSTR *SymbolicLinkList
#define DNF_HAS_PROBLEM
Definition: iotypes.h:183
struct _Entry Entry
Definition: kefuncs.h:629
static const WCHAR ControlClass[]
Definition: cfgmgr.c:44
USHORT MaximumLength
Definition: env_spec_w32.h:370
_Must_inspect_result_ __drv_aliasesMem PDEVICE_OBJECT _In_ PDEVICE_OBJECT TargetDevice
Definition: iofuncs.h:690
static NTSTATUS IopGetRelatedDevice(PPLUGPLAY_CONTROL_RELATED_DEVICE_DATA RelatedDeviceData)
Definition: plugplay.c:611
#define DNUF_NOT_DISABLEABLE
Definition: iotypes.h:211
#define PDCAP_D1_SUPPORTED
Definition: advprop.cpp:37
#define PNP_POWER_RELATIONS
Definition: cmtypes.h:68
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
#define DN_ROOT_ENUMERATED
Definition: cfg.h:118
#define TRUE
Definition: types.h:120
Definition: plugplay.c:15
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define DN_DRIVER_BLOCKED
Definition: cfg.h:154
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty
Definition: wdfdevice.h:3767
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2163
#define PNP_GET_SIBLING_DEVICE
Definition: cmtypes.h:54
char CHAR
Definition: xmlstorage.h:175
FORCEINLINE PLIST_ENTRY RemoveTailList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:154
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
#define KeGetPreviousMode()
Definition: ketypes.h:1108
LONG NTSTATUS
Definition: precomp.h:26
#define DN_DRIVER_LOADED
Definition: cfg.h:119
#define DN_DISABLEABLE
Definition: cfg.h:131
PLUGPLAY_EVENT_BLOCK Event
Definition: plugplay.c:18
NTSTATUS NTAPI IoGetDeviceInterfaces(IN CONST GUID *InterfaceClassGuid, IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL, IN ULONG Flags, OUT PWSTR *SymbolicLinkList)
Definition: deviface.c:454
#define PNP_SET_DEVICE_STATUS
Definition: cmtypes.h:60
struct _PLUGPLAY_EVENT_BLOCK::@2345::@2348 TargetDevice
#define PNP_GET_PARENT_DEVICE
Definition: cmtypes.h:52
DEVICE_CAPABILITIES
Definition: iotypes.h:965
struct _EXTENDED_DEVOBJ_EXTENSION * PEXTENDED_DEVOBJ_EXTENSION
#define PNP_BUS_RELATIONS
Definition: cmtypes.h:69
PDEVICE_LIST DeviceList
Definition: utils.c:27
static LIST_ENTRY IopPnpEventQueueHead
Definition: plugplay.c:24
uint16_t * PWCHAR
Definition: typedefs.h:56
struct _PNP_EVENT_ENTRY PNP_EVENT_ENTRY
UNICODE_STRING DeviceInstance
Definition: cmtypes.h:525
_In_ WDFDEVICE _In_ PWDF_DEVICE_INTERFACE_PROPERTY_DATA PropertyData
static NTSTATUS IopGetDeviceRelations(PPLUGPLAY_CONTROL_DEVICE_RELATIONS_DATA RelationsData)
Definition: plugplay.c:894
_NullNull_terminated_ WCHAR * PZZWSTR
Definition: ntbasedef.h:420
_In_ ULONG TotalLength
Definition: usbdlib.h:158
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
static PDEVICE_OBJECT IopTraverseDeviceNode(PDEVICE_NODE Node, PUNICODE_STRING DeviceInstance)
Definition: plugplay.c:93
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
static NTSTATUS IopRemovePlugPlayEvent(_In_ PPLUGPLAY_CONTROL_USER_RESPONSE_DATA ResponseData)
Definition: plugplay.c:273
enum _PLUGPLAY_CONTROL_CLASS PLUGPLAY_CONTROL_CLASS
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
NTSTATUS IopQueueTargetDeviceEvent(const GUID *Guid, PUNICODE_STRING DeviceIds)
Definition: plugplay.c:43
_SEH2_TRY
Definition: create.c:4226
uint32_t ULONG_PTR
Definition: typedefs.h:65
static NTSTATUS IopGetDeviceProperty(PPLUGPLAY_CONTROL_PROPERTY_DATA PropertyData)
Definition: plugplay.c:373
_In_ WDFREQUEST _In_ PIO_STACK_LOCATION Stack
Definition: wdfrequest.h:636
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
return STATUS_NOT_IMPLEMENTED
PLUGPLAY_EVENT_CATEGORY EventCategory
Definition: cmtypes.h:406
#define L(x)
Definition: ntvdm.h:50
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FILE_DEVICE_CONTROLLER
Definition: winioctl.h:110
#define FALSE
Definition: types.h:117
#define UNICODE_NULL
#define DNUF_DONT_SHOW_IN_UI
Definition: iotypes.h:209
PDEVICE_NODE PipAllocateDeviceNode(IN PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS NTAPI NtGetPlugPlayEvent(IN ULONG Reserved1, IN ULONG Reserved2, OUT PPLUGPLAY_EVENT_BLOCK Buffer, IN ULONG BufferSize)
Definition: plugplay.c:1213
#define PDCAP_D2_SUPPORTED
Definition: advprop.cpp:38
ULONG PD_D2Latency
Definition: advprop.cpp:52
struct NameRec_ * Name
Definition: cdprocs.h:459
struct _DEVICE_RELATIONS * PDEVICE_RELATIONS
unsigned char BOOLEAN
PDEVICE_OBJECT IopGetDeviceObjectFromDeviceInstance(PUNICODE_STRING DeviceInstance)
Definition: plugplay.c:122
#define _In_
Definition: ms_sal.h:308
#define PNP_PROPERTY_BUSTYPEGUID
Definition: cmtypes.h:36
#define DeviceCapabilities
Definition: wingdi.h:4449
NTSTATUS NTAPI IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_REGISTRY_PROPERTY DeviceProperty, IN ULONG BufferLength, OUT PVOID PropertyBuffer, OUT PULONG ResultLength)
Definition: pnpmgr.c:1952
#define PNP_PROPERTY_REMOVAL_POLICY_HARDWARE_DEFAULT
Definition: cmtypes.h:44
Definition: bufpool.h:45
#define DN_NO_SHOW_IN_DM
Definition: cfg.h:148
#define PDCAP_D3_SUPPORTED
Definition: advprop.cpp:39
static KEVENT IopPnpNotifyEvent
Definition: plugplay.c:25
Definition: bcd.h:202
#define FILE_AUTOGENERATED_DEVICE_NAME
Definition: iotypes.h:138
NTSTATUS IopInitPlugPlayEvents(VOID)
Definition: plugplay.c:31
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define PNP_PROPERTY_ADDRESS
Definition: cmtypes.h:42
enum _DEVICE_ACTION DEVICE_ACTION
ULONG PD_D3Latency
Definition: advprop.cpp:53
Status
Definition: gdiplustypes.h:24
#define PNP_PROPERTY_LOCATION_PATHS
Definition: cmtypes.h:46
#define PNP_PROPERTY_ENUMERATOR_NAME
Definition: cmtypes.h:43
#define DN_PRIVATE_PROBLEM
Definition: cfg.h:133
_In_ WDFDMATRANSACTION _In_ size_t MaximumLength
#define ASSERT(a)
Definition: mode.c:44
static BOOLEAN PiIsDevNodeStarted(_In_ PDEVICE_NODE DeviceNode)
Definition: plugplay.c:744
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSYSAPI NTSTATUS WINAPI RtlDuplicateUnicodeString(int, const UNICODE_STRING *, UNICODE_STRING *)
#define PNP_GET_DEVICE_STATUS
Definition: cmtypes.h:59
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136
_Must_inspect_result_ _In_ WDFOBJECT _In_ CONST GUID * Guid
Definition: wdfobject.h:760
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define PNP_PROPERTY_REMOVAL_POLICY
Definition: cmtypes.h:40
struct _PNP_EVENT_ENTRY * PPNP_EVENT_ENTRY
static NTSTATUS IopDeviceStatus(PPLUGPLAY_CONTROL_STATUS_DATA StatusData)
Definition: plugplay.c:804
#define ObDereferenceObject
Definition: obfuncs.h:203
#define DN_HAS_PROBLEM
Definition: cfg.h:128
#define DN_NT_DRIVER
Definition: cfg.h:142
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define DN_NT_ENUMERATOR
Definition: cfg.h:141
static NTSTATUS IopInitializeDevice(_In_ PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA ControlData)
Definition: plugplay.c:192
Definition: Node.h:9
#define DNF_CHILD_WITH_INVALID_ID
Definition: iotypes.h:191
#define PNP_PROPERTY_UI_NUMBER
Definition: cmtypes.h:34
#define PNP_PROPERTY_REMOVAL_POLICY_OVERRIDE
Definition: cmtypes.h:41
unsigned char UCHAR
Definition: xmlstorage.h:181
#define PNP_CLEAR_DEVICE_STATUS
Definition: cmtypes.h:61
PDRIVER_OBJECT IopRootDriverObject
Definition: pnpmgr.c:26
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
Definition: arc.h:85
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
#define PNP_PROPERTY_PHYSICAL_DEVICE_OBJECT_NAME
Definition: cmtypes.h:35
static NTSTATUS IopCaptureUnicodeString(PUNICODE_STRING DstName, PUNICODE_STRING SrcName)
Definition: plugplay.c:143
#define DNF_LEGACY_DRIVER
Definition: iotypes.h:182
_In_ PNDIS_STRING DeviceInstance
Definition: ndis.h:5202
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
Definition: typedefs.h:119
#define PNP_GET_CHILD_DEVICE
Definition: cmtypes.h:53
static NTSTATUS IopGetDeviceDepth(PPLUGPLAY_CONTROL_DEPTH_DATA DepthData)
Definition: plugplay.c:1051
UNICODE_STRING InstancePath
Definition: iotypes.h:858
NTSTATUS PiPerformSyncDeviceAction(_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action)
Perfom a device operation synchronously via PiQueueDeviceAction.
Definition: devaction.c:2714
const LUID SeTcbPrivilege
Definition: priv.c:26
#define PDCAP_WAKE_FROM_D1_SUPPORTED
Definition: advprop.cpp:41
#define STATUS_USER_APC
Definition: ntstatus.h:78
_In_ DWORD Property
Definition: setupapi.h:1550
static NTSTATUS PiControlSyncDeviceAction(_In_ PPLUGPLAY_CONTROL_DEVICE_CONTROL_DATA DeviceData, _In_ PLUGPLAY_CONTROL_CLASS ControlClass)
Definition: plugplay.c:1097
ULONG_PTR SIZE_T
Definition: typedefs.h:80
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
VOID Copy(PVOID Src, PVOID Dst, ULONG NumBytes)
Definition: mmixer.c:126
SYSTEM_POWER_STATE PD_DeepestSystemWake
Definition: advprop.cpp:55
_SEH2_END
Definition: create.c:4400
NTSTATUS NTAPI NtPlugPlayControl(IN PLUGPLAY_CONTROL_CLASS PlugPlayControlClass, IN OUT PVOID Buffer, IN ULONG BufferLength)
Definition: plugplay.c:1343
LIST_ENTRY ListEntry
Definition: plugplay.c:17
ULONG PD_D1Latency
Definition: advprop.cpp:51
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
_In_ WDFIOTARGET _In_ _Strict_type_match_ WDF_IO_TARGET_SENT_IO_ACTION Action
Definition: wdfiotarget.h:506
struct CM_Power_Data_s CM_POWER_DATA
struct CM_Power_Data_s * PCM_POWER_DATA
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define PNP_PROPERTY_LEGACYBUSTYPE
Definition: cmtypes.h:37
#define DNF_HAS_PRIVATE_PROBLEM
Definition: iotypes.h:184
#define NULL
Definition: types.h:112
#define IRP_MN_QUERY_DEVICE_RELATIONS
struct _DEVICE_NODE * Sibling
Definition: iotypes.h:839
Definition: bcd.h:201
DEVICE_POWER_STATE PD_PowerStateMapping[PowerSystemMaximum]
Definition: advprop.cpp:54
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define DPRINT1
Definition: precomp.h:8
BOOLEAN NTAPI SeSinglePrivilegeCheck(_In_ LUID PrivilegeValue, _In_ KPROCESSOR_MODE PreviousMode)
Checks if a single privilege is present in the context of the calling thread.
Definition: priv.c:744
#define PNP_EJECT_RELATIONS
Definition: cmtypes.h:66
#define DN_LEGACY_DRIVER
Definition: cfg.h:155
#define DN_CHILD_WITH_INVALID_ID
Definition: cfg.h:156
#define PNP_PROPERTY_INSTALL_STATE
Definition: cmtypes.h:45
#define DN_STARTED
Definition: cfg.h:121
VOID PiInsertDevNode(_In_ PDEVICE_NODE DeviceNode, _In_ PDEVICE_NODE ParentNode)
Definition: devnode.c:80
#define OUT
Definition: typedefs.h:40
#define ObReferenceObject
Definition: obfuncs.h:204
unsigned int ULONG
Definition: retypes.h:1
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: device.c:1031
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNIMPLEMENTED
Definition: debug.h:115
#define UNREACHABLE
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define PDCAP_WAKE_FROM_D0_SUPPORTED
Definition: advprop.cpp:40
_In_ FLT_SET_CONTEXT_OPERATION Operation
Definition: fltkernel.h:1467
NTSTATUS IopFreeDeviceNode(IN PDEVICE_NODE DeviceNode)
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define PNP_PROPERTY_BUSNUMBER
Definition: cmtypes.h:38
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:40
DEVICE_POWER_STATE PD_MostRecentPowerState
Definition: advprop.cpp:49
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ ULONG _Out_ PVOID _Out_ PULONG RequiredSize
Definition: wdfdevice.h:4431
#define STATUS_SUCCESS
Definition: shellext.h:65
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define _SEH2_LEAVE
Definition: filesup.c:20
#define DPRINT
Definition: sndvol32.h:71
#define PDCAP_WAKE_FROM_D2_SUPPORTED
Definition: advprop.cpp:42
#define PNP_PROPERTY_CONTAINERID
Definition: cmtypes.h:47
#define DN_WILL_BE_REMOVED
Definition: cfg.h:136
NTSTATUS NTAPI IopInitiatePnpIrp(IN PDEVICE_OBJECT DeviceObject, IN PIO_STATUS_BLOCK IoStatusBlock, IN UCHAR MinorFunction, IN PIO_STACK_LOCATION Stack)
static CODE_SEG("PAGE")
Definition: isapnp.c:1482
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
static NTSTATUS IopGetInterfaceDeviceList(PPLUGPLAY_CONTROL_INTERFACE_DEVICE_LIST_DATA DeviceList)
Definition: plugplay.c:295
UNICODE_STRING DeviceInstance
Definition: cmtypes.h:534
#define PDCAP_WAKE_FROM_D3_SUPPORTED
Definition: advprop.cpp:43
base of all file and directory entries
Definition: entries.h:82
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
ULONG PD_Capabilities
Definition: advprop.cpp:50
PDEVICE_NODE FASTCALL IopGetDeviceNode(IN PDEVICE_OBJECT DeviceObject)
#define BufferSize
Definition: mmc.h:75
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:251
#define PDCAP_D0_SUPPORTED
Definition: advprop.cpp:36
#define DNF_DRIVER_BLOCKED
Definition: iotypes.h:190
#define IRP_MN_QUERY_CAPABILITIES
Definition: dlist.c:348
#define DNUF_WILL_BE_REMOVED
Definition: iotypes.h:208