ReactOS  0.4.15-dev-3331-g8ebe441
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  * Remove the current PnP event from the tail of the event queue
191  * and signal IopPnpNotifyEvent if there is yet another event in the queue.
192  */
193 static
194 NTSTATUS
197 {
198  /* Remove a pnp event entry from the tail of the queue */
200  {
202  }
203 
204  /* Signal the next pnp event in the queue */
206  {
208  0,
209  FALSE);
210  }
211 
212  return STATUS_SUCCESS;
213 }
214 
215 
216 static NTSTATUS
218 {
223  GUID FilterGuid;
224  PZZWSTR SymbolicLinkList = NULL, LinkList;
226 
227  _SEH2_TRY
228  {
230 
231  ProbeForRead(StackList.FilterGuid, sizeof(GUID), sizeof(UCHAR));
232  RtlCopyMemory(&FilterGuid, StackList.FilterGuid, sizeof(GUID));
233 
234  if (StackList.Buffer != NULL && StackList.BufferSize != 0)
235  {
236  ProbeForWrite(StackList.Buffer, StackList.BufferSize, sizeof(UCHAR));
237  }
238  }
240  {
242  }
243  _SEH2_END;
244 
246  if (NT_SUCCESS(Status))
247  {
248  /* Get the device object */
250  if (DeviceInstance.Buffer != NULL)
251  {
253  }
254  }
255 
256  Status = IoGetDeviceInterfaces(&FilterGuid, DeviceObject, StackList.Flags, &SymbolicLinkList);
258 
259  if (!NT_SUCCESS(Status))
260  {
261  /* failed */
262  return Status;
263  }
264 
265  LinkList = SymbolicLinkList;
266  while (*SymbolicLinkList != UNICODE_NULL)
267  {
268  SymbolicLinkList += wcslen(SymbolicLinkList) + (sizeof(UNICODE_NULL) / sizeof(WCHAR));
269  }
270  TotalLength = ((SymbolicLinkList - LinkList + 1) * sizeof(WCHAR));
271 
272  _SEH2_TRY
273  {
274  if (StackList.Buffer != NULL &&
275  StackList.BufferSize >= TotalLength)
276  {
277  // We've already probed the buffer for writing above.
278  RtlCopyMemory(StackList.Buffer, LinkList, TotalLength);
279  }
280 
281  DeviceList->BufferSize = TotalLength;
282  }
284  {
285  ExFreePool(LinkList);
287  }
288  _SEH2_END;
289 
290  ExFreePool(LinkList);
291  return STATUS_SUCCESS;
292 }
293 
294 static NTSTATUS
296 {
301  ULONG Property;
303  PVOID Buffer;
305 
306  DPRINT("IopGetDeviceProperty() called\n");
307  DPRINT("Device name: %wZ\n", &PropertyData->DeviceInstance);
308 
310  if (!NT_SUCCESS(Status))
311  {
312  return Status;
313  }
314 
315  _SEH2_TRY
316  {
317  Property = PropertyData->Property;
318  BufferSize = PropertyData->BufferSize;
319  ProbeForWrite(PropertyData->Buffer,
320  BufferSize,
321  sizeof(UCHAR));
322  }
324  {
325  if (DeviceInstance.Buffer != NULL)
326  {
328  }
330  }
331  _SEH2_END;
332 
333  /* Get the device object */
335  if (DeviceInstance.Buffer != NULL)
336  {
338  }
339  if (DeviceObject == NULL)
340  {
341  return STATUS_NO_SUCH_DEVICE;
342  }
343 
345  if (Buffer == NULL)
346  {
349  }
350 
351 
352  DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
353 
355  {
356  if (BufferSize < sizeof(CM_POWER_DATA))
357  {
358  BufferSize = 0;
360  }
361  else
362  {
364  PCM_POWER_DATA PowerData;
367 
368  PowerData = (PCM_POWER_DATA)Buffer;
369  RtlZeroMemory(PowerData, sizeof(CM_POWER_DATA));
370  PowerData->PD_Size = sizeof(CM_POWER_DATA);
371 
374  DeviceCapabilities.Version = 1;
375  DeviceCapabilities.Address = -1;
376  DeviceCapabilities.UINumber = -1;
377 
378  Stack.Parameters.DeviceCapabilities.Capabilities = &DeviceCapabilities;
379 
381  &IoStatusBlock,
383  &Stack);
384  if (NT_SUCCESS(Status))
385  {
386  DPRINT("Got device capabiliities\n");
387 
388  PowerData->PD_MostRecentPowerState = PowerDeviceD0; // FIXME
389  if (DeviceCapabilities.DeviceD1)
390  PowerData->PD_Capabilities |= PDCAP_D1_SUPPORTED;
391  if (DeviceCapabilities.DeviceD2)
392  PowerData->PD_Capabilities |= PDCAP_D2_SUPPORTED;
393  if (DeviceCapabilities.WakeFromD0)
395  if (DeviceCapabilities.WakeFromD1)
397  if (DeviceCapabilities.WakeFromD2)
399  if (DeviceCapabilities.WakeFromD3)
401  if (DeviceCapabilities.WarmEjectSupported)
403  PowerData->PD_D1Latency = DeviceCapabilities.D1Latency;
404  PowerData->PD_D2Latency = DeviceCapabilities.D2Latency;
405  PowerData->PD_D3Latency = DeviceCapabilities.D3Latency;
407  &DeviceCapabilities.DeviceState,
408  sizeof(DeviceCapabilities.DeviceState));
409  PowerData->PD_DeepestSystemWake = DeviceCapabilities.SystemWake;
410  }
411  else
412  {
413  DPRINT("IRP_MN_QUERY_CAPABILITIES failed (Status 0x%08lx)\n", Status);
414 
417  }
418  }
419  }
421  {
423  BufferSize = 0;
425  }
427  {
428  if (BufferSize < sizeof(DeviceNode->HardwareRemovalPolicy))
429  {
430  BufferSize = 0;
432  }
433  else
434  {
435  BufferSize = sizeof(DeviceNode->HardwareRemovalPolicy);
437  &DeviceNode->HardwareRemovalPolicy,
438  BufferSize);
439  }
440  }
441  else
442  {
443  switch (Property)
444  {
447  break;
448 
451  break;
452 
455  break;
456 
459  break;
460 
463  break;
464 
467  break;
468 
471  break;
472 
475  break;
476 
479  break;
480 
481 #if (WINVER >= _WIN32_WINNT_WS03)
484  BufferSize = 0;
486  break;
487 #endif
488 
489 #if (WINVER >= _WIN32_WINNT_WIN7)
492  break;
493 #endif
494 
495  default:
496  BufferSize = 0;
498  break;
499  }
500 
501  if (Status == STATUS_SUCCESS)
502  {
505  BufferSize,
506  Buffer,
507  &BufferSize);
508  }
509  }
510 
512 
513  if (NT_SUCCESS(Status))
514  {
515  _SEH2_TRY
516  {
518  PropertyData->BufferSize = BufferSize;
519  }
521  {
523  }
524  _SEH2_END;
525  }
526 
528  return Status;
529 }
530 
531 
532 static NTSTATUS
534 {
535  UNICODE_STRING RootDeviceName;
538  PDEVICE_NODE RelatedDeviceNode;
539  UNICODE_STRING TargetDeviceInstance;
541  ULONG Relation = 0;
542  ULONG MaximumLength = 0;
543 
544  DPRINT("IopGetRelatedDevice() called\n");
545  DPRINT("Device name: %wZ\n", &RelatedDeviceData->TargetDeviceInstance);
546 
547  Status = IopCaptureUnicodeString(&TargetDeviceInstance, &RelatedDeviceData->TargetDeviceInstance);
548  if (!NT_SUCCESS(Status))
549  {
550  return Status;
551  }
552 
553  _SEH2_TRY
554  {
555  Relation = RelatedDeviceData->Relation;
556  MaximumLength = RelatedDeviceData->RelatedDeviceInstanceLength;
557  ProbeForWrite(RelatedDeviceData->RelatedDeviceInstance,
559  sizeof(WCHAR));
560  }
562  {
563  if (TargetDeviceInstance.Buffer != NULL)
564  {
565  ExFreePool(TargetDeviceInstance.Buffer);
566  }
568  }
569  _SEH2_END;
570 
571  RtlInitUnicodeString(&RootDeviceName,
572  L"HTREE\\ROOT\\0");
573  if (RtlEqualUnicodeString(&TargetDeviceInstance,
574  &RootDeviceName,
575  TRUE))
576  {
578  if (TargetDeviceInstance.Buffer != NULL)
579  {
580  ExFreePool(TargetDeviceInstance.Buffer);
581  }
582  }
583  else
584  {
585  /* Get the device object */
586  DeviceObject = IopGetDeviceObjectFromDeviceInstance(&TargetDeviceInstance);
587  if (TargetDeviceInstance.Buffer != NULL)
588  {
589  ExFreePool(TargetDeviceInstance.Buffer);
590  }
591  if (DeviceObject == NULL)
592  return STATUS_NO_SUCH_DEVICE;
593 
594  DeviceNode = ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
595  }
596 
597  switch (Relation)
598  {
600  RelatedDeviceNode = DeviceNode->Parent;
601  break;
602 
604  RelatedDeviceNode = DeviceNode->Child;
605  break;
606 
608  RelatedDeviceNode = DeviceNode->Sibling;
609  break;
610 
611  default:
612  if (DeviceObject != NULL)
613  {
615  }
616 
618  }
619 
620  if (RelatedDeviceNode == NULL)
621  {
622  if (DeviceObject)
623  {
625  }
626 
627  return STATUS_NO_SUCH_DEVICE;
628  }
629 
630  if (RelatedDeviceNode->InstancePath.Length > MaximumLength)
631  {
632  if (DeviceObject)
633  {
635  }
636 
638  }
639 
640  /* Copy related device instance name */
641  _SEH2_TRY
642  {
643  RtlCopyMemory(RelatedDeviceData->RelatedDeviceInstance,
644  RelatedDeviceNode->InstancePath.Buffer,
645  RelatedDeviceNode->InstancePath.Length);
646  RelatedDeviceData->RelatedDeviceInstanceLength = RelatedDeviceNode->InstancePath.Length;
647  }
649  {
651  }
652  _SEH2_END;
653 
654  if (DeviceObject != NULL)
655  {
657  }
658 
659  DPRINT("IopGetRelatedDevice() done\n");
660 
661  return Status;
662 }
663 
664 static
665 BOOLEAN
668 {
669  return (DeviceNode->State == DeviceNodeStartPending ||
672  DeviceNode->State == DeviceNodeStarted ||
676  DeviceNode->State == DeviceNodeStopped ||
678 }
679 
680 static ULONG
682 {
684 
685  if (DeviceNode->Parent == IopRootDeviceNode)
687 
688  // FIXME: review for deleted and removed states
689  if (DeviceNode->State >= DeviceNodeDriversAdded)
691 
693  Output |= DN_STARTED;
694 
695  if (DeviceNode->UserFlags & DNUF_WILL_BE_REMOVED)
697 
698  if (DeviceNode->Flags & DNF_HAS_PROBLEM)
700 
701  if (DeviceNode->Flags & DNF_HAS_PRIVATE_PROBLEM)
703 
704  if (DeviceNode->Flags & DNF_DRIVER_BLOCKED)
706 
709 
710  if (DeviceNode->Flags & DNF_HAS_PRIVATE_PROBLEM)
712 
713  if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
715 
716  if (DeviceNode->UserFlags & DNUF_DONT_SHOW_IN_UI)
718 
719  if (!(DeviceNode->UserFlags & DNUF_NOT_DISABLEABLE))
721 
722  return Output;
723 }
724 
725 static NTSTATUS
727 {
730  ULONG Operation = 0;
731  ULONG DeviceStatus = 0;
732  ULONG DeviceProblem = 0;
735 
736  DPRINT("IopDeviceStatus() called\n");
737 
739  if (!NT_SUCCESS(Status))
740  {
741  return Status;
742  }
743 
744  DPRINT("Device name: '%wZ'\n", &DeviceInstance);
745 
746  _SEH2_TRY
747  {
748  Operation = StatusData->Operation;
750  {
751  DeviceStatus = StatusData->DeviceStatus;
752  DeviceProblem = StatusData->DeviceProblem;
753  }
754  }
756  {
757  if (DeviceInstance.Buffer != NULL)
758  {
760  }
762  }
763  _SEH2_END;
764 
765  /* Get the device object */
767  if (DeviceInstance.Buffer != NULL)
768  {
770  }
771  if (DeviceObject == NULL)
772  {
773  return STATUS_NO_SUCH_DEVICE;
774  }
775 
777 
778  switch (Operation)
779  {
781  DPRINT("Get status data\n");
782  DeviceStatus = IopGetDeviceNodeStatus(DeviceNode);
783  DeviceProblem = DeviceNode->Problem;
784  break;
785 
787  DPRINT1("Set status data is NOT SUPPORTED\n");
788  break;
789 
791  DPRINT1("FIXME: Clear status data!\n");
792  break;
793  }
794 
796 
798  {
799  _SEH2_TRY
800  {
801  StatusData->DeviceStatus = DeviceStatus;
802  StatusData->DeviceProblem = DeviceProblem;
803  }
805  {
807  }
808  _SEH2_END;
809  }
810 
811  return Status;
812 }
813 
814 static
815 NTSTATUS
817 {
822  PDEVICE_RELATIONS DeviceRelations = NULL;
823  PDEVICE_OBJECT ChildDeviceObject;
824  PDEVICE_NODE ChildDeviceNode;
825  ULONG i;
826  ULONG Relations;
828  ULONG BufferLeft;
829  PWCHAR Buffer, Ptr;
831 
832  DPRINT("IopGetDeviceRelations() called\n");
833  DPRINT("Device name: %wZ\n", &RelationsData->DeviceInstance);
834  DPRINT("Relations: %lu\n", RelationsData->Relations);
835  DPRINT("BufferSize: %lu\n", RelationsData->BufferSize);
836  DPRINT("Buffer: %p\n", RelationsData->Buffer);
837 
838  _SEH2_TRY
839  {
840  Relations = RelationsData->Relations;
841  BufferSize = RelationsData->BufferSize;
842  Buffer = RelationsData->Buffer;
843 
844  ProbeForWrite(Buffer, BufferSize, sizeof(CHAR));
845  }
847  {
849  }
850  _SEH2_END;
851 
853  if (!NT_SUCCESS(Status))
854  {
855  DPRINT1("IopCaptureUnicodeString() failed (Status 0x%08lx)\n", Status);
856  return Status;
857  }
858 
859  /* Get the device object */
861  if (DeviceObject == NULL)
862  {
863  DPRINT1("IopGetDeviceObjectFromDeviceInstance() returned NULL\n");
865  goto done;
866  }
867 
868  switch (Relations)
869  {
870  case PNP_EJECT_RELATIONS:
871  Stack.Parameters.QueryDeviceRelations.Type = EjectionRelations;
872  break;
873 
875  Stack.Parameters.QueryDeviceRelations.Type = RemovalRelations;
876  break;
877 
878  case PNP_POWER_RELATIONS:
879  Stack.Parameters.QueryDeviceRelations.Type = PowerRelations;
880  break;
881 
882  case PNP_BUS_RELATIONS:
883  Stack.Parameters.QueryDeviceRelations.Type = BusRelations;
884  break;
885 
886  default:
888  goto done;
889  }
890 
892  &IoStatusBlock,
894  &Stack);
895  if (!NT_SUCCESS(Status))
896  {
897  DPRINT1("IopInitiatePnpIrp() failed (Status 0x%08lx)\n", Status);
898  goto done;
899  }
900 
901  DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
902 
903  DPRINT("Found %d device relations\n", DeviceRelations->Count);
904 
905  _SEH2_TRY
906  {
907  RequiredSize = 0;
908  BufferLeft = BufferSize;
909  Ptr = Buffer;
910 
911  for (i = 0; i < DeviceRelations->Count; i++)
912  {
913  ChildDeviceObject = DeviceRelations->Objects[i];
914 
915  ChildDeviceNode = IopGetDeviceNode(ChildDeviceObject);
916  if (ChildDeviceNode)
917  {
918  DPRINT("Device instance: %wZ\n", &ChildDeviceNode->InstancePath);
919  DPRINT("RequiredSize: %hu\n", ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
920 
921  if (Ptr != NULL)
922  {
923  if (BufferLeft < ChildDeviceNode->InstancePath.Length + 2 * sizeof(WCHAR))
924  {
926  break;
927  }
928 
930  ChildDeviceNode->InstancePath.Buffer,
931  ChildDeviceNode->InstancePath.Length);
932  Ptr = (PWCHAR)((ULONG_PTR)Ptr + ChildDeviceNode->InstancePath.Length);
933  *Ptr = UNICODE_NULL;
934  Ptr = (PWCHAR)((ULONG_PTR)Ptr + sizeof(WCHAR));
935 
936  BufferLeft -= (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
937  }
938 
939  RequiredSize += (ChildDeviceNode->InstancePath.Length + sizeof(WCHAR));
940  }
941  }
942 
943  if (Ptr != NULL && BufferLeft >= sizeof(WCHAR))
944  *Ptr = UNICODE_NULL;
945 
946  if (RequiredSize > 0)
947  RequiredSize += sizeof(WCHAR);
948 
949  DPRINT("BufferSize: %lu RequiredSize: %lu\n", RelationsData->BufferSize, RequiredSize);
950 
951  RelationsData->BufferSize = RequiredSize;
952  }
954  {
956  }
957  _SEH2_END;
958 
959 done:
960  if (DeviceRelations != NULL)
961  ExFreePool(DeviceRelations);
962 
963  if (DeviceObject != NULL)
965 
966  if (DeviceInstance.Buffer != NULL)
968 
969  return Status;
970 }
971 
972 static NTSTATUS
974 {
979 
980  DPRINT("IopGetDeviceDepth() called\n");
981  DPRINT("Device name: %wZ\n", &DepthData->DeviceInstance);
982 
984  if (!NT_SUCCESS(Status))
985  {
986  return Status;
987  }
988 
989  /* Get the device object */
991  if (DeviceInstance.Buffer != NULL)
992  {
994  }
995  if (DeviceObject == NULL)
996  {
997  return STATUS_NO_SUCH_DEVICE;
998  }
999 
1001 
1002  _SEH2_TRY
1003  {
1004  DepthData->Depth = DeviceNode->Level;
1005  }
1007  {
1009  }
1010  _SEH2_END;
1011 
1013 
1014  return Status;
1015 }
1016 
1017 static
1018 NTSTATUS
1022 {
1024  NTSTATUS Status;
1026 
1030 
1032  if (!NT_SUCCESS(Status))
1033  {
1034  return Status;
1035  }
1036 
1038  if (DeviceInstance.Buffer != NULL)
1039  {
1041  }
1042  if (DeviceObject == NULL)
1043  {
1044  return STATUS_NO_SUCH_DEVICE;
1045  }
1046 
1048 
1049  switch (ControlClass)
1050  {
1053  break;
1056  break;
1059  break;
1060  default:
1061  UNREACHABLE;
1062  break;
1063  }
1064 
1066 
1068 
1069  return Status;
1070 }
1071 
1072 /* PUBLIC FUNCTIONS **********************************************************/
1073 
1074 /*
1075  * Plug and Play event structure used by NtGetPlugPlayEvent.
1076  *
1077  * EventGuid
1078  * Can be one of the following values:
1079  * GUID_HWPROFILE_QUERY_CHANGE
1080  * GUID_HWPROFILE_CHANGE_CANCELLED
1081  * GUID_HWPROFILE_CHANGE_COMPLETE
1082  * GUID_TARGET_DEVICE_QUERY_REMOVE
1083  * GUID_TARGET_DEVICE_REMOVE_CANCELLED
1084  * GUID_TARGET_DEVICE_REMOVE_COMPLETE
1085  * GUID_PNP_CUSTOM_NOTIFICATION
1086  * GUID_PNP_POWER_NOTIFICATION
1087  * GUID_DEVICE_* (see above)
1088  *
1089  * EventCategory
1090  * Type of the event that happened.
1091  *
1092  * Result
1093  * ?
1094  *
1095  * Flags
1096  * ?
1097  *
1098  * TotalSize
1099  * Size of the event block including the device IDs and other
1100  * per category specific fields.
1101  */
1102 
1103 /*
1104  * NtGetPlugPlayEvent
1105  *
1106  * Returns one Plug & Play event from a global queue.
1107  *
1108  * Parameters
1109  * Reserved1
1110  * Reserved2
1111  * Always set to zero.
1112  *
1113  * Buffer
1114  * The buffer that will be filled with the event information on
1115  * successful return from the function.
1116  *
1117  * BufferSize
1118  * Size of the buffer pointed by the Buffer parameter. If the
1119  * buffer size is not large enough to hold the whole event
1120  * information, error STATUS_BUFFER_TOO_SMALL is returned and
1121  * the buffer remains untouched.
1122  *
1123  * Return Values
1124  * STATUS_PRIVILEGE_NOT_HELD
1125  * STATUS_BUFFER_TOO_SMALL
1126  * STATUS_SUCCESS
1127  *
1128  * Remarks
1129  * This function isn't multi-thread safe!
1130  *
1131  * @implemented
1132  */
1133 NTSTATUS
1134 NTAPI
1136  IN ULONG Reserved2,
1139 {
1141  NTSTATUS Status;
1142 
1143  DPRINT("NtGetPlugPlayEvent() called\n");
1144 
1145  /* Function can only be called from user-mode */
1146  if (KeGetPreviousMode() == KernelMode)
1147  {
1148  DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
1149  return STATUS_ACCESS_DENIED;
1150  }
1151 
1152  /* Check for Tcb privilege */
1154  UserMode))
1155  {
1156  DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
1158  }
1159 
1160  /* Wait for a PnP event */
1161  DPRINT("Waiting for pnp notification event\n");
1163  UserRequest,
1164  UserMode,
1165  FALSE,
1166  NULL);
1168  {
1169  DPRINT("KeWaitForSingleObject() failed (Status %lx)\n", Status);
1171  return Status;
1172  }
1173 
1174  /* Get entry from the tail of the queue */
1177  ListEntry);
1178 
1179  /* Check the buffer size */
1180  if (BufferSize < Entry->Event.TotalSize)
1181  {
1182  DPRINT1("Buffer is too small for the pnp-event\n");
1183  return STATUS_BUFFER_TOO_SMALL;
1184  }
1185 
1186  /* Copy event data to the user buffer */
1187  _SEH2_TRY
1188  {
1190  Entry->Event.TotalSize,
1191  sizeof(UCHAR));
1193  &Entry->Event,
1194  Entry->Event.TotalSize);
1195  }
1197  {
1199  }
1200  _SEH2_END;
1201 
1202  DPRINT("NtGetPlugPlayEvent() done\n");
1203 
1204  return STATUS_SUCCESS;
1205 }
1206 
1207 /*
1208  * NtPlugPlayControl
1209  *
1210  * A function for doing various Plug & Play operations from user mode.
1211  *
1212  * Parameters
1213  * PlugPlayControlClass
1214  * 0x00 Reenumerate device tree
1215  *
1216  * Buffer points to UNICODE_STRING decribing the instance
1217  * path (like "HTREE\ROOT\0" or "Root\ACPI_HAL\0000"). For
1218  * more information about instance paths see !devnode command
1219  * in kernel debugger or look at "Inside Windows 2000" book,
1220  * chapter "Driver Loading, Initialization, and Installation".
1221  *
1222  * 0x01 Register new device
1223  * 0x02 Deregister device
1224  * 0x03 Initialize device
1225  * 0x04 Start device
1226  * 0x06 Query and remove device
1227  * 0x07 User response
1228  *
1229  * Called after processing the message from NtGetPlugPlayEvent.
1230  *
1231  * 0x08 Generate legacy device
1232  * 0x09 Get interface device list
1233  * 0x0A Get property data
1234  * 0x0B Device class association (Registration)
1235  * 0x0C Get related device
1236  * 0x0D Get device interface alias
1237  * 0x0E Get/set/clear device status
1238  * 0x0F Get device depth
1239  * 0x10 Query device relations
1240  * 0x11 Query target device relation
1241  * 0x12 Query conflict list
1242  * 0x13 Retrieve dock data
1243  * 0x14 Reset device
1244  * 0x15 Halt device
1245  * 0x16 Get blocked driver data
1246  *
1247  * Buffer
1248  * The buffer contains information that is specific to each control
1249  * code. The buffer is read-only.
1250  *
1251  * BufferSize
1252  * Size of the buffer pointed by the Buffer parameter. If the
1253  * buffer size specifies incorrect value for specified control
1254  * code, error ??? is returned.
1255  *
1256  * Return Values
1257  * STATUS_PRIVILEGE_NOT_HELD
1258  * STATUS_SUCCESS
1259  * ...
1260  *
1261  * @unimplemented
1262  */
1263 NTSTATUS
1264 NTAPI
1266  IN OUT PVOID Buffer,
1268 {
1269  DPRINT("NtPlugPlayControl(%d %p %lu) called\n",
1270  PlugPlayControlClass, Buffer, BufferLength);
1271 
1272  /* Function can only be called from user-mode */
1273  if (KeGetPreviousMode() == KernelMode)
1274  {
1275  DPRINT1("NtGetPlugPlayEvent cannot be called from kernel mode!\n");
1276  return STATUS_ACCESS_DENIED;
1277  }
1278 
1279  /* Check for Tcb privilege */
1281  UserMode))
1282  {
1283  DPRINT1("NtGetPlugPlayEvent: Caller does not hold the SeTcbPrivilege privilege!\n");
1285  }
1286 
1287  /* Probe the buffer */
1288  _SEH2_TRY
1289  {
1291  BufferLength,
1292  sizeof(ULONG));
1293  }
1295  {
1297  }
1298  _SEH2_END;
1299 
1300  switch (PlugPlayControlClass)
1301  {
1304  return STATUS_INVALID_PARAMETER;
1305  // the Flags field is not used anyway
1307  PlugPlayControlClass);
1308 
1309 // case PlugPlayControlRegisterNewDevice:
1310 // case PlugPlayControlDeregisterDevice:
1311 // case PlugPlayControlInitializeDevice:
1312 
1316  return STATUS_INVALID_PARAMETER;
1318  PlugPlayControlClass);
1319 
1320 // case PlugPlayControlUnlockDevice:
1321 // case PlugPlayControlQueryAndRemoveDevice:
1322 
1325  return STATUS_INVALID_PARAMETER;
1327 
1328 // case PlugPlayControlGenerateLegacyDevice:
1329 
1332  return STATUS_INVALID_PARAMETER;
1334 
1337  return STATUS_INVALID_PARAMETER;
1339 
1340 // case PlugPlayControlDeviceClassAssociation:
1341 
1344  return STATUS_INVALID_PARAMETER;
1346 
1347 // case PlugPlayControlGetInterfaceDeviceAlias:
1348 
1351  return STATUS_INVALID_PARAMETER;
1353 
1356  return STATUS_INVALID_PARAMETER;
1358 
1361  return STATUS_INVALID_PARAMETER;
1363 
1364 // case PlugPlayControlTargetDeviceRelation:
1365 // case PlugPlayControlQueryConflictList:
1366 // case PlugPlayControlRetrieveDock:
1367 // case PlugPlayControlHaltDevice:
1368 // case PlugPlayControlGetBlockedDriverList:
1369 
1370  default:
1371  return STATUS_NOT_IMPLEMENTED;
1372  }
1373 
1374  return STATUS_NOT_IMPLEMENTED;
1375 }
DEVICE_REGISTRY_PROPERTY
Definition: iotypes.h:1194
static ULONG IopGetDeviceNodeStatus(PDEVICE_NODE DeviceNode)
Definition: plugplay.c:681
#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:627
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:533
#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:1107
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
#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:816
_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:195
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:295
_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
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define FALSE
Definition: types.h:117
#define UNICODE_NULL
#define DNUF_DONT_SHOW_IN_UI
Definition: iotypes.h:209
NTSTATUS NTAPI NtGetPlugPlayEvent(IN ULONG Reserved1, IN ULONG Reserved2, OUT PPLUGPLAY_EVENT_BLOCK Buffer, IN ULONG BufferSize)
Definition: plugplay.c:1135
#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
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:666
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#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:726
#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
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
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
static const WCHAR L[]
Definition: oid.c:1250
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:973
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:2693
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:1019
ULONG_PTR SIZE_T
Definition: typedefs.h:80
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:1265
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
struct _PLUGPLAY_EVENT_BLOCK::@2317::@2320 TargetDevice
#define OUT
Definition: typedefs.h:40
#define ObReferenceObject
Definition: obfuncs.h:204
unsigned int ULONG
Definition: retypes.h:1
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
#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:217
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