ReactOS  0.4.14-dev-583-g2a1ba2c
swenum.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS Kernel Streaming
4  * FILE: drivers/ksfilter/ks/swenum.c
5  * PURPOSE: KS Software BUS functions
6  * PROGRAMMER: Johannes Anderwald
7  */
8 
9 #include "precomp.h"
10 
11 #include <stdio.h>
12 #include <swenum.h>
13 
14 #define NDEBUG
15 #include <debug.h>
16 
18 
20  IN PHANDLE hKey,
21  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
22  IN PBUS_DEVICE_ENTRY DummyEntry,
23  IN LPWSTR RootName,
24  IN LPWSTR DirectoryName);
25 
28  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
29  IN PBUS_DEVICE_ENTRY DeviceEntry,
30  OUT PDEVICE_OBJECT * OutDeviceObject)
31 {
33  WCHAR Buffer[50];
34  ULONG CurDeviceId;
37  PCOMMON_DEVICE_EXTENSION DeviceExtension;
38 
39  /* increment device count */
40  CurDeviceId = InterlockedIncrement(&KsDeviceCount);
41 
42  /* generate new device id */
43  swprintf(Buffer, L"\\Device\\KSENUM%08x", CurDeviceId);
44 
45  /* initialize new device name */
47 
48  /* create new device object */
49  Status = IoCreateDevice(BusDeviceExtension->BusDeviceObject->DriverObject, sizeof(PVOID), &DeviceName, FILE_DEVICE_UNKNOWN, 0, FALSE, &DeviceObject);
50 
51  /* check for success */
52  if (!NT_SUCCESS(Status))
53  {
54  /* failed to create pdo */
55  return Status;
56  }
57 
58  /* now allocate device extension */
60  if (!DeviceExtension)
61  {
62  /* no memory */
65  }
66 
67  /* store device extension */
68  *((PVOID*)DeviceObject->DeviceExtension) = DeviceExtension;
69 
70  /* initialize device extension */
71  DeviceExtension->IsBus = FALSE;
72  DeviceExtension->DeviceObject = DeviceObject;
73  DeviceExtension->DeviceEntry = DeviceEntry;
74  DeviceExtension->BusDeviceExtension = BusDeviceExtension;
75 
76  /* not started yet*/
77  DeviceEntry->DeviceState = NotStarted;
78 
79  /* get current time */
80  KeQuerySystemTime(&DeviceEntry->TimeCreated);
81 
82  /* setup flags */
85  /* TODO: fire time when expired */
86 
87  *OutDeviceObject = DeviceObject;
88 
89  return STATUS_SUCCESS;
90 }
91 
94  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
95  IN PBUS_DEVICE_ENTRY DeviceEntry,
96  IN OUT PBUS_INSTANCE_ENTRY BusInstanceEntry)
97 {
100 
101  /* initialize reference string */
102  RtlInitUnicodeString(&ReferenceString, DeviceEntry->DeviceName);
103 
104  /* register device interface */
105  Status = IoRegisterDeviceInterface(BusDeviceExtension->PhysicalDeviceObject, &BusInstanceEntry->InterfaceGuid, &ReferenceString, &BusInstanceEntry->SymbolicLink);
106 
107  /* check for success */
108  if (!NT_SUCCESS(Status))
109  {
110  /* failed */
111  return Status;
112  }
113 
114  /* now enable the interface */
115  Status = IoSetDeviceInterfaceState(&BusInstanceEntry->SymbolicLink, TRUE);
116 
117  /* check for success */
118  if (!NT_SUCCESS(Status))
119  {
120  /* failed, free memory */
121  FreeItem(BusInstanceEntry->SymbolicLink.Buffer);
122  return Status;
123  }
124 
125  DPRINT("Registered DeviceInterface %wZ\n", &BusInstanceEntry->SymbolicLink);
126 
127 
128  /* done */
129  return Status;
130 }
131 
132 VOID
134  IN PBUS_DEVICE_ENTRY DeviceEntry)
135 {
137  PBUS_INSTANCE_ENTRY CurEntry;
138 
139  /* remove all entries */
140  Entry = DeviceEntry->DeviceInterfaceList.Flink;
141 
142  while(Entry != &DeviceEntry->DeviceInterfaceList)
143  {
144  /* get offset */
146 
147  /* sanity check */
148  ASSERT(CurEntry->SymbolicLink.Buffer);
149 
150  /* de-register interface */
152 
153  /* free symbolic link buffer */
154  FreeItem(CurEntry->SymbolicLink.Buffer);
155 
156  /* remove entry from list */
158 
159  /* move to next entry */
160  Entry = Entry->Flink;
161 
162  /* free entry */
163  FreeItem(CurEntry);
164  }
165 }
166 
167 NTSTATUS
169  IN HANDLE hKey,
172  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
173  IN PBUS_DEVICE_ENTRY DeviceEntry)
174 {
177  HANDLE hNewKey;
179  ULONG ResultLength, Index, KeyInfoLength;
180  KEY_FULL_INFORMATION KeyInformation;
181  PKEY_BASIC_INFORMATION KeyInfo;
182 
183  /* initialize key name */
185 
186  /* initialize object attributes */
188 
189  /* open new key */
190  Status = ZwOpenKey(&hNewKey, GENERIC_READ, &ObjectAttributes);
191 
192  /* check for success */
193  if (!NT_SUCCESS(Status))
194  {
195  /* failed to open key */
196 
197  return Status;
198  }
199 
200  /* query key stats */
201  Status = ZwQueryKey(hNewKey, KeyFullInformation, &KeyInformation, sizeof(KeyInformation), &ResultLength);
202 
203  if (!NT_SUCCESS(Status))
204  {
205  /* close key */
206  ZwClose(hNewKey);
207 
208  /* done */
209  return Status;
210  }
211 
212  /* calculate key info length */
213  KeyInfoLength = KeyInformation.MaxNameLen + sizeof(KEY_BASIC_INFORMATION) + 1 * sizeof(WCHAR);
214 
215  /* allocate buffer */
216  KeyInfo = (PKEY_BASIC_INFORMATION)AllocateItem(NonPagedPool, KeyInfoLength);
217  if (!KeyInfo)
218  {
219 
220  /* no memory */
221  ZwClose(hNewKey);
222 
223  /* done */
225  }
226 
227  /* enumerate all keys */
228  for(Index = 0; Index < KeyInformation.SubKeys; Index++)
229  {
230 
231  /* query sub key */
232  Status = ZwEnumerateKey(hNewKey, Index, KeyBasicInformation, (PVOID)KeyInfo, KeyInfoLength, &ResultLength);
233 
234  /* check for success */
235  if (NT_SUCCESS(Status))
236  {
237  /* perform callback */
238  Status = Callback(hNewKey, BusDeviceExtension, DeviceEntry, KeyInfo->Name, ReferenceString);
239 
240  /* should enumeration stop */
241  if (!NT_SUCCESS(Status))
242  break;
243  }
244  }
245 
246  /* free info buffer */
247  FreeItem(KeyInfo);
248 
249  /* close key */
250  ZwClose(hNewKey);
251 
252  /* done */
253  return Status;
254 }
255 
256 NTSTATUS
257 NTAPI
259  IN PHANDLE hKey,
260  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
261  IN PBUS_DEVICE_ENTRY DeviceEntry,
262  IN LPWSTR InterfaceString,
264 {
265  GUID InterfaceGUID;
268  PBUS_INSTANCE_ENTRY CurEntry;
270 
271  /* initialize interface string */
272  RtlInitUnicodeString(&DeviceName, InterfaceString);
273 
274  /* first convert device name to guid */
275  RtlGUIDFromString(&DeviceName, &InterfaceGUID);
276 
277  /* check if the device is already present */
278  Entry = DeviceEntry->DeviceInterfaceList.Flink;
279  DPRINT("KspCreateDeviceAssociation ReferenceString %S\n", ReferenceString);
280  DPRINT("KspCreateDeviceAssociation InterfaceString %S\n", InterfaceString);
281 
282  while(Entry != &DeviceEntry->DeviceInterfaceList)
283  {
284  /* get offset */
286 
287  if (IsEqualGUIDAligned(&CurEntry->InterfaceGuid, &InterfaceGUID))
288  {
289  /* entry already exists */
290  return STATUS_SUCCESS;
291  }
292 
293  /* move to next entry */
294  Entry = Entry->Flink;
295  }
296 
297  /* time to allocate new entry */
299 
300  if (!CurEntry)
301  {
302  /* no memory */
304  }
305 
306  /* store guid */
307  RtlMoveMemory(&CurEntry->InterfaceGuid, &InterfaceGUID, sizeof(GUID));
308 
309  /* now register the association */
310  Status = KspRegisterDeviceAssociation(BusDeviceExtension, DeviceEntry, CurEntry);
311 
312  /* check for success */
313  if (NT_SUCCESS(Status))
314  {
315  /* store entry */
316  InsertTailList(&DeviceEntry->DeviceInterfaceList, &CurEntry->Entry);
317  }
318  else
319  {
320  /* failed to associated device */
321  FreeItem(CurEntry);
322  }
323 
324  /* done */
325  return Status;
326 }
327 
328 NTSTATUS
329 NTAPI
331  IN PHANDLE hKey,
332  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
333  IN PBUS_DEVICE_ENTRY DummyEntry,
334  IN LPWSTR InterfaceId,
335  IN LPWSTR DeviceId)
336 {
338  SIZE_T Length;
340  PBUS_DEVICE_ENTRY DeviceEntry = NULL; /* GCC warning */
341  BOOLEAN ItemExists = FALSE;
344  KIRQL OldLevel;
345 
346  /* first construct device name & reference guid */
347  Length = wcslen(DeviceId) + wcslen(InterfaceId);
348 
349  /* append '&' and null byte */
350  Length += 2;
351 
352  /* allocate device name */
354 
355  if (!DeviceName)
356  {
357  /* not enough memory */
359  }
360 
361  /* construct device name */
362  wcscpy(DeviceName, DeviceId);
363  wcscat(DeviceName, L"&");
364  wcscat(DeviceName, InterfaceId);
365 
366  /* scan list and check if it is already present */
367  Entry = BusDeviceExtension->Common.Entry.Flink;
368 
369  while(Entry != &BusDeviceExtension->Common.Entry)
370  {
371  /* get real offset */
373 
374  /* check if name matches */
375  if (!wcsicmp(DeviceEntry->DeviceName, DeviceName))
376  {
377  /* item already exists */
378  ItemExists = TRUE;
379  break;
380  }
381 
382  /* move to next entry */
383  Entry = Entry->Flink;
384  }
385 
386  if (!ItemExists)
387  {
388  /* allocate new device entry */
389  DeviceEntry = AllocateItem(NonPagedPool, sizeof(BUS_DEVICE_ENTRY));
390  if (!DeviceEntry)
391  {
392  /* no memory */
395  }
396 
397  /* initialize device entry */
399  InitializeListHead(&DeviceEntry->IrpPendingList);
400 
401  /* copy device guid */
402  RtlInitUnicodeString(&String, DeviceId);
403  RtlGUIDFromString(&String, &DeviceEntry->DeviceGuid);
404 
405  /* copy device names */
406  DeviceEntry->DeviceName = DeviceName;
407  DeviceEntry->Instance = (DeviceName + wcslen(DeviceId) + 1);
408 
409  /* copy name */
410  DeviceEntry->BusId = AllocateItem(NonPagedPool, (wcslen(DeviceId) + 1) * sizeof(WCHAR));
411  if (!DeviceEntry->BusId)
412  {
413  /* no memory */
415  FreeItem(DeviceEntry);
417  }
418  wcscpy(DeviceEntry->BusId, DeviceId);
419  }
420 
421  /* now enumerate the interfaces */
422  Status = KspEnumerateBusRegistryKeys(hKey, InterfaceId, KspCreateDeviceAssociation, BusDeviceExtension, DeviceEntry);
423 
424  /* check if list is empty */
425  if (IsListEmpty(&DeviceEntry->DeviceInterfaceList))
426  {
427  /* invalid device settings */
428  FreeItem(DeviceEntry->BusId);
429  FreeItem(DeviceEntry->DeviceName);
430  FreeItem(DeviceEntry);
431 
432  ASSERT(ItemExists == FALSE);
433 
435  }
436 
437  /* check if enumeration failed */
438  if (!NT_SUCCESS(Status))
439  {
440  /* failed */
441  KspRemoveDeviceAssociations(DeviceEntry);
442  FreeItem(DeviceEntry->BusId);
443  FreeItem(DeviceEntry->DeviceName);
444  FreeItem(DeviceEntry);
445 
446  ASSERT(ItemExists == FALSE);
447 
448  /* done */
449  return Status;
450  }
451 
452  if (!ItemExists)
453  {
454  /* acquire lock */
455  KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
456 
457  /* successfully initialized entry */
458  InsertTailList(&BusDeviceExtension->Common.Entry, &DeviceEntry->Entry);
459 
460  /* release lock */
461  KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
462  }
463 
464  /* done */
465  return Status;
466 }
467 
468 NTSTATUS
469 NTAPI
471  IN PHANDLE hKey,
472  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
473  IN PBUS_DEVICE_ENTRY DummyEntry,
474  IN LPWSTR DeviceCategory,
476 {
477  return KspEnumerateBusRegistryKeys(hKey, DeviceCategory, KspCreateDeviceReference, BusDeviceExtension, DummyEntry);
478 }
479 
480 
481 NTSTATUS
483  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
484  OUT PHANDLE hKey)
485 {
487 
488  /* initialize object attributes */
490 
491  return ZwCreateKey(hKey, GENERIC_READ | GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
492 }
493 
494 NTSTATUS
496  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension)
497 {
498  HANDLE hKey;
500 
501  /* first open key */
502  Status = KspOpenBusRegistryKey(BusDeviceExtension, &hKey);
503 
504  /* check for success */
505  if (!NT_SUCCESS(Status))
506  {
507  /* no success */
508 
509  return Status;
510  }
511 
512  /* TODO clear reference marks */
513 
514  /* construct device entries */
516 
517  /* TODO: delete unreferenced devices */
518 
519  /* close handle */
520  ZwClose(hKey);
521 
522  /* done */
523  return Status;
524 }
525 
526 
527 NTSTATUS
528 NTAPI
530  IN PVOID Context,
531  IN OUT PWCHAR *String)
532 {
533  LPWSTR Name;
534  SIZE_T Length;
536 
537  /* sanity checks */
538  ASSERT(BusDeviceExtension);
539  ASSERT(BusDeviceExtension->BusIdentifier);
540 
541  /* calculate length */
542  Length = wcslen(BusDeviceExtension->BusIdentifier) + 1;
543 
544  /* allocate buffer */
545  Name = AllocateItem(PagedPool, Length * sizeof(WCHAR));
546 
547  if (!Name)
548  {
549  /* failed to allocate buffer */
551  }
552 
553  /* copy buffer */
554  wcscpy(Name, BusDeviceExtension->BusIdentifier);
555 
556  /* store result */
557  *String = Name;
558 
559  /* done */
560  return STATUS_SUCCESS;
561 }
562 
563 VOID
564 NTAPI
566  IN PVOID Context)
567 {
569 
570  /* reference count */
571  InterlockedIncrement((PLONG)&ChildDeviceExtension->DeviceReferenceCount);
572 }
573 
574 VOID
575 NTAPI
577  IN PVOID Context)
578 {
580 
581  /* reference count */
582  InterlockedDecrement((PLONG)&ChildDeviceExtension->DeviceReferenceCount);
583 }
584 
585 VOID
586 NTAPI
588  IN PVOID Context)
589 {
591 
592  /* reference count */
593  InterlockedIncrement((PLONG)&ChildDeviceExtension->DeviceObjectReferenceCount);
594 }
595 
596 VOID
597 NTAPI
599  IN PVOID Context)
600 {
602 
603  /* reference count */
604  InterlockedDecrement((PLONG)&ChildDeviceExtension->DeviceObjectReferenceCount);
605 }
606 
607 NTSTATUS
609  IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
610  IN PIRP Irp)
611 {
612  PBUS_INTERFACE_SWENUM Interface;
613  PIO_STACK_LOCATION IoStack;
614 
615  /* get current irp stack location */
617 
618  /* sanity checks */
619  ASSERT(IoStack->Parameters.QueryInterface.Size == sizeof(BUS_INTERFACE_SWENUM));
620  ASSERT(IoStack->Parameters.QueryInterface.Interface);
621 
622  /* fill in interface */
623  Interface = (PBUS_INTERFACE_SWENUM)IoStack->Parameters.QueryInterface.Interface;
624  Interface->Interface.Size = sizeof(BUS_INTERFACE_SWENUM);
625  Interface->Interface.Version = BUS_INTERFACE_SWENUM_VERSION;
626  Interface->Interface.Context = ChildDeviceExtension;
627  Interface->Interface.InterfaceReference = KspBusDeviceReference;
628  Interface->Interface.InterfaceDereference = KspBusDeviceDereference;
629  Interface->ReferenceDeviceObject = KspBusReferenceDeviceObject;
630  Interface->DereferenceDeviceObject = KspBusDereferenceDeviceObject;
631  Interface->QueryReferenceString = KspBusQueryReferenceString;
632 
633  return STATUS_SUCCESS;
634 }
635 
636 NTSTATUS
638  PBUS_DEVICE_ENTRY DeviceEntry,
640 {
642  PBUS_INSTANCE_ENTRY InstanceEntry;
644 
645  /* enable now all interfaces */
646  Entry = DeviceEntry->DeviceInterfaceList.Flink;
647 
648  while(Entry != &DeviceEntry->DeviceInterfaceList)
649  {
650  /* get bus instance entry */
652  DPRINT("Enabling %u %wZ Irql %u\n", bEnable, &InstanceEntry->SymbolicLink, KeGetCurrentIrql());
653 
654  /* set interface state */
656 
657  if (!NT_SUCCESS(Status))
658  {
659  /* failed to set interface */
660  break;
661  }
662 
663  /* move to next entry */
664  Entry = Entry->Flink;
665  }
666 
667  /* done */
668  return Status;
669 }
670 
671 NTSTATUS
673  PIRP Irp,
674  PBUS_DEVICE_ENTRY DeviceEntry)
675 {
676  SIZE_T Length;
677  LPWSTR Buffer;
678  PIO_STACK_LOCATION IoStack;
679 
680  /* get stack location */
682 
683  /* sanity checks */
684  ASSERT(DeviceEntry->PDODeviceName);
685  ASSERT(DeviceEntry->Instance);
686  ASSERT(IoStack->FileObject);
687  ASSERT(IoStack->FileObject->FileName.Buffer);
688 
689  /* calculate length */
690  Length = wcslen(DeviceEntry->PDODeviceName);
691  Length += wcslen(DeviceEntry->Instance);
692 
693  /* zero byte and '\\' */
694  Length += 2;
695 
696  /* allocate buffer */
697  Buffer = ExAllocatePoolWithTag(NonPagedPool, Length * sizeof(WCHAR), 'mNoI');
698  if (!Buffer)
699  {
700  /* no resources */
702  }
703 
704  /* construct buffer */
705  swprintf(Buffer, L"%s\\%s", DeviceEntry->PDODeviceName, DeviceEntry->Instance);
706 
707  /* free old buffer*/
708  ExFreePoolWithTag(IoStack->FileObject->FileName.Buffer, 'mNoI');
709 
710  /* store new file name */
711  RtlInitUnicodeString(&IoStack->FileObject->FileName, Buffer);
712 
713  /* done */
714  return STATUS_REPARSE;
715 }
716 
717 VOID
719  IN PBUS_DEVICE_ENTRY DeviceEntry,
720  IN OUT NTSTATUS ResultCode)
721 {
723  PIRP Irp;
725 
726  /* go through list */
727  while(!IsListEmpty(&DeviceEntry->IrpPendingList))
728  {
729  /* get first entry */
730  Entry = RemoveHeadList(&DeviceEntry->IrpPendingList);
731 
732  /* get irp */
733  Irp = (PIRP)CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
734 
735  if (ResultCode == STATUS_REPARSE)
736  {
737  /* construct reparse information */
738  Status = KspDoReparseForIrp(Irp, DeviceEntry);
739  }
740  else
741  {
742  /* use default code */
743  Status = ResultCode;
744  }
745 
746  /* store result code */
747  Irp->IoStatus.Status = Status;
748 
749  DPRINT("Completing IRP %p Status %x\n", Irp, Status);
750 
751  /* complete the request */
753  }
754 
755 }
756 
757 
758 
759 NTSTATUS
762  IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
763  IN PIRP Irp)
764 {
765  WCHAR PDOName[256];
768  LPWSTR Name;
769  ULONG NameLength;
770  PBUS_DEVICE_ENTRY DeviceEntry;
771 
772  /* FIXME handle pending remove */
773 
774  /* get full device name */
776 
777  if (!NT_SUCCESS(Status))
778  {
779  /* failed to get device name */
780  return Status;
781  }
782 
783  /* allocate device name buffer */
784  NameLength = ResultLength + sizeof(UNICODE_NULL);
785  Name = AllocateItem(NonPagedPool, NameLength);
786  if (!Name)
787  {
788  /* no memory */
790  }
791 
792  /* copy name */
793  NT_VERIFY(NT_SUCCESS(RtlStringCbCopyW(Name, NameLength, PDOName)));
794 
795  /* TODO: time stamp creation time */
796 
797  /* get device entry */
798  DeviceEntry = (PBUS_DEVICE_ENTRY)ChildDeviceExtension->DeviceEntry;
799 
800  /* sanity check */
801  ASSERT(DeviceEntry);
802 
803  /* store device name */
804  DeviceEntry->PDODeviceName = Name;
805 
806  /* mark device as started */
807  DeviceEntry->DeviceState = Started;
808 
809  /* reference start time */
810  KeQuerySystemTime(&DeviceEntry->TimeCreated);
811 
812  DPRINT1("KspStartBusDevice Name %S DeviceName %S Instance %S Started\n", Name, DeviceEntry->DeviceName, DeviceEntry->Instance);
813 
814  /* enable device classes */
815  //KspEnableBusDeviceInterface(DeviceEntry, TRUE);
816 
817  /* done */
818  return STATUS_SUCCESS;
819 }
820 
821 NTSTATUS
823  IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
824  IN PIRP Irp)
825 {
827  PIO_STACK_LOCATION IoStack;
828 
829  /* get stack location */
831 
832  /* get capabilities */
833  Capabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
834 
836 
837  /* setup capabilities */
838  Capabilities->UniqueID = TRUE;
839  Capabilities->SilentInstall = TRUE;
840  Capabilities->SurpriseRemovalOK = TRUE;
841  Capabilities->Address = 0;
842  Capabilities->UINumber = 0;
843  Capabilities->SystemWake = PowerSystemWorking; /* FIXME common device extension */
844  Capabilities->DeviceWake = PowerDeviceD0;
845 
846  /* done */
847  return STATUS_SUCCESS;
848 }
849 
850 NTSTATUS
852  IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
853  IN PIRP Irp)
854 {
855  PPNP_BUS_INFORMATION BusInformation;
856 
857  /* allocate bus information */
859 
860  if (!BusInformation)
861  {
862  /* no memory */
864  }
865 
866  /* return info */
867  BusInformation->BusNumber = 0;
868  BusInformation->LegacyBusType = InterfaceTypeUndefined;
869  RtlMoveMemory(&BusInformation->BusTypeGuid, &KSMEDIUMSETID_Standard, sizeof(GUID));
870 
871  /* store result */
872  Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
873 
874  /* done */
875  return STATUS_SUCCESS;
876 }
877 
878 NTSTATUS
880  IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
881  IN PIRP Irp)
882 {
883  /* set device flags */
885 
886  /* done */
887  return STATUS_SUCCESS;
888 }
889 
890 NTSTATUS
892  IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
893  IN PIRP Irp)
894 {
895  PIO_STACK_LOCATION IoStack;
896  PBUS_DEVICE_ENTRY DeviceEntry;
897  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
898  LPWSTR Name;
899  SIZE_T Length;
900 
901  /* get current irp stack location */
903 
904  if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
905  {
906  /* get device entry */
907  DeviceEntry = (PBUS_DEVICE_ENTRY) ChildDeviceExtension->DeviceEntry;
908 
909  /* sanity check */
910  ASSERT(DeviceEntry);
911  ASSERT(DeviceEntry->Instance);
912 
913  /* calculate length */
914  Length = wcslen(DeviceEntry->Instance) + 2;
915 
916  /* allocate buffer */
917  Name = AllocateItem(PagedPool, Length * sizeof(WCHAR));
918 
919  if (!Name)
920  {
921  /* failed to allocate buffer */
923  }
924 
925  /* copy buffer */
926  wcscpy(Name, DeviceEntry->Instance);
927 
928  /* store result */
929  Irp->IoStatus.Information = (ULONG_PTR)Name;
930 
931  /* done */
932  return STATUS_SUCCESS;
933  }
934  else if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID ||
935  IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
936  {
937  /* get device entry */
938  DeviceEntry = (PBUS_DEVICE_ENTRY) ChildDeviceExtension->DeviceEntry;
939 
940  /* get bus device extension */
941  BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION) ChildDeviceExtension->BusDeviceExtension;
942 
943  /* sanity check */
944  ASSERT(DeviceEntry);
945  ASSERT(DeviceEntry->BusId);
946  ASSERT(BusDeviceExtension);
947  ASSERT(BusDeviceExtension->BusIdentifier);
948 
949  /* calculate length */
950  Length = wcslen(BusDeviceExtension->BusIdentifier);
951  Length += wcslen(DeviceEntry->BusId);
952 
953  /* extra length for '\\' and 2 zero bytes */
954  Length += 4;
955 
956  /* allocate buffer */
957  Name = AllocateItem(PagedPool, Length * sizeof(WCHAR));
958  if (!Name)
959  {
960  /* failed to allocate buffer */
962  }
963 
964  /* construct id */
965  wcscpy(Name, BusDeviceExtension->BusIdentifier);
966  wcscat(Name, L"\\");
967  wcscat(Name, DeviceEntry->BusId);
968  //swprintf(Name, L"%s\\%s", BusDeviceExtension->BusIdentifier, DeviceEntry->BusId);
969 
970  /* store result */
971  Irp->IoStatus.Information = (ULONG_PTR)Name;
972 
973  /* done */
974  return STATUS_SUCCESS;
975  }
976  else
977  {
978  /* other ids are not supported */
979  //DPRINT1("Not Supported ID Type %x\n", IoStack->Parameters.QueryId.IdType);
980  return Irp->IoStatus.Status;
981  }
982 }
983 
984 NTSTATUS
986  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
987  IN PSWENUM_INSTALL_INTERFACE InstallInterface)
988 {
990  UNICODE_STRING DeviceString, InterfaceString, ReferenceString;
991  HANDLE hKey, hDeviceKey, hInterfaceKey, hReferenceKey;
994 
995  /* sanity check */
996  ASSERT(InstallInterface);
997 
998  /* calculate length */
999  Length = wcslen(InstallInterface->ReferenceString);
1000 
1001  /* check for invalid characters */
1002  for(Index = 0; Index < Length; Index++)
1003  {
1004  if (InstallInterface->ReferenceString[Index] <= L' ' ||
1005  InstallInterface->ReferenceString[Index] > L'~' ||
1006  InstallInterface->ReferenceString[Index] == L',' ||
1007  InstallInterface->ReferenceString[Index] == L'\\' ||
1008  InstallInterface->ReferenceString[Index] == L'/')
1009  {
1010  /* invalid character */
1011  return STATUS_INVALID_PARAMETER;
1012  }
1013  }
1014 
1015  /* open bus key */
1016  Status = KspOpenBusRegistryKey(BusDeviceExtension, &hKey);
1017  if (NT_SUCCESS(Status))
1018  {
1019  /* convert device guid to string */
1020  Status = RtlStringFromGUID(&InstallInterface->DeviceId, &DeviceString);
1021  if (NT_SUCCESS(Status))
1022  {
1023  /* initialize object attributes */
1025 
1026  /* construct device key */
1027  Status = ZwCreateKey(&hDeviceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
1028  if (NT_SUCCESS(Status))
1029  {
1030  /* convert interface guid to string */
1031  Status = RtlStringFromGUID(&InstallInterface->InterfaceId, &InterfaceString);
1032  if (NT_SUCCESS(Status))
1033  {
1034  /* initialize object attributes */
1036 
1037  /* construct device key */
1038  Status = ZwCreateKey(&hInterfaceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
1039  if (NT_SUCCESS(Status))
1040  {
1041  /* initialize reference string */
1042  RtlInitUnicodeString(&ReferenceString, InstallInterface->ReferenceString);
1043 
1044  /* initialize object attributes */
1046 
1047  /* construct device key */
1048  Status = ZwCreateKey(&hReferenceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
1049  if (NT_SUCCESS(Status))
1050  {
1051  /* close key */
1052  ZwClose(hReferenceKey);
1053  }
1054  }
1055  /* free interface string */
1056  RtlFreeUnicodeString(&InterfaceString);
1057 
1058  /* close reference key */
1059  ZwClose(hInterfaceKey);
1060  }
1061  /* close device key */
1062  ZwClose(hDeviceKey);
1063  }
1064  /* free device string */
1065  RtlFreeUnicodeString(&DeviceString);
1066  }
1067  /* close bus key */
1068  ZwClose(hKey);
1069  }
1070 
1071  /* done */
1072  return Status;
1073  }
1074 
1075 VOID
1076 NTAPI
1078  IN PVOID Ctx)
1079 {
1080  PIO_STACK_LOCATION IoStack;
1081  NTSTATUS Status;
1083  PBUS_DEVICE_ENTRY DeviceEntry;
1084  PSWENUM_INSTALL_INTERFACE InstallInterface;
1085  KIRQL OldLevel;
1087 
1088  /* get current irp stack location */
1089  IoStack = IoGetCurrentIrpStackLocation(Context->Irp);
1090 
1091  /* get install request */
1092  InstallInterface = (PSWENUM_INSTALL_INTERFACE)Context->Irp->AssociatedIrp.SystemBuffer;
1093 
1094  /* sanity check */
1095  ASSERT(InstallInterface);
1096  ASSERT(Context->BusDeviceExtension);
1097 
1098  if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SWENUM_INSTALL_INTERFACE))
1099  {
1100  /* buffer too small */
1102 
1103  /* signal completion */
1104  KeSetEvent(&Context->Event, 0, FALSE);
1105 
1106  /* done */
1107  return;
1108  }
1109 
1110  /* FIXME locks */
1111 
1112  /* now install the interface */
1113  Status = KspInstallInterface(Context->BusDeviceExtension, InstallInterface);
1114  if (!NT_SUCCESS(Status))
1115  {
1116  /* failed to install interface */
1117  Context->Status = Status;
1118 
1119  /* signal completion */
1120  KeSetEvent(&Context->Event, 0, FALSE);
1121 
1122  /* done */
1123  return;
1124  }
1125 
1126  /* now scan the bus */
1127  Status = KspScanBus(Context->BusDeviceExtension);
1128  // FIXME: We may need to check for success here, and properly fail...
1130 
1131  /* acquire device entry lock */
1132  KeAcquireSpinLock(&Context->BusDeviceExtension->Lock, &OldLevel);
1133 
1134  /* now iterate all device entries */
1135  ASSERT(!IsListEmpty(&Context->BusDeviceExtension->Common.Entry));
1136  Entry = Context->BusDeviceExtension->Common.Entry.Flink;
1137  while(Entry != &Context->BusDeviceExtension->Common.Entry)
1138  {
1139  /* get device entry */
1141  if (IsEqualGUIDAligned(&DeviceEntry->DeviceGuid, &InstallInterface->DeviceId))
1142  {
1143  if (!DeviceEntry->PDO)
1144  {
1145  /* release device entry lock */
1146  KeReleaseSpinLock(&Context->BusDeviceExtension->Lock, OldLevel);
1147 
1148  /* create pdo */
1149  Status = KspCreatePDO(Context->BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
1150 
1151  /* acquire device entry lock */
1152  KeAcquireSpinLock(&Context->BusDeviceExtension->Lock, &OldLevel);
1153 
1154  /* done */
1155  break;
1156  }
1157  }
1158 
1159  /* move to next entry */
1160  Entry = Entry->Flink;
1161  }
1162 
1163  /* release device entry lock */
1164  KeReleaseSpinLock(&Context->BusDeviceExtension->Lock, OldLevel);
1165 
1166  /* signal that bus driver relations has changed */
1167  IoInvalidateDeviceRelations(Context->BusDeviceExtension->PhysicalDeviceObject, BusRelations);
1168 
1169  /* update status */
1170  Context->Status = Status;
1171 
1172  /* signal completion */
1173  KeSetEvent(&Context->Event, 0, FALSE);
1174 }
1175 
1176 
1177 VOID
1178 NTAPI
1180  IN PVOID Parameter)
1181 {
1182  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1183  PBUS_DEVICE_ENTRY DeviceEntry;
1185  LARGE_INTEGER Time, Diff;
1186  BOOLEAN DoInvalidate = FALSE;
1187  KIRQL OldLevel;
1188 
1189  /* get device extension */
1190  BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)Parameter;
1191 
1192  /* acquire lock */
1193  KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1194 
1195  /* get current time */
1197 
1198  /* enumerate all device entries */
1199  Entry = BusDeviceExtension->Common.Entry.Flink;
1200  while(Entry != &BusDeviceExtension->Common.Entry)
1201  {
1202  /* get offset to device entry */
1204 
1205  /* sanity check */
1206  ASSERT(DeviceEntry);
1207 
1208  //DPRINT1("DeviceEntry %p PDO %p State %x\n", DeviceEntry, DeviceEntry->PDO, DeviceEntry->DeviceState);
1209 
1210  if (DeviceEntry->PDO)
1211  {
1212  if (DeviceEntry->DeviceState == NotStarted)
1213  {
1214  Diff.QuadPart = Time.QuadPart - DeviceEntry->TimeCreated.QuadPart;
1215 
1216  if (Diff.QuadPart > Int32x32To64(15000, 10000))
1217  {
1218  /* release spin lock */
1219  KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1220 
1221  DPRINT1("DeviceID %S Instance %S TimeCreated %I64u Now %I64u Diff %I64u hung\n", DeviceEntry->DeviceName, DeviceEntry->Instance, DeviceEntry->TimeCreated.QuadPart, Time.QuadPart, Diff.QuadPart);
1222 
1223  /* deactivate interfaces */
1224  //KspEnableBusDeviceInterface(DeviceEntry, FALSE);
1225 
1226  /* re-acquire lock */
1227  KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1228 
1229  /* pending remove device object */
1230  DeviceEntry->DeviceState = StopPending;
1231 
1232  /* perform invalidation */
1233  DoInvalidate = TRUE;
1234  }
1235  }
1236  else if (DeviceEntry->DeviceState == Started)
1237  {
1238  /* release spin lock */
1239  KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1240 
1241  /* found pending irps */
1242  KspCompletePendingIrps(DeviceEntry, STATUS_REPARSE);
1243 
1244  /* re-acquire lock */
1245  KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1246  }
1247  }
1248 
1249 
1250  /* move to next */
1251  Entry = Entry->Flink;
1252  }
1253 
1254  /* release lock */
1255  KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1256 
1257  if (DoInvalidate)
1258  {
1259  /* invalidate device relations */
1261  }
1262 
1263  Time.QuadPart = Int32x32To64(5000, -10000);
1264  KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
1265 }
1266 
1267 VOID
1268 NTAPI
1270  IN PKDPC Dpc,
1274 {
1275  /* get device extension */
1277 
1278  /* queue the item */
1279  ExQueueWorkItem(&BusDeviceExtension->WorkItem, DelayedWorkQueue);
1280 }
1281 
1282 VOID
1283 NTAPI
1285  PVOID Ctx)
1286 {
1288 
1289  /* TODO
1290  * get SWENUM_INSTALL_INTERFACE struct
1291  * open device key and delete the keys
1292  */
1293 
1294  UNIMPLEMENTED;
1295 
1296  /* set status */
1297  Context->Status = STATUS_NOT_IMPLEMENTED;
1298 
1299 
1300  /* signal completion */
1302 }
1303 
1304 NTSTATUS
1306  IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
1307  IN PIRP Irp)
1308 {
1309  PDEVICE_RELATIONS DeviceRelations;
1311  PBUS_DEVICE_ENTRY DeviceEntry;
1312  ULONG Count = 0, Length;
1313  KIRQL OldLevel;
1314 
1315  /* acquire lock */
1316  KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1317 
1318  /* first scan all device entries */
1319  Entry = BusDeviceExtension->Common.Entry.Flink;
1320 
1321  while(Entry != &BusDeviceExtension->Common.Entry)
1322  {
1323  /* get offset to device entry */
1325 
1326  /* is there a pdo yet */
1327  if (DeviceEntry->PDO && (DeviceEntry->DeviceState == NotStarted || DeviceEntry->DeviceState == Started))
1328  {
1329  /* increment count */
1330  Count++;
1331  }
1332 
1333  /* move to next entry */
1334  Entry = Entry->Flink;
1335  }
1336 
1337  /* calculate length */
1338  Length = sizeof(DEVICE_RELATIONS) + (Count > 1 ? sizeof(PDEVICE_OBJECT) * (Count-1) : 0);
1339 
1340  /* allocate device relations */
1341  DeviceRelations = (PDEVICE_RELATIONS)AllocateItem(NonPagedPool, Length);
1342 
1343  if (!DeviceRelations)
1344  {
1345  /* not enough memory */
1346  KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1348  }
1349 
1350  /* rescan device entries */
1351  Entry = BusDeviceExtension->Common.Entry.Flink;
1352 
1353  while(Entry != &BusDeviceExtension->Common.Entry)
1354  {
1355  /* get offset to device entry */
1357 
1358  /* is there a pdo yet */
1359  if (DeviceEntry->PDO && (DeviceEntry->DeviceState == NotStarted || DeviceEntry->DeviceState == Started))
1360  {
1361  /* store pdo */
1362  DeviceRelations->Objects[DeviceRelations->Count] = DeviceEntry->PDO;
1363 
1364  /* reference device object */
1365  ObReferenceObject(DeviceEntry->PDO);
1366 
1367  /* increment pdo count */
1368  DeviceRelations->Count++;
1369  }
1370 
1371  /* move to next entry */
1372  Entry = Entry->Flink;
1373  }
1374 
1375  /* release lock */
1376  KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1377 
1378  /* FIXME handle existing device relations */
1379  ASSERT(Irp->IoStatus.Information == 0);
1380 
1381  /* store device relations */
1382  Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
1383 
1384  /* done */
1385  return STATUS_SUCCESS;
1386 }
1387 
1388 //------------------------------------------------------------------------------------
1389 
1390 /*
1391  @implemented
1392 */
1393 
1394 KSDDKAPI
1395 NTSTATUS
1396 NTAPI
1398  IN PIRP Irp)
1399 {
1400  PDEV_EXTENSION DeviceExtension;
1401  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1402  PIO_STACK_LOCATION IoStack;
1403  SIZE_T Length;
1404  NTSTATUS Status;
1405  LPWSTR Buffer;
1406 
1407  DPRINT("KsGetBusEnumIdentifier\n");
1408 
1409  /* get stack location */
1410  IoStack = IoGetCurrentIrpStackLocation(Irp);
1411 
1412  /* sanity checks */
1413  ASSERT(IoStack->DeviceObject);
1414  ASSERT(IoStack->DeviceObject->DeviceExtension);
1415 
1416  /* get device extension */
1417  DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
1418 
1419  /* get bus device extension */
1420  BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1421 
1422  /* sanity checks */
1423  ASSERT(BusDeviceExtension);
1424  ASSERT(BusDeviceExtension->Common.IsBus);
1425 
1426  if (!BusDeviceExtension)
1427  {
1428  /* invalid parameter */
1429  return STATUS_INVALID_PARAMETER;
1430  }
1431 
1432  /* get length */
1433  Length = (wcslen(BusDeviceExtension->BusIdentifier)+1) * sizeof(WCHAR);
1434 
1435  /* is there an output buffer provided */
1436  if (IoStack->Parameters.DeviceIoControl.InputBufferLength)
1437  {
1438  if (Length > IoStack->Parameters.DeviceIoControl.InputBufferLength)
1439  {
1440  /* buffer is too small */
1441  return STATUS_BUFFER_TOO_SMALL;
1442  }
1443 
1444  /* now allocate buffer */
1446  if (!Buffer)
1447  {
1448  /* no memory */
1450  }
1451  else
1452  {
1453  /* copy bus identifier */
1454  wcscpy(Buffer, BusDeviceExtension->BusIdentifier);
1455 
1456  /* store buffer */
1457  Irp->AssociatedIrp.SystemBuffer = Buffer;
1458 
1459  /* set flag that buffer gets copied back */
1461 
1462  /* done */
1464  }
1465  }
1466  else
1467  {
1468  /* no buffer provided */
1470  }
1471 
1472  /* done */
1473  Irp->IoStatus.Status = Status;
1474  return Status;
1475 }
1476 
1477 /*
1478  @implemented
1479 */
1480 KSDDKAPI
1481 NTSTATUS
1482 NTAPI
1486 {
1487  PDEV_EXTENSION DeviceExtension;
1488 
1489  DPRINT("KsGetBusEnumParentFDOFromChildPDO\n");
1490 
1491  /* get device extension */
1492  DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1493 
1494  /* check if this is child pdo */
1495  if (DeviceExtension->Ext->IsBus == FALSE)
1496  {
1497  /* return bus device object */
1498  *FunctionalDeviceObject = DeviceExtension->Ext->BusDeviceExtension->BusDeviceObject;
1499 
1500  /* done */
1501  return STATUS_SUCCESS;
1502  }
1503 
1504  /* invalid parameter */
1505  return STATUS_INVALID_PARAMETER;
1506 }
1507 
1508 
1509 /*
1510  @implemented
1511 */
1512 KSDDKAPI
1513 NTSTATUS
1514 NTAPI
1516  IN PWCHAR BusIdentifier,
1517  IN PDEVICE_OBJECT BusDeviceObject,
1519  IN PDEVICE_OBJECT PnpDeviceObject OPTIONAL,
1521  IN PWCHAR ServiceRelativePath OPTIONAL)
1522 {
1523  SIZE_T Length;
1525  UNICODE_STRING ServiceKeyPath = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Services\\");
1526  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1527  PDEV_EXTENSION DeviceExtension;
1528  PBUS_DEVICE_ENTRY DeviceEntry;
1530  KIRQL OldLevel;
1531 
1532  DPRINT1("KsCreateBusEnumObject %S BusDeviceObject %p\n", ServiceRelativePath, BusDeviceObject);
1533 
1534  /* calculate sizeof bus enum device extension */
1535  Length = wcslen(BusIdentifier) * sizeof(WCHAR);
1536  Length += sizeof(BUS_ENUM_DEVICE_EXTENSION);
1537 
1538  BusDeviceExtension = AllocateItem(NonPagedPool, Length);
1539  if (!BusDeviceExtension)
1540  {
1541  /* not enough memory */
1542 
1544  }
1545 
1546  /* get device extension */
1547  DeviceExtension = (PDEV_EXTENSION)BusDeviceObject->DeviceExtension;
1548 
1549  /* store bus device extension */
1550  DeviceExtension->Ext = (PCOMMON_DEVICE_EXTENSION)BusDeviceExtension;
1551 
1552  DPRINT("DeviceExtension %p BusDeviceExtension %p\n", DeviceExtension, DeviceExtension->Ext);
1553 
1554 
1555  /* zero device extension */
1556  RtlZeroMemory(BusDeviceExtension, sizeof(BUS_ENUM_DEVICE_EXTENSION));
1557 
1558  /* initialize bus device extension */
1559  wcscpy(BusDeviceExtension->BusIdentifier, BusIdentifier);
1560 
1561  /* allocate service path string */
1562  Length = ServiceKeyPath.MaximumLength;
1563  Length += BusDeviceObject->DriverObject->DriverExtension->ServiceKeyName.MaximumLength;
1564 
1565  if (ServiceRelativePath)
1566  {
1567  /* relative path for devices */
1568  Length += (wcslen(ServiceRelativePath) + 2) * sizeof(WCHAR);
1569  }
1570 
1571  BusDeviceExtension->ServicePath.Length = 0;
1572  BusDeviceExtension->ServicePath.MaximumLength = (USHORT)Length;
1573  BusDeviceExtension->ServicePath.Buffer = AllocateItem(NonPagedPool, Length);
1574 
1575  if (!BusDeviceExtension->ServicePath.Buffer)
1576  {
1577  /* not enough memory */
1578  FreeItem(BusDeviceExtension);
1579 
1581  }
1582 
1583  RtlAppendUnicodeStringToString(&BusDeviceExtension->ServicePath, &ServiceKeyPath);
1584  RtlAppendUnicodeStringToString(&BusDeviceExtension->ServicePath, &BusDeviceObject->DriverObject->DriverExtension->ServiceKeyName);
1585 
1586  if (ServiceRelativePath)
1587  {
1588  RtlAppendUnicodeToString(&BusDeviceExtension->ServicePath, L"\\");
1589  RtlAppendUnicodeToString(&BusDeviceExtension->ServicePath, ServiceRelativePath);
1590  }
1591 
1592  if (InterfaceGuid)
1593  {
1594  /* register an device interface */
1596 
1597  /* check for success */
1598  if (!NT_SUCCESS(Status))
1599  {
1600  DPRINT1("IoRegisterDeviceInterface failed Status %lx\n", Status);
1601  FreeItem(BusDeviceExtension->ServicePath.Buffer);
1602  FreeItem(BusDeviceExtension);
1603  return Status;
1604  }
1605 
1606  /* now enable device interface */
1607  Status = IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, TRUE);
1608 
1609  if (!NT_SUCCESS(Status))
1610  {
1611  DPRINT1("IoSetDeviceInterfaceState failed Status %lx\n", Status);
1612  FreeItem(BusDeviceExtension->ServicePath.Buffer);
1613  FreeItem(BusDeviceExtension);
1614  return Status;
1615  }
1616  }
1617 
1618  /* initialize common device extension */
1619  BusDeviceExtension->Common.BusDeviceExtension = NULL;
1620  BusDeviceExtension->Common.DeviceObjectReferenceCount = 1;
1621  BusDeviceExtension->Common.DeviceReferenceCount = 1;
1622  BusDeviceExtension->Common.IsBus = TRUE;
1623  InitializeListHead(&BusDeviceExtension->Common.Entry);
1624 
1625  /* store device objects */
1626  BusDeviceExtension->BusDeviceObject = BusDeviceObject;
1627  BusDeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
1628 
1629  /* initialize lock */
1630  KeInitializeSpinLock(&BusDeviceExtension->Lock);
1631 
1632  /* initialize timer */
1633  KeInitializeTimer(&BusDeviceExtension->Timer);
1634 
1635  /* initialize dpc */
1636  KeInitializeDpc(&BusDeviceExtension->Dpc, KspBusDpcRoutine, (PVOID)BusDeviceExtension);
1637 
1638  /* initialize event */
1639  KeInitializeEvent(&BusDeviceExtension->Event, SynchronizationEvent, FALSE);
1640 
1641  /* initialize work item */
1642  ExInitializeWorkItem(&BusDeviceExtension->WorkItem, KspBusWorkerRoutine, (PVOID)BusDeviceExtension);
1643 
1644  if (!PnpDeviceObject)
1645  {
1646  /* attach device */
1647  BusDeviceExtension->PnpDeviceObject = IoAttachDeviceToDeviceStack(BusDeviceObject, PhysicalDeviceObject);
1648 
1649  if (!BusDeviceExtension->PnpDeviceObject)
1650  {
1651  /* failed to attach device */
1652  DPRINT1("IoAttachDeviceToDeviceStack failed with %x\n", Status);
1653  if (BusDeviceExtension->DeviceInterfaceLink.Buffer)
1654  {
1655  IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, FALSE);
1656  RtlFreeUnicodeString(&BusDeviceExtension->DeviceInterfaceLink);
1657  }
1658 
1659  /* free device extension */
1660  FreeItem(BusDeviceExtension->ServicePath.Buffer);
1661  FreeItem(BusDeviceExtension);
1662 
1663  return STATUS_DEVICE_REMOVED;
1664  }
1665 
1666  /* mark device as attached */
1667  BusDeviceExtension->DeviceAttached = TRUE;
1668  }
1669  else
1670  {
1671  /* directly attach */
1672  BusDeviceExtension->PnpDeviceObject = PnpDeviceObject;
1673  }
1674 
1675  /* now scan the bus */
1676  Status = KspScanBus(BusDeviceExtension);
1677 
1678  /* check for success */
1679  if (!NT_SUCCESS(Status))
1680  {
1681  /* failed to scan bus */
1682  if (BusDeviceExtension->DeviceInterfaceLink.Buffer)
1683  {
1684  IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, FALSE);
1685  RtlFreeUnicodeString(&BusDeviceExtension->DeviceInterfaceLink);
1686  }
1687 
1688  if (BusDeviceExtension->DeviceAttached)
1689  {
1690  /* detach device */
1691  IoDetachDevice(BusDeviceExtension->PnpDeviceObject);
1692  }
1693 
1694  /* free device extension */
1695  FreeItem(BusDeviceExtension->ServicePath.Buffer);
1696  FreeItem(BusDeviceExtension);
1697 
1698  return Status;
1699  }
1700 
1701  /* acquire device entry lock */
1702  KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1703 
1704  /* now iterate all device entries */
1705  Entry = BusDeviceExtension->Common.Entry.Flink;
1706  while(Entry != &BusDeviceExtension->Common.Entry)
1707  {
1708  /* get device entry */
1710  if (!DeviceEntry->PDO)
1711  {
1712  /* release device entry lock */
1713  KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1714 
1715  /* create pdo */
1716  Status = KspCreatePDO(BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
1717 
1718  /* acquire device entry lock */
1719  KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1720 
1721  /* done */
1722  break;
1723  }
1724  /* move to next entry */
1725  Entry = Entry->Flink;
1726  }
1727 
1728  /* release device entry lock */
1729  KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1730 
1731 
1732  /* invalidate device relations */
1733  IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
1734  DPRINT("KsCreateBusEnumObject Status %x\n", Status);
1735  /* done */
1736  return Status;
1737 }
1738 
1739 /*
1740  @implemented
1741 */
1742 KSDDKAPI
1743 NTSTATUS
1744 NTAPI
1747  IN PDEVICE_OBJECT *PnpDeviceObject)
1748 {
1749  PDEV_EXTENSION DeviceExtension;
1750  PCOMMON_DEVICE_EXTENSION CommonDeviceExtension;
1751  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1752 
1753  DPRINT("KsGetBusEnumPnpDeviceObject\n");
1754 
1756  {
1757  /* invalid parameter */
1758  return STATUS_INVALID_PARAMETER;
1759  }
1760 
1761  /* get device extension */
1762  DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1763 
1764  /* get common device extension */
1765  CommonDeviceExtension = DeviceExtension->Ext;
1766 
1767  if (!CommonDeviceExtension)
1768  {
1769  /* invalid parameter */
1770  return STATUS_INVALID_PARAMETER;
1771  }
1772 
1773  if (!CommonDeviceExtension->IsBus)
1774  {
1775  /* getting pnp device object is only supported for software bus device object */
1776  return STATUS_INVALID_PARAMETER;
1777  }
1778 
1779  /* sanity checks */
1780  ASSERT(CommonDeviceExtension);
1781  ASSERT(CommonDeviceExtension->IsBus);
1782 
1783  /* cast to bus device extension */
1784  BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)CommonDeviceExtension;
1785 
1786  /* store result */
1787  *PnpDeviceObject = BusDeviceExtension->PnpDeviceObject;
1788 
1789  /* done */
1790  return STATUS_SUCCESS;
1791 }
1792 
1793 /*
1794  @implemented
1795 */
1796 KSDDKAPI
1797 NTSTATUS
1798 NTAPI
1800  PIRP Irp)
1801 {
1804  LUID luid;
1805  PIO_STACK_LOCATION IoStack;
1806  PDEV_EXTENSION DeviceExtension;
1807  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1808 
1809  DPRINT("KsInstallBusEnumInterface\n");
1810 
1811  /* get current irp stack location */
1812  IoStack = IoGetCurrentIrpStackLocation(Irp);
1813 
1814  /* get previous mode */
1815  Mode = ExGetPreviousMode();
1816 
1817  /* convert to luid */
1819 
1820  /* perform access check */
1821  if (!SeSinglePrivilegeCheck(luid, Mode))
1822  {
1823  /* FIXME insufficient privileges */
1824  //return STATUS_PRIVILEGE_NOT_HELD;
1825  }
1826 
1827  /* get device extension */
1828  DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
1829 
1830  /* get bus device extension */
1831  BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1832 
1833 
1834  /* initialize context */
1835  Context.Irp = Irp;
1837  Context.BusDeviceExtension = BusDeviceExtension;
1839 
1840  /* queue the work item */
1842  /* wait for completion */
1844 
1845  /* store result */
1846  Irp->IoStatus.Status = Context.Status;
1847 
1848  /* done */
1849  return Context.Status;
1850 }
1851 
1852 /*
1853  @implemented
1854 */
1855 KSDDKAPI
1856 NTSTATUS
1857 NTAPI
1860  OUT PBOOLEAN ChildDevice)
1861 {
1862  PDEV_EXTENSION DeviceExtension;
1863  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1864 
1865  DPRINT("KsIsBusEnumChildDevice %p\n", DeviceObject);
1866 
1867  /* get device extension */
1868  DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1869 
1870  /* get bus device extension */
1871  BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1872 
1873  if (!BusDeviceExtension)
1874  {
1875  /* not a bus device */
1876  return STATUS_INVALID_PARAMETER;
1877  }
1878 
1879  /* store result */
1880  *ChildDevice = (BusDeviceExtension->Common.IsBus == FALSE);
1881 
1882  return STATUS_SUCCESS;
1883 }
1884 
1885 /*
1886  @implemented
1887 */
1888 KSDDKAPI
1889 NTSTATUS
1890 NTAPI
1893  IN OUT PIRP Irp)
1894 {
1896  PBUS_DEVICE_ENTRY DeviceEntry = NULL; /* fix gcc */
1897  PIO_STACK_LOCATION IoStack;
1898  BOOLEAN ItemExists = FALSE;
1899  PDEV_EXTENSION DeviceExtension;
1900  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1901  //PCOMMON_DEVICE_EXTENSION ChildDeviceExtension;
1902  NTSTATUS Status;
1904 
1905  /* FIXME: locks */
1906 
1907  /* get device extension */
1908  DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1909 
1910  /* get bus device extension */
1911  BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1912 
1913  /* get current irp stack location */
1914  IoStack = IoGetCurrentIrpStackLocation(Irp);
1915 
1916  /* sanity checks */
1917  ASSERT(IoStack->FileObject);
1918  if (IoStack->FileObject->FileName.Buffer == NULL)
1919  {
1920  DPRINT("KsServiceBusEnumCreateRequest PNP Hack\n");
1921  Irp->IoStatus.Status = STATUS_SUCCESS;
1922  return STATUS_SUCCESS;
1923  }
1924 
1925  ASSERT(IoStack->FileObject->FileName.Buffer);
1926 
1927  DPRINT1("KsServiceBusEnumCreateRequest IRP %p Name %wZ\n", Irp, &IoStack->FileObject->FileName);
1928 
1929  /* scan list and check if it is already present */
1930  Entry = BusDeviceExtension->Common.Entry.Flink;
1931 
1932  while(Entry != &BusDeviceExtension->Common.Entry)
1933  {
1934  /* get real offset */
1936 
1937  /* check if name matches */
1938  if (!wcsicmp(DeviceEntry->DeviceName, IoStack->FileObject->FileName.Buffer + 1))
1939  {
1940  /* item already exists */
1941  ItemExists = TRUE;
1942  break;
1943  }
1944 
1945  /* move to next entry */
1946  Entry = Entry->Flink;
1947  }
1948 
1949  if (!ItemExists)
1950  {
1951  /* interface not registered */
1952  DPRINT1("Interface %wZ not registered\n", &IoStack->FileObject->FileName);
1954  }
1955 
1956  /* is there a pdo yet */
1957  if (DeviceEntry->PDO)
1958  {
1959  if (DeviceEntry->DeviceState == Started)
1960  {
1961  /* issue reparse */
1962  Status = KspDoReparseForIrp(Irp, DeviceEntry);
1963  DPRINT("REPARSE Irp %p '%wZ'\n", Irp, &IoStack->FileObject->FileName);
1964 
1965  Irp->IoStatus.Status = Status;
1966  Irp->IoStatus.Information = IO_REPARSE;
1967  return Status;
1968  }
1969 
1970  /* delay processing until pnp is finished with enumeration */
1972 
1973  /* insert into irp pending list */
1974  InsertTailList(&DeviceEntry->IrpPendingList, &Irp->Tail.Overlay.ListEntry);
1975 
1976  Time.QuadPart = Int32x32To64(1500, -10000);
1977  DbgPrint("PENDING Irp %p %wZ DeviceState %d\n", Irp, &IoStack->FileObject->FileName, DeviceEntry->DeviceState);
1978 
1979 
1980  /* set timer */
1981  KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
1982 
1983  /* done for now */
1984  return STATUS_PENDING;
1985 
1986  }
1987  else
1988  {
1989  /* time to create PDO */
1990  Status = KspCreatePDO(BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
1991 
1992  if (!NT_SUCCESS(Status))
1993  {
1994  /* failed to create PDO */
1995  DPRINT1("KsServiceBusEnumCreateRequest failed to create PDO with %x\n", Status);
1996  return Status;
1997  }
1998  DPRINT("PENDING CREATE Irp %p %wZ\n", Irp, &IoStack->FileObject->FileName);
1999 
2000  /* delay processing until pnp is finished with enumeration */
2002 
2003  /* insert into irp pending list */
2004  InsertTailList(&DeviceEntry->IrpPendingList, &Irp->Tail.Overlay.ListEntry);
2005 
2006  /* invalidate device relations */
2008 
2009  /* done for now */
2010  return STATUS_PENDING;
2011  }
2012 }
2013 
2014 /*
2015  @implemented
2016 */
2017 KSDDKAPI
2018 NTSTATUS
2019 NTAPI
2022  IN OUT PIRP Irp)
2023 {
2024  PDEV_EXTENSION DeviceExtension;
2025  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
2026  PCOMMON_DEVICE_EXTENSION ChildDeviceExtension;
2027  PIO_STACK_LOCATION IoStack;
2028  NTSTATUS Status;
2030  PDEVICE_RELATIONS DeviceRelation;
2031  PBUS_DEVICE_ENTRY DeviceEntry;
2032 
2033  /* get device extension */
2034  DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
2035 
2036  /* get bus device extension */
2037  BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
2038 
2039  /* get current irp stack location */
2040  IoStack = IoGetCurrentIrpStackLocation(Irp);
2041 
2042  if (BusDeviceExtension->Common.IsBus)
2043  {
2044  if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
2045  {
2046  /* no op for bus driver */
2048  }
2049  else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS)
2050  {
2051  /* handle bus device relations */
2052  ASSERT(IoStack->Parameters.QueryDeviceRelations.Type == BusRelations);
2053 
2054  Status = KspQueryBusRelations(BusDeviceExtension, Irp);
2055  }
2056  else
2057  {
2058  /* get default status */
2059  Status = Irp->IoStatus.Status;
2060  }
2061  }
2062  else
2063  {
2064  /* get child device extension */
2065  ChildDeviceExtension = DeviceExtension->Ext;
2066 
2067  /* get bus device extension */
2068  BusDeviceExtension = ChildDeviceExtension->BusDeviceExtension;
2069 
2070  if (IoStack->MinorFunction == IRP_MN_QUERY_ID)
2071  {
2072  /* query id */
2073  Status = KspQueryId(ChildDeviceExtension, Irp);
2074  }
2075  else if (IoStack->MinorFunction == IRP_MN_REMOVE_DEVICE)
2076  {
2077  ASSERT(ChildDeviceExtension->DeviceEntry->DeviceState != Started || ChildDeviceExtension->DeviceEntry->DeviceState == NotStarted);
2078  ASSERT(ChildDeviceExtension->DeviceEntry->PDO == DeviceObject);
2079 
2080  /* backup device entry */
2081  DeviceEntry = ChildDeviceExtension->DeviceEntry;
2082 
2083  /* free device extension */
2084  FreeItem(ChildDeviceExtension);
2085 
2086  /* clear PDO reference */
2087  DeviceEntry->PDO = NULL;
2088 
2089  /* delete the device */
2091 
2092  if (DeviceEntry->PDODeviceName)
2093  {
2094  /* delete pdo device name */
2095  FreeItem(DeviceEntry->PDODeviceName);
2096 
2097  /* set to null */
2098  DeviceEntry->PDODeviceName = NULL;
2099  }
2100 
2101  /* set state no notstarted */
2102  DeviceEntry->DeviceState = NotStarted;
2103 
2104  /* complete pending irps */
2106 
2107  /* done */
2109  }
2110  else if (IoStack->MinorFunction == IRP_MN_QUERY_BUS_INFORMATION)
2111  {
2112  /* query bus information */
2113  Status = KspQueryBusInformation(ChildDeviceExtension, Irp);
2114  }
2115  else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCES)
2116  {
2117  /* no op */
2119  }
2121  {
2122  /* no op */
2124  }
2125  else if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
2126  {
2127  /* start bus */
2128  Status = KspStartBusDevice(DeviceObject, ChildDeviceExtension, Irp);
2129  if (NT_SUCCESS(Status))
2130  {
2131  /* complete pending irps*/
2132  KspCompletePendingIrps(ChildDeviceExtension->DeviceEntry, STATUS_REPARSE);
2133  }
2134 
2135  /* set time out */
2136  Time.QuadPart = Int32x32To64(1500, -10000);
2137 
2138  /* sanity check */
2139  ASSERT(BusDeviceExtension);
2140 
2141  /* set timer */
2142  KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
2143  }
2144  else if (IoStack->MinorFunction == IRP_MN_QUERY_CAPABILITIES)
2145  {
2146  /* query capabilities */
2147  Status = KspQueryBusDeviceCapabilities(ChildDeviceExtension, Irp);
2148  }
2149  else if (IoStack->MinorFunction == IRP_MN_QUERY_PNP_DEVICE_STATE)
2150  {
2151  /* query pnp state */
2152  Status = KspQueryBusDevicePnpState(ChildDeviceExtension, Irp);
2153  }
2154  else if (IoStack->MinorFunction == IRP_MN_QUERY_INTERFACE)
2155  {
2156  /* query interface */
2157  Status = KspQueryBusDeviceInterface(ChildDeviceExtension, Irp);
2158  }
2159  else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS && IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
2160  {
2161  /* handle target device relations */
2162  ASSERT(IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation);
2163  ASSERT(Irp->IoStatus.Information == 0);
2164 
2165  /* allocate device relation */
2166  DeviceRelation = AllocateItem(PagedPool, sizeof(DEVICE_RELATIONS));
2167  if (DeviceRelation)
2168  {
2169  DeviceRelation->Count = 1;
2170  DeviceRelation->Objects[0] = DeviceObject;
2171 
2172  /* reference self */
2174 
2175  /* store result */
2176  Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
2177 
2178  /* done */
2180  }
2181  else
2182  {
2183  /* no memory */
2185  }
2186  }
2187  else
2188  {
2189  /* get default status */
2190  Status = Irp->IoStatus.Status;
2191  }
2192  }
2193 
2194  DPRINT("KsServiceBusEnumPnpRequest %p Bus %u Function %x Status %x\n", DeviceObject, BusDeviceExtension->Common.IsBus, IoStack->MinorFunction, Status);
2195  Irp->IoStatus.Status = Status;
2196  return Status;
2197 }
2198 
2199 /*
2200  @implemented
2201 */
2202 KSDDKAPI
2203 NTSTATUS
2204 NTAPI
2206  IN PIRP Irp)
2207 {
2209  LUID luid;
2211  PDEV_EXTENSION DeviceExtension;
2212  PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
2213  PIO_STACK_LOCATION IoStack;
2214 
2215  DPRINT("KsRemoveBusEnumInterface\n");
2216 
2217  /* get io stack location */
2218  IoStack = IoGetCurrentIrpStackLocation(Irp);
2219 
2220  /* get device extension */
2221  DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
2222 
2223  /* get bus device extension */
2224  BusDeviceExtension = DeviceExtension->Ext->BusDeviceExtension;
2225 
2226  /* get previous mode */
2227  Mode = ExGetPreviousMode();
2228 
2229  /* convert to luid */
2231 
2232  /* perform access check */
2233  if (!SeSinglePrivilegeCheck(luid, Mode))
2234  {
2235  /* insufficient privileges */
2237  }
2238 
2239  /* initialize context */
2241  Ctx.Irp = Irp;
2242  Ctx.BusDeviceExtension = BusDeviceExtension;
2244 
2245  /* now queue the work item */
2246  ExQueueWorkItem(&Ctx.WorkItem, DelayedWorkQueue);
2247 
2248  /* wait for completion */
2250 
2251  /* return result */
2252  return Ctx.Status;
2253 }
LIST_ENTRY Entry
Definition: kstypes.h:193
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
IN CINT OUT PVOID IN ULONG OUT PULONG ResultLength
Definition: conport.c:47
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
NTSTRSAFEAPI RtlStringCbCopyW(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PWSTR pszDest, _In_ size_t cbDest, _In_ NTSTRSAFE_PCWSTR pszSrc)
Definition: ntstrsafe.h:174
#define DO_POWER_PAGABLE
NTSTATUS KspQueryBusDeviceInterface(IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
Definition: swenum.c:608
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
#define IN
Definition: typedefs.h:38
#define STATUS_PRIVILEGE_NOT_HELD
Definition: DriverTester.h:9
#define STATUS_DEVICE_REMOVED
Definition: ntstatus.h:795
KSDDKAPI NTSTATUS NTAPI KsRemoveBusEnumInterface(IN PIRP Irp)
Definition: swenum.c:2205
#define TRUE
Definition: types.h:120
LIST_ENTRY Entry
Definition: kstypes.h:172
#define IRP_MN_QUERY_RESOURCES
VOID NTAPI ExQueueWorkItem(IN PWORK_QUEUE_ITEM WorkItem, IN WORK_QUEUE_TYPE QueueType)
Definition: work.c:717
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:281
#define IRP_MN_REMOVE_DEVICE
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define IRP_MN_QUERY_ID
GUID DeviceGuid
Definition: kstypes.h:198
struct _Entry Entry
Definition: kefuncs.h:640
NTSTATUS NTAPI KspBusQueryReferenceString(IN PVOID Context, IN OUT PWCHAR *String)
Definition: swenum.c:529
NTSTATUS KspOpenBusRegistryKey(IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, OUT PHANDLE hKey)
Definition: swenum.c:482
Definition: scsiwmi.h:51
_In_ ULONG Mode
Definition: hubbusif.h:303
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define DbgPrint
Definition: loader.c:25
USHORT MaximumLength
Definition: env_spec_w32.h:370
WORK_QUEUE_ITEM WorkItem
Definition: kstypes.h:219
struct __BUS_ENUM_DEVICE_EXTENSION__ * BusDeviceExtension
Definition: kstypes.h:161
_In_ PIRP Irp
Definition: csq.h:116
NTSTATUS KspEnableBusDeviceInterface(PBUS_DEVICE_ENTRY DeviceEntry, BOOLEAN bEnable)
Definition: swenum.c:637
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
struct __BUS_ENUM_DEVICE_EXTENSION__ BUS_ENUM_DEVICE_EXTENSION
#define IRP_MN_QUERY_RESOURCE_REQUIREMENTS
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2055
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: misc.c:30
WORK_QUEUE_ITEM WorkItem
Definition: kstypes.h:232
LONG NTSTATUS
Definition: precomp.h:26
#define SE_LOAD_DRIVER_PRIVILEGE
Definition: security.c:664
VOID NTAPI KspInstallBusEnumInterface(IN PVOID Ctx)
Definition: swenum.c:1077
LPWSTR PDODeviceName
Definition: kstypes.h:199
struct _KEY_BASIC_INFORMATION KEY_BASIC_INFORMATION
NTSTATUS KspQueryId(IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
Definition: swenum.c:891
LPWSTR DeviceName
Definition: kstypes.h:200
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
NTSTATUS KspQueryBusDevicePnpState(IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
Definition: swenum.c:879
VOID NTAPI IoDetachDevice(IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:1296
BOOLEAN NTAPI SeSinglePrivilegeCheck(IN LUID PrivilegeValue, IN KPROCESSOR_MODE PreviousMode)
Definition: priv.c:524
KPROCESSOR_MODE NTAPI ExGetPreviousMode(VOID)
Definition: sysinfo.c:3066
NTSTATUS KspRegisterDeviceAssociation(IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DeviceEntry, IN OUT PBUS_INSTANCE_ENTRY BusInstanceEntry)
Definition: swenum.c:93
DEVICE_CAPABILITIES
Definition: iotypes.h:928
LONG KsDeviceCount
Definition: swenum.c:17
static WCHAR String[]
Definition: stringtable.c:55
IRP
Definition: iotypes.h:2463
uint16_t * PWCHAR
Definition: typedefs.h:54
#define NT_VERIFY(exp)
Definition: rtlfuncs.h:3289
PDEVICE_OBJECT PhysicalDeviceObject
Definition: btrfs_drv.h:1122
WCHAR DeviceName[]
Definition: adapter.cpp:21
_In_ PVOID Parameter
Definition: ldrtypes.h:241
#define InsertTailList(ListHead, Entry)
NTSTATUS KspInstallInterface(IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PSWENUM_INSTALL_INTERFACE InstallInterface)
Definition: swenum.c:985
NTSTATUS KspQueryBusRelations(IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PIRP Irp)
Definition: swenum.c:1305
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
#define KSDDKAPI
Definition: ks.h:40
_Must_inspect_result_ FORCEINLINE BOOLEAN IsListEmpty(_In_ const LIST_ENTRY *ListHead)
Definition: rtlfuncs.h:57
#define PNP_DEVICE_DONT_DISPLAY_IN_UI
Definition: iotypes.h:965
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
struct BUS_INSTALL_ENUM_CONTEXT * PBUS_INSTALL_ENUM_CONTEXT
VOID NTAPI KspRemoveBusInterface(PVOID Ctx)
Definition: swenum.c:1284
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
UNICODE_STRING DeviceInterfaceLink
Definition: kstypes.h:212
#define IsEqualGUIDAligned(guid1, guid2)
Definition: wdm.template.h:233
NTSTATUS NTAPI KspCreateDeviceReference(IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DummyEntry, IN LPWSTR InterfaceId, IN LPWSTR DeviceId)
Definition: swenum.c:330
#define STATUS_INVALID_DEVICE_STATE
Definition: udferr_usr.h:178
FORCEINLINE BOOLEAN RemoveEntryList(_In_ PLIST_ENTRY Entry)
Definition: rtlfuncs.h:105
VOID KspRemoveDeviceAssociations(IN PBUS_DEVICE_ENTRY DeviceEntry)
Definition: swenum.c:133
UCHAR KIRQL
Definition: env_spec_w32.h:591
KSDDKAPI NTSTATUS NTAPI KsServiceBusEnumCreateRequest(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
Definition: swenum.c:1891
VOID FreeItem(IN PVOID Item)
Definition: misc.c:43
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
NTSTATUS NTAPI KspCreateDeviceReferenceTrampoline(IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DummyEntry, IN LPWSTR DeviceCategory, IN LPWSTR ReferenceString)
Definition: swenum.c:470
#define UNICODE_NULL
ULONG DeviceObjectReferenceCount
Definition: kstypes.h:162
_Must_inspect_result_ typedef _Out_ PHIDP_CAPS Capabilities
Definition: hidclass.h:103
NTSTATUS NTAPI KspCreateDeviceAssociation(IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DeviceEntry, IN LPWSTR InterfaceString, IN LPWSTR ReferenceString)
Definition: swenum.c:258
long LONG
Definition: pedump.c:60
LARGE_INTEGER TimeCreated
Definition: kstypes.h:202
Entry(ENTRY_TYPE etype)
Definition: entries.cpp:35
#define GENERIC_WRITE
Definition: nt_native.h:90
PDEVICE_OBJECT NTAPI IoAttachDeviceToDeviceStack(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:966
_In_ CONST GUID _In_opt_ PUNICODE_STRING ReferenceString
Definition: iofuncs.h:1134
struct _SWENUM_INSTALL_INTERFACE * PSWENUM_INSTALL_INTERFACE
struct NameRec_ * Name
Definition: cdprocs.h:464
struct _KEY_BASIC_INFORMATION * PKEY_BASIC_INFORMATION
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
struct _DEVICE_RELATIONS * PDEVICE_RELATIONS
PVOID DeviceExtension
Definition: env_spec_w32.h:418
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
struct _PNP_BUS_INFORMATION * PPNP_BUS_INFORMATION
VOID NTAPI KeInitializeTimer(OUT PKTIMER Timer)
Definition: timerobj.c:233
FORCEINLINE PLIST_ENTRY RemoveHeadList(_Inout_ PLIST_ENTRY ListHead)
Definition: rtlfuncs.h:128
NTSTATUS NTAPI IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_REGISTRY_PROPERTY DeviceProperty, IN ULONG BufferLength, OUT PVOID PropertyBuffer, OUT PULONG ResultLength)
Definition: pnpmgr.c:4228
void DPRINT(...)
Definition: polytest.cpp:61
Definition: bufpool.h:45
PDEVICE_OBJECT PhysicalDeviceObject
Definition: kstypes.h:213
NTSTATUS NTAPI IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName, IN BOOLEAN Enable)
Definition: deviface.c:1311
struct __BUS_ENUM_DEVICE_EXTENSION__ * PBUS_ENUM_DEVICE_EXTENSION
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
PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension
Definition: kstypes.h:229
NTSTATUS KspDoReparseForIrp(PIRP Irp, PBUS_DEVICE_ENTRY DeviceEntry)
Definition: swenum.c:672
KSDDKAPI NTSTATUS NTAPI KsGetBusEnumIdentifier(IN PIRP Irp)
Definition: swenum.c:1397
_In_opt_ PVOID _In_opt_ PVOID SystemArgument1
Definition: ketypes.h:675
NTSTATUS RtlAppendUnicodeToString(IN PUNICODE_STRING Str1, IN PWSTR Str2)
Definition: string_lib.cpp:62
struct _LIST_ENTRY * Flink
Definition: typedefs.h:119
PDEVICE_OBJECT DeviceObject
Definition: pci.h:42
IN PVOID IN PVOID IN USHORT IN USHORT IN PINTERFACE Interface
Definition: pci.h:359
NTSTATUS KspQueryBusInformation(IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
Definition: swenum.c:851
_In_ LARGE_INTEGER _In_opt_ PKDPC Dpc
Definition: kefuncs.h:524
#define ExInitializeWorkItem(Item, Routine, Context)
Definition: exfuncs.h:265
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
FORCEINLINE LUID NTAPI_INLINE RtlConvertUlongToLuid(_In_ ULONG Val)
Definition: rtlfuncs.h:3543
UNICODE_STRING ServicePath
Definition: kstypes.h:221
NTSTATUS KspScanBus(IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension)
Definition: swenum.c:495
#define IO_REPARSE
Definition: iotypes.h:511
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
#define swprintf(buf, format,...)
Definition: sprintf.c:56
#define IRP_MN_START_DEVICE
KSDDKAPI NTSTATUS NTAPI KsCreateBusEnumObject(IN PWCHAR BusIdentifier, IN PDEVICE_OBJECT BusDeviceObject, IN PDEVICE_OBJECT PhysicalDeviceObject, IN PDEVICE_OBJECT PnpDeviceObject OPTIONAL, IN REFGUID InterfaceGuid OPTIONAL, IN PWCHAR ServiceRelativePath OPTIONAL)
Definition: swenum.c:1515
struct __BUS_DEVICE_ENTRY__ * PBUS_DEVICE_ENTRY
struct _COMMON_DEVICE_EXTENSION * PCOMMON_DEVICE_EXTENSION
static const UCHAR Index[8]
Definition: usbohci.c:18
#define PNP_DEVICE_NOT_DISABLEABLE
Definition: iotypes.h:969
NTSTATUS KspCreatePDO(IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DeviceEntry, OUT PDEVICE_OBJECT *OutDeviceObject)
Definition: swenum.c:27
LPWSTR Instance
Definition: kstypes.h:204
PDEVICE_OBJECT DeviceObject
Definition: iotypes.h:2867
NTSYSAPI NTSTATUS WINAPI RtlGUIDFromString(PUNICODE_STRING, GUID *)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define IRP_MN_QUERY_INTERFACE
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
KSDDKAPI NTSTATUS NTAPI KsGetBusEnumParentFDOFromChildPDO(IN PDEVICE_OBJECT DeviceObject, OUT PDEVICE_OBJECT *FunctionalDeviceObject)
Definition: swenum.c:1483
NTSTATUS NTAPI CompleteRequest(IN PIRP Irp, IN NTSTATUS Status, IN ULONG_PTR Information)
Definition: dispatch.c:19
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
VOID NTAPI KspBusReferenceDeviceObject(IN PVOID Context)
Definition: swenum.c:587
VOID NTAPI KspBusDeviceReference(IN PVOID Context)
Definition: swenum.c:565
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define IRP_MN_QUERY_BUS_INFORMATION
char * PBOOLEAN
Definition: retypes.h:11
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
static const GUID InterfaceGuid
Definition: wlanapi.c:25
KSDDKAPI NTSTATUS NTAPI KsServiceBusEnumPnpRequest(IN PDEVICE_OBJECT DeviceObject, IN OUT PIRP Irp)
Definition: swenum.c:2020
static const WCHAR L[]
Definition: oid.c:1250
#define InterlockedDecrement
Definition: armddk.h:52
PCOMMON_DEVICE_EXTENSION Ext
Definition: kstypes.h:167
LPWSTR BusId
Definition: kstypes.h:201
Definition: ketypes.h:687
#define NTSTATUS
Definition: precomp.h:20
DEVICE_STATE DeviceState
Definition: kstypes.h:197
GUID InterfaceGuid
Definition: kstypes.h:173
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:414
NTSTATUS(NTAPI * PKSP_BUS_ENUM_CALLBACK)(IN PHANDLE hKey, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DummyEntry, IN LPWSTR RootName, IN LPWSTR DirectoryName)
Definition: swenum.c:19
#define GENERIC_READ
Definition: compat.h:124
Definition: typedefs.h:117
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
KSDDKAPI NTSTATUS NTAPI KsGetBusEnumPnpDeviceObject(IN PDEVICE_OBJECT DeviceObject, IN PDEVICE_OBJECT *PnpDeviceObject)
Definition: swenum.c:1745
#define wcsicmp
Definition: string.h:1152
* PDEVICE_CAPABILITIES
Definition: iotypes.h:928
Status
Definition: gdiplustypes.h:24
_In_opt_ PVOID _In_opt_ PVOID _In_opt_ PVOID SystemArgument2
Definition: ketypes.h:675
LIST_ENTRY IrpPendingList
Definition: kstypes.h:195
Definition: kstypes.h:170
Definition: kstypes.h:191
KSDDKAPI NTSTATUS NTAPI KsInstallBusEnumInterface(PIRP Irp)
Definition: swenum.c:1799
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
ULONG_PTR SIZE_T
Definition: typedefs.h:78
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
PFILE_OBJECT FileObject
Definition: iotypes.h:2813
VOID NTAPI IoInvalidateDeviceRelations(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_RELATION_TYPE Type)
Definition: pnpmgr.c:5111
NTSTATUS NTAPI IoRegisterDeviceInterface(IN PDEVICE_OBJECT PhysicalDeviceObject, IN CONST GUID *InterfaceClassGuid, IN PUNICODE_STRING ReferenceString OPTIONAL, OUT PUNICODE_STRING SymbolicLinkName)
Definition: deviface.c:955
struct _DEVICE_RELATIONS DEVICE_RELATIONS
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define IRP_INPUT_OPERATION
_In_ BOOL bEnable
Definition: winddi.h:3426
#define IRP_BUFFERED_IO
#define InterlockedIncrement
Definition: armddk.h:53
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
PDEVICE_OBJECT PDO
Definition: kstypes.h:196
unsigned short USHORT
Definition: pedump.c:61
struct BUS_INSTANCE_ENTRY * PBUS_INSTANCE_ENTRY
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
KSDDKAPI NTSTATUS NTAPI KsIsBusEnumChildDevice(IN PDEVICE_OBJECT DeviceObject, OUT PBOOLEAN ChildDevice)
Definition: swenum.c:1858
_Inout_opt_ PDEVICE_OBJECT _Inout_opt_ PDEVICE_OBJECT * FunctionalDeviceObject
Definition: ndis.h:4640
#define STATUS_REPARSE
Definition: ntstatus.h:83
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
VOID NTAPI KspBusDpcRoutine(IN PKDPC Dpc, IN PVOID DeferredContext OPTIONAL, IN PVOID SystemArgument1 OPTIONAL, IN PVOID SystemArgument2 OPTIONAL)
Definition: swenum.c:1269
#define FILE_DEVICE_UNKNOWN
Definition: winioctl.h:139
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
#define IRP_MN_QUERY_DEVICE_RELATIONS
NTSTATUS KspQueryBusDeviceCapabilities(IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
Definition: swenum.c:822
#define DPRINT1
Definition: precomp.h:8
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
NTSTATUS KspEnumerateBusRegistryKeys(IN HANDLE hKey, IN LPWSTR ReferenceString, IN PKSP_BUS_ENUM_CALLBACK Callback, IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension, IN PBUS_DEVICE_ENTRY DeviceEntry)
Definition: swenum.c:168
#define IRP_DEALLOCATE_BUFFER
VOID NTAPI KspBusDereferenceDeviceObject(IN PVOID Context)
Definition: swenum.c:598
#define OUT
Definition: typedefs.h:39
#define ObReferenceObject
Definition: obfuncs.h:204
PVOID PIRP
Definition: usb.h:38
struct tagContext Context
Definition: acpixf.h:1030
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:566
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:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define ULONG_PTR
Definition: config.h:101
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
PDEVICE_OBJECT PnpDeviceObject
Definition: kstypes.h:214
VOID NTAPI KspBusWorkerRoutine(IN PVOID Parameter)
Definition: swenum.c:1179
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
WCHAR * LPWSTR
Definition: xmlstorage.h:184
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
NTSTATUS KspStartBusDevice(IN PDEVICE_OBJECT DeviceObject, IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension, IN PIRP Irp)
Definition: swenum.c:760
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:711
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
COMMON_DEVICE_EXTENSION Common
Definition: kstypes.h:209
struct DEV_EXTENSION * PDEV_EXTENSION
return STATUS_SUCCESS
Definition: btrfs.c:2938
VOID NTAPI KspBusDeviceDereference(IN PVOID Context)
Definition: swenum.c:576
IoMarkIrpPending(Irp)
signed int * PLONG
Definition: retypes.h:5
LPFNPSPCALLBACK Callback
Definition: desk.c:111
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
static PLARGE_INTEGER Time
Definition: time.c:105
INTERFACE_TYPE LegacyBusType
Definition: cmtypes.h:363
base of all file and directory entries
Definition: entries.h:82
#define IRP_MN_QUERY_PNP_DEVICE_STATE
#define Int32x32To64(a, b)
LONGLONG QuadPart
Definition: typedefs.h:112
#define IRP_MN_QUERY_CAPABILITIES
PDEVICE_OBJECT BusDeviceObject
Definition: kstypes.h:215
UNICODE_STRING SymbolicLink
Definition: kstypes.h:174
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
const GUID KSMEDIUMSETID_Standard
Definition: swenum.c:12
VOID KspCompletePendingIrps(IN PBUS_DEVICE_ENTRY DeviceEntry, IN OUT NTSTATUS ResultCode)
Definition: swenum.c:718
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
_In_opt_ PVOID DeferredContext
Definition: ketypes.h:675
LIST_ENTRY DeviceInterfaceList
Definition: kstypes.h:194