svn will drive me nuts, part 1/x
[reactos.git] / ntoskrnl / io / pnpmgr / pnpmgr.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * COPYRIGHT: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/io/pnpmgr/pnpmgr.c
5 * PURPOSE: Initializes the PnP manager
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Copyright 2007 Hervé Poussineau (hpoussin@reactos.org)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 #define ENABLE_ACPI
17
18 /* GLOBALS *******************************************************************/
19
20 PDEVICE_NODE IopRootDeviceNode;
21 KSPIN_LOCK IopDeviceTreeLock;
22 ERESOURCE PpRegistryDeviceResource;
23 KGUARDED_MUTEX PpDeviceReferenceTableLock;
24 RTL_AVL_TABLE PpDeviceReferenceTable;
25
26 extern ULONG ExpInitializationPhase;
27 extern BOOLEAN PnpSystemInit;
28
29 /* DATA **********************************************************************/
30
31 PDRIVER_OBJECT IopRootDriverObject;
32 FAST_MUTEX IopBusTypeGuidListLock;
33 PIO_BUS_TYPE_GUID_LIST IopBusTypeGuidList = NULL;
34
35 #if defined (ALLOC_PRAGMA)
36 #pragma alloc_text(INIT, PnpInit)
37 #pragma alloc_text(INIT, PnpInit2)
38 #endif
39
40 typedef struct _INVALIDATE_DEVICE_RELATION_DATA
41 {
42 PDEVICE_OBJECT DeviceObject;
43 DEVICE_RELATION_TYPE Type;
44 PIO_WORKITEM WorkItem;
45 } INVALIDATE_DEVICE_RELATION_DATA, *PINVALIDATE_DEVICE_RELATION_DATA;
46
47 /* FUNCTIONS *****************************************************************/
48
49 static NTSTATUS
50 IopAssignDeviceResources(
51 IN PDEVICE_NODE DeviceNode,
52 OUT ULONG *pRequiredSize);
53 static NTSTATUS
54 IopTranslateDeviceResources(
55 IN PDEVICE_NODE DeviceNode,
56 IN ULONG RequiredSize);
57
58 PDEVICE_NODE
59 FASTCALL
60 IopGetDeviceNode(PDEVICE_OBJECT DeviceObject)
61 {
62 return ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
63 }
64
65 NTSTATUS
66 FASTCALL
67 IopInitializeDevice(PDEVICE_NODE DeviceNode,
68 PDRIVER_OBJECT DriverObject)
69 {
70 PDEVICE_OBJECT Fdo;
71 NTSTATUS Status;
72
73 if (!DriverObject->DriverExtension->AddDevice)
74 return STATUS_SUCCESS;
75
76 /* This is a Plug and Play driver */
77 DPRINT("Plug and Play driver found\n");
78 ASSERT(DeviceNode->PhysicalDeviceObject);
79
80 /* Check if this plug-and-play driver is used as a legacy one for this device node */
81 if (IopDeviceNodeHasFlag(DeviceNode, DNF_LEGACY_DRIVER))
82 {
83 IopDeviceNodeSetFlag(DeviceNode, DNF_ADDED);
84 return STATUS_SUCCESS;
85 }
86
87 DPRINT("Calling %wZ->AddDevice(%wZ)\n",
88 &DriverObject->DriverName,
89 &DeviceNode->InstancePath);
90 Status = DriverObject->DriverExtension->AddDevice(
91 DriverObject, DeviceNode->PhysicalDeviceObject);
92 if (!NT_SUCCESS(Status))
93 {
94 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
95 return Status;
96 }
97
98 /* Check if driver added a FDO above the PDO */
99 Fdo = IoGetAttachedDeviceReference(DeviceNode->PhysicalDeviceObject);
100 if (Fdo == DeviceNode->PhysicalDeviceObject)
101 {
102 /* FIXME: What do we do? Unload the driver or just disable the device? */
103 DPRINT1("An FDO was not attached\n");
104 ObDereferenceObject(Fdo);
105 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
106 return STATUS_UNSUCCESSFUL;
107 }
108
109 /* Check if we have a ACPI device (needed for power management) */
110 if (Fdo->DeviceType == FILE_DEVICE_ACPI)
111 {
112 static BOOLEAN SystemPowerDeviceNodeCreated = FALSE;
113
114 /* There can be only one system power device */
115 if (!SystemPowerDeviceNodeCreated)
116 {
117 PopSystemPowerDeviceNode = DeviceNode;
118 ObReferenceObject(PopSystemPowerDeviceNode);
119 SystemPowerDeviceNodeCreated = TRUE;
120 }
121 }
122
123 ObDereferenceObject(Fdo);
124
125 IopDeviceNodeSetFlag(DeviceNode, DNF_ADDED);
126 IopDeviceNodeSetFlag(DeviceNode, DNF_NEED_ENUMERATION_ONLY);
127
128 return STATUS_SUCCESS;
129 }
130
131 NTSTATUS
132 IopStartDevice(
133 PDEVICE_NODE DeviceNode)
134 {
135 IO_STATUS_BLOCK IoStatusBlock;
136 IO_STACK_LOCATION Stack;
137 ULONG RequiredLength;
138 NTSTATUS Status;
139
140 IopDeviceNodeSetFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
141 DPRINT("Sending IRP_MN_FILTER_RESOURCE_REQUIREMENTS to device stack\n");
142 Stack.Parameters.FilterResourceRequirements.IoResourceRequirementList = DeviceNode->ResourceRequirements;
143 Status = IopInitiatePnpIrp(
144 DeviceNode->PhysicalDeviceObject,
145 &IoStatusBlock,
146 IRP_MN_FILTER_RESOURCE_REQUIREMENTS,
147 &Stack);
148 if (!NT_SUCCESS(Status) && Status != STATUS_NOT_SUPPORTED)
149 {
150 DPRINT("IopInitiatePnpIrp(IRP_MN_FILTER_RESOURCE_REQUIREMENTS) failed\n");
151 return Status;
152 }
153 DeviceNode->ResourceRequirements = Stack.Parameters.FilterResourceRequirements.IoResourceRequirementList;
154
155 Status = IopAssignDeviceResources(DeviceNode, &RequiredLength);
156 if (NT_SUCCESS(Status))
157 {
158 Status = IopTranslateDeviceResources(DeviceNode, RequiredLength);
159 if (NT_SUCCESS(Status))
160 {
161 IopDeviceNodeSetFlag(DeviceNode, DNF_RESOURCE_ASSIGNED);
162 }
163 else
164 {
165 DPRINT("IopTranslateDeviceResources() failed (Status 0x%08lx)\n", Status);
166 }
167 }
168 else
169 {
170 DPRINT("IopAssignDeviceResources() failed (Status 0x%08lx)\n", Status);
171 }
172 IopDeviceNodeClearFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
173
174 DPRINT("Sending IRP_MN_START_DEVICE to driver\n");
175 Stack.Parameters.StartDevice.AllocatedResources = DeviceNode->ResourceList;
176 Stack.Parameters.StartDevice.AllocatedResourcesTranslated = DeviceNode->ResourceListTranslated;
177
178 /*
179 * Windows NT Drivers receive IRP_MN_START_DEVICE in a critical region and
180 * actually _depend_ on this!. This is because NT will lock the Device Node
181 * with an ERESOURCE, which of course requires APCs to be disabled.
182 */
183 KeEnterCriticalRegion();
184
185 Status = IopInitiatePnpIrp(
186 DeviceNode->PhysicalDeviceObject,
187 &IoStatusBlock,
188 IRP_MN_START_DEVICE,
189 &Stack);
190
191 KeLeaveCriticalRegion();
192
193 if (!NT_SUCCESS(Status))
194 {
195 DPRINT("IopInitiatePnpIrp() failed\n");
196 }
197 else
198 {
199 if (IopDeviceNodeHasFlag(DeviceNode, DNF_NEED_ENUMERATION_ONLY))
200 {
201 DPRINT("Device needs enumeration, invalidating bus relations\n");
202 /* Invalidate device relations synchronously
203 (otherwise there will be dirty read of DeviceNode) */
204 IopEnumerateDevice(DeviceNode->PhysicalDeviceObject);
205 IopDeviceNodeClearFlag(DeviceNode, DNF_NEED_ENUMERATION_ONLY);
206 }
207 }
208
209 if (NT_SUCCESS(Status))
210 IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
211
212 return Status;
213 }
214
215 NTSTATUS
216 NTAPI
217 IopQueryDeviceCapabilities(PDEVICE_NODE DeviceNode,
218 PDEVICE_CAPABILITIES DeviceCaps)
219 {
220 IO_STATUS_BLOCK StatusBlock;
221 IO_STACK_LOCATION Stack;
222
223 /* Set up the Header */
224 RtlZeroMemory(DeviceCaps, sizeof(DEVICE_CAPABILITIES));
225 DeviceCaps->Size = sizeof(DEVICE_CAPABILITIES);
226 DeviceCaps->Version = 1;
227 DeviceCaps->Address = -1;
228 DeviceCaps->UINumber = -1;
229
230 /* Set up the Stack */
231 RtlZeroMemory(&Stack, sizeof(IO_STACK_LOCATION));
232 Stack.Parameters.DeviceCapabilities.Capabilities = DeviceCaps;
233
234 /* Send the IRP */
235 return IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
236 &StatusBlock,
237 IRP_MN_QUERY_CAPABILITIES,
238 &Stack);
239 }
240
241 static VOID NTAPI
242 IopAsynchronousInvalidateDeviceRelations(
243 IN PDEVICE_OBJECT DeviceObject,
244 IN PVOID InvalidateContext)
245 {
246 PINVALIDATE_DEVICE_RELATION_DATA Data = InvalidateContext;
247
248 IoSynchronousInvalidateDeviceRelations(
249 Data->DeviceObject,
250 Data->Type);
251
252 ObDereferenceObject(Data->DeviceObject);
253 IoFreeWorkItem(Data->WorkItem);
254 ExFreePool(Data);
255 }
256
257 NTSTATUS
258 IopGetSystemPowerDeviceObject(PDEVICE_OBJECT *DeviceObject)
259 {
260 KIRQL OldIrql;
261
262 if (PopSystemPowerDeviceNode)
263 {
264 KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
265 *DeviceObject = PopSystemPowerDeviceNode->PhysicalDeviceObject;
266 KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
267
268 return STATUS_SUCCESS;
269 }
270
271 return STATUS_UNSUCCESSFUL;
272 }
273
274 USHORT
275 NTAPI
276 IopGetBusTypeGuidIndex(LPGUID BusTypeGuid)
277 {
278 USHORT i = 0, FoundIndex = 0xFFFF;
279 ULONG NewSize;
280 PVOID NewList;
281
282 /* Acquire the lock */
283 ExAcquireFastMutex(&IopBusTypeGuidListLock);
284
285 /* Loop all entries */
286 while (i < IopBusTypeGuidList->GuidCount)
287 {
288 /* Try to find a match */
289 if (RtlCompareMemory(BusTypeGuid,
290 &IopBusTypeGuidList->Guids[i],
291 sizeof(GUID)) == sizeof(GUID))
292 {
293 /* Found it */
294 FoundIndex = i;
295 goto Quickie;
296 }
297 i++;
298 }
299
300 /* Check if we have to grow the list */
301 if (IopBusTypeGuidList->GuidCount)
302 {
303 /* Calculate the new size */
304 NewSize = sizeof(IO_BUS_TYPE_GUID_LIST) +
305 (sizeof(GUID) * IopBusTypeGuidList->GuidCount);
306
307 /* Allocate the new copy */
308 NewList = ExAllocatePool(PagedPool, NewSize);
309
310 if (!NewList) {
311 /* Fail */
312 ExFreePool(IopBusTypeGuidList);
313 goto Quickie;
314 }
315
316 /* Now copy them, decrease the size too */
317 NewSize -= sizeof(GUID);
318 RtlCopyMemory(NewList, IopBusTypeGuidList, NewSize);
319
320 /* Free the old list */
321 ExFreePool(IopBusTypeGuidList);
322
323 /* Use the new buffer */
324 IopBusTypeGuidList = NewList;
325 }
326
327 /* Copy the new GUID */
328 RtlCopyMemory(&IopBusTypeGuidList->Guids[IopBusTypeGuidList->GuidCount],
329 BusTypeGuid,
330 sizeof(GUID));
331
332 /* The new entry is the index */
333 FoundIndex = (USHORT)IopBusTypeGuidList->GuidCount;
334 IopBusTypeGuidList->GuidCount++;
335
336 Quickie:
337 ExReleaseFastMutex(&IopBusTypeGuidListLock);
338 return FoundIndex;
339 }
340
341 /*
342 * DESCRIPTION
343 * Creates a device node
344 *
345 * ARGUMENTS
346 * ParentNode = Pointer to parent device node
347 * PhysicalDeviceObject = Pointer to PDO for device object. Pass NULL
348 * to have the root device node create one
349 * (eg. for legacy drivers)
350 * DeviceNode = Pointer to storage for created device node
351 *
352 * RETURN VALUE
353 * Status
354 */
355 NTSTATUS
356 IopCreateDeviceNode(PDEVICE_NODE ParentNode,
357 PDEVICE_OBJECT PhysicalDeviceObject,
358 PUNICODE_STRING ServiceName,
359 PDEVICE_NODE *DeviceNode)
360 {
361 PDEVICE_NODE Node;
362 NTSTATUS Status;
363 KIRQL OldIrql;
364
365 DPRINT("ParentNode 0x%p PhysicalDeviceObject 0x%p ServiceName %wZ\n",
366 ParentNode, PhysicalDeviceObject, ServiceName);
367
368 Node = (PDEVICE_NODE)ExAllocatePool(NonPagedPool, sizeof(DEVICE_NODE));
369 if (!Node)
370 {
371 return STATUS_INSUFFICIENT_RESOURCES;
372 }
373
374 RtlZeroMemory(Node, sizeof(DEVICE_NODE));
375
376 if (!PhysicalDeviceObject)
377 {
378 Status = PnpRootCreateDevice(ServiceName, &PhysicalDeviceObject);
379 if (!NT_SUCCESS(Status))
380 {
381 DPRINT1("PnpRootCreateDevice() failed with status 0x%08X\n", Status);
382 ExFreePool(Node);
383 return Status;
384 }
385
386 /* This is for drivers passed on the command line to ntoskrnl.exe */
387 IopDeviceNodeSetFlag(Node, DNF_STARTED);
388 IopDeviceNodeSetFlag(Node, DNF_LEGACY_DRIVER);
389 }
390
391 Node->PhysicalDeviceObject = PhysicalDeviceObject;
392
393 ((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = Node;
394
395 if (ParentNode)
396 {
397 KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
398 Node->Parent = ParentNode;
399 Node->Sibling = ParentNode->Child;
400 ParentNode->Child = Node;
401 if (ParentNode->LastChild == NULL)
402 ParentNode->LastChild = Node;
403 KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
404 Node->Level = ParentNode->Level + 1;
405 }
406
407 PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
408
409 *DeviceNode = Node;
410
411 return STATUS_SUCCESS;
412 }
413
414 NTSTATUS
415 IopFreeDeviceNode(PDEVICE_NODE DeviceNode)
416 {
417 KIRQL OldIrql;
418 PDEVICE_NODE PrevSibling = NULL;
419
420 /* All children must be deleted before a parent is deleted */
421 ASSERT(!DeviceNode->Child);
422
423 KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
424
425 ASSERT(DeviceNode->PhysicalDeviceObject);
426
427 ObDereferenceObject(DeviceNode->PhysicalDeviceObject);
428
429 /* Get previous sibling */
430 if (DeviceNode->Parent && DeviceNode->Parent->Child != DeviceNode)
431 {
432 PrevSibling = DeviceNode->Parent->Child;
433 while (PrevSibling->Sibling != DeviceNode)
434 PrevSibling = PrevSibling->Sibling;
435 }
436
437 /* Unlink from parent if it exists */
438 if (DeviceNode->Parent)
439 {
440 if (DeviceNode->Parent->LastChild == DeviceNode)
441 {
442 DeviceNode->Parent->LastChild = PrevSibling;
443 if (PrevSibling)
444 PrevSibling->Sibling = NULL;
445 }
446 if (DeviceNode->Parent->Child == DeviceNode)
447 DeviceNode->Parent->Child = DeviceNode->Sibling;
448 }
449
450 /* Unlink from sibling list */
451 if (PrevSibling)
452 PrevSibling->Sibling = DeviceNode->Sibling;
453
454 KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
455
456 RtlFreeUnicodeString(&DeviceNode->InstancePath);
457
458 RtlFreeUnicodeString(&DeviceNode->ServiceName);
459
460 if (DeviceNode->ResourceList)
461 {
462 ExFreePool(DeviceNode->ResourceList);
463 }
464
465 if (DeviceNode->ResourceListTranslated)
466 {
467 ExFreePool(DeviceNode->ResourceListTranslated);
468 }
469
470 if (DeviceNode->ResourceRequirements)
471 {
472 ExFreePool(DeviceNode->ResourceRequirements);
473 }
474
475 if (DeviceNode->BootResources)
476 {
477 ExFreePool(DeviceNode->BootResources);
478 }
479
480 ExFreePool(DeviceNode);
481
482 return STATUS_SUCCESS;
483 }
484
485 NTSTATUS
486 IopInitiatePnpIrp(PDEVICE_OBJECT DeviceObject,
487 PIO_STATUS_BLOCK IoStatusBlock,
488 ULONG MinorFunction,
489 PIO_STACK_LOCATION Stack OPTIONAL)
490 {
491 PDEVICE_OBJECT TopDeviceObject;
492 PIO_STACK_LOCATION IrpSp;
493 NTSTATUS Status;
494 KEVENT Event;
495 PIRP Irp;
496
497 /* Always call the top of the device stack */
498 TopDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
499
500 KeInitializeEvent(
501 &Event,
502 NotificationEvent,
503 FALSE);
504
505 Irp = IoBuildSynchronousFsdRequest(
506 IRP_MJ_PNP,
507 TopDeviceObject,
508 NULL,
509 0,
510 NULL,
511 &Event,
512 IoStatusBlock);
513
514 /* PNP IRPs are initialized with a status code of STATUS_NOT_SUPPORTED */
515 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
516 Irp->IoStatus.Information = 0;
517
518 if (MinorFunction == IRP_MN_FILTER_RESOURCE_REQUIREMENTS)
519 {
520 Irp->IoStatus.Information = (ULONG_PTR)Stack->Parameters.FilterResourceRequirements.IoResourceRequirementList;
521 }
522
523 IrpSp = IoGetNextIrpStackLocation(Irp);
524 IrpSp->MinorFunction = (UCHAR)MinorFunction;
525
526 if (Stack)
527 {
528 RtlCopyMemory(&IrpSp->Parameters,
529 &Stack->Parameters,
530 sizeof(Stack->Parameters));
531 }
532
533 Status = IoCallDriver(TopDeviceObject, Irp);
534 if (Status == STATUS_PENDING)
535 {
536 KeWaitForSingleObject(&Event,
537 Executive,
538 KernelMode,
539 FALSE,
540 NULL);
541 Status = IoStatusBlock->Status;
542 }
543
544 ObDereferenceObject(TopDeviceObject);
545
546 return Status;
547 }
548
549
550 NTSTATUS
551 IopTraverseDeviceTreeNode(PDEVICETREE_TRAVERSE_CONTEXT Context)
552 {
553 PDEVICE_NODE ParentDeviceNode;
554 PDEVICE_NODE ChildDeviceNode;
555 NTSTATUS Status;
556
557 /* Copy context data so we don't overwrite it in subsequent calls to this function */
558 ParentDeviceNode = Context->DeviceNode;
559
560 /* Call the action routine */
561 Status = (Context->Action)(ParentDeviceNode, Context->Context);
562 if (!NT_SUCCESS(Status))
563 {
564 return Status;
565 }
566
567 /* Traversal of all children nodes */
568 for (ChildDeviceNode = ParentDeviceNode->Child;
569 ChildDeviceNode != NULL;
570 ChildDeviceNode = ChildDeviceNode->Sibling)
571 {
572 /* Pass the current device node to the action routine */
573 Context->DeviceNode = ChildDeviceNode;
574
575 Status = IopTraverseDeviceTreeNode(Context);
576 if (!NT_SUCCESS(Status))
577 {
578 return Status;
579 }
580 }
581
582 return Status;
583 }
584
585
586 NTSTATUS
587 IopTraverseDeviceTree(PDEVICETREE_TRAVERSE_CONTEXT Context)
588 {
589 NTSTATUS Status;
590
591 DPRINT("Context 0x%p\n", Context);
592
593 DPRINT("IopTraverseDeviceTree(DeviceNode 0x%p FirstDeviceNode 0x%p Action %x Context 0x%p)\n",
594 Context->DeviceNode, Context->FirstDeviceNode, Context->Action, Context->Context);
595
596 /* Start from the specified device node */
597 Context->DeviceNode = Context->FirstDeviceNode;
598
599 /* Recursively traverse the device tree */
600 Status = IopTraverseDeviceTreeNode(Context);
601 if (Status == STATUS_UNSUCCESSFUL)
602 {
603 /* The action routine just wanted to terminate the traversal with status
604 code STATUS_SUCCESS */
605 Status = STATUS_SUCCESS;
606 }
607
608 return Status;
609 }
610
611
612 /*
613 * IopCreateDeviceKeyPath
614 *
615 * Creates a registry key
616 *
617 * Parameters
618 * RegistryPath
619 * Name of the key to be created.
620 * Handle
621 * Handle to the newly created key
622 *
623 * Remarks
624 * This method can create nested trees, so parent of RegistryPath can
625 * be not existant, and will be created if needed.
626 */
627 NTSTATUS
628 NTAPI
629 IopCreateDeviceKeyPath(IN PCUNICODE_STRING RegistryPath,
630 OUT PHANDLE Handle)
631 {
632 UNICODE_STRING EnumU = RTL_CONSTANT_STRING(ENUM_ROOT);
633 HANDLE hParent = NULL, hKey;
634 OBJECT_ATTRIBUTES ObjectAttributes;
635 UNICODE_STRING KeyName;
636 LPCWSTR Current, Last;
637 ULONG dwLength;
638 NTSTATUS Status;
639
640 /* Assume failure */
641 *Handle = NULL;
642
643 /* Open root key for device instances */
644 Status = IopOpenRegistryKeyEx(&hParent, NULL, &EnumU, KEY_CREATE_SUB_KEY);
645 if (!NT_SUCCESS(Status))
646 {
647 DPRINT1("ZwOpenKey('%wZ') failed with status 0x%08lx\n", &EnumU, Status);
648 return Status;
649 }
650
651 Current = KeyName.Buffer = RegistryPath->Buffer;
652 Last = &RegistryPath->Buffer[RegistryPath->Length / sizeof(WCHAR)];
653
654 /* Go up to the end of the string */
655 while (Current <= Last)
656 {
657 if (Current != Last && *Current != '\\')
658 {
659 /* Not the end of the string and not a separator */
660 Current++;
661 continue;
662 }
663
664 /* Prepare relative key name */
665 dwLength = (ULONG_PTR)Current - (ULONG_PTR)KeyName.Buffer;
666 KeyName.MaximumLength = KeyName.Length = dwLength;
667 DPRINT("Create '%wZ'\n", &KeyName);
668
669 /* Open key */
670 InitializeObjectAttributes(&ObjectAttributes,
671 &KeyName,
672 OBJ_CASE_INSENSITIVE,
673 hParent,
674 NULL);
675 Status = ZwCreateKey(&hKey,
676 Current == Last ? KEY_ALL_ACCESS : KEY_CREATE_SUB_KEY,
677 &ObjectAttributes,
678 0,
679 NULL,
680 0,
681 NULL);
682
683 /* Close parent key handle, we don't need it anymore */
684 if (hParent)
685 ZwClose(hParent);
686
687 /* Key opening/creating failed? */
688 if (!NT_SUCCESS(Status))
689 {
690 DPRINT1("ZwCreateKey('%wZ') failed with status 0x%08lx\n", &KeyName, Status);
691 return Status;
692 }
693
694 /* Check if it is the end of the string */
695 if (Current == Last)
696 {
697 /* Yes, return success */
698 *Handle = hKey;
699 return STATUS_SUCCESS;
700 }
701
702 /* Start with this new parent key */
703 hParent = hKey;
704 Current++;
705 KeyName.Buffer = (LPWSTR)Current;
706 }
707
708 return STATUS_UNSUCCESSFUL;
709 }
710
711
712 static
713 NTSTATUS
714 IopSetDeviceInstanceData(HANDLE InstanceKey,
715 PDEVICE_NODE DeviceNode)
716 {
717 OBJECT_ATTRIBUTES ObjectAttributes;
718 UNICODE_STRING KeyName;
719 HANDLE LogConfKey;
720 ULONG ResCount;
721 ULONG ListSize, ResultLength;
722 NTSTATUS Status;
723
724 DPRINT("IopSetDeviceInstanceData() called\n");
725
726 /* Create the 'LogConf' key */
727 RtlInitUnicodeString(&KeyName, L"LogConf");
728 InitializeObjectAttributes(&ObjectAttributes,
729 &KeyName,
730 OBJ_CASE_INSENSITIVE,
731 InstanceKey,
732 NULL);
733 Status = ZwCreateKey(&LogConfKey,
734 KEY_ALL_ACCESS,
735 &ObjectAttributes,
736 0,
737 NULL,
738 0,
739 NULL);
740 if (NT_SUCCESS(Status))
741 {
742 /* Set 'BootConfig' value */
743 if (DeviceNode->BootResources != NULL)
744 {
745 ResCount = DeviceNode->BootResources->Count;
746 if (ResCount != 0)
747 {
748 ListSize = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
749
750 RtlInitUnicodeString(&KeyName, L"BootConfig");
751 Status = ZwSetValueKey(LogConfKey,
752 &KeyName,
753 0,
754 REG_RESOURCE_LIST,
755 DeviceNode->BootResources,
756 ListSize);
757 }
758 }
759
760 /* Set 'BasicConfigVector' value */
761 if (DeviceNode->ResourceRequirements != NULL &&
762 DeviceNode->ResourceRequirements->ListSize != 0)
763 {
764 RtlInitUnicodeString(&KeyName, L"BasicConfigVector");
765 Status = ZwSetValueKey(LogConfKey,
766 &KeyName,
767 0,
768 REG_RESOURCE_REQUIREMENTS_LIST,
769 DeviceNode->ResourceRequirements,
770 DeviceNode->ResourceRequirements->ListSize);
771 }
772
773 ZwClose(LogConfKey);
774 }
775
776 /* Set the 'ConfigFlags' value */
777 RtlInitUnicodeString(&KeyName, L"ConfigFlags");
778 Status = ZwQueryValueKey(InstanceKey,
779 &KeyName,
780 KeyValueBasicInformation,
781 NULL,
782 0,
783 &ResultLength);
784 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
785 {
786 /* Write the default value */
787 ULONG DefaultConfigFlags = 0;
788 Status = ZwSetValueKey(InstanceKey,
789 &KeyName,
790 0,
791 REG_DWORD,
792 &DefaultConfigFlags,
793 sizeof(DefaultConfigFlags));
794 }
795
796 DPRINT("IopSetDeviceInstanceData() done\n");
797
798 return STATUS_SUCCESS;
799 }
800
801
802 static NTSTATUS
803 IopAssignDeviceResources(
804 IN PDEVICE_NODE DeviceNode,
805 OUT ULONG *pRequiredSize)
806 {
807 PIO_RESOURCE_LIST ResourceList;
808 PIO_RESOURCE_DESCRIPTOR ResourceDescriptor;
809 PCM_PARTIAL_RESOURCE_DESCRIPTOR DescriptorRaw;
810 PCM_PARTIAL_RESOURCE_LIST pPartialResourceList;
811 ULONG NumberOfResources = 0;
812 ULONG Size;
813 ULONG i, j;
814 NTSTATUS Status;
815
816 if (!DeviceNode->BootResources && !DeviceNode->ResourceRequirements)
817 {
818 /* No resource needed for this device */
819 DeviceNode->ResourceList = NULL;
820 *pRequiredSize = 0;
821 return STATUS_SUCCESS;
822 }
823
824 /* Fill DeviceNode->ResourceList
825 * FIXME: the PnP arbiter should go there!
826 * Actually, use the BootResources if provided, else the resource list #0
827 */
828
829 if (DeviceNode->BootResources)
830 {
831 /* Browse the boot resources to know if we have some custom structures */
832 Size = FIELD_OFFSET(CM_RESOURCE_LIST, List);
833 for (i = 0; i < DeviceNode->BootResources->Count; i++)
834 {
835 pPartialResourceList = &DeviceNode->BootResources->List[i].PartialResourceList;
836 Size += FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList.PartialDescriptors)
837 + pPartialResourceList->Count * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
838 for (j = 0; j < pPartialResourceList->Count; j++)
839 {
840 if (pPartialResourceList->PartialDescriptors[j].Type == CmResourceTypeDeviceSpecific)
841 Size += pPartialResourceList->PartialDescriptors[j].u.DeviceSpecificData.DataSize;
842 }
843 }
844
845 DeviceNode->ResourceList = ExAllocatePool(PagedPool, Size);
846 if (!DeviceNode->ResourceList)
847 {
848 Status = STATUS_NO_MEMORY;
849 goto ByeBye;
850 }
851 RtlCopyMemory(DeviceNode->ResourceList, DeviceNode->BootResources, Size);
852
853 *pRequiredSize = Size;
854 return STATUS_SUCCESS;
855 }
856
857 /* Ok, here, we have to use the device requirement list */
858 ResourceList = &DeviceNode->ResourceRequirements->List[0];
859 if (ResourceList->Version != 1 || ResourceList->Revision != 1)
860 {
861 Status = STATUS_REVISION_MISMATCH;
862 goto ByeBye;
863 }
864
865 Size = sizeof(CM_RESOURCE_LIST) + ResourceList->Count * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
866 DeviceNode->ResourceList = ExAllocatePool(PagedPool, Size);
867 if (!DeviceNode->ResourceList)
868 {
869 Status = STATUS_NO_MEMORY;
870 goto ByeBye;
871 }
872
873 DeviceNode->ResourceList->Count = 1;
874 DeviceNode->ResourceList->List[0].InterfaceType = DeviceNode->ResourceRequirements->InterfaceType;
875 DeviceNode->ResourceList->List[0].BusNumber = DeviceNode->ResourceRequirements->BusNumber;
876 DeviceNode->ResourceList->List[0].PartialResourceList.Version = 1;
877 DeviceNode->ResourceList->List[0].PartialResourceList.Revision = 1;
878
879 for (i = 0; i < ResourceList->Count; i++)
880 {
881 ResourceDescriptor = &ResourceList->Descriptors[i];
882
883 if (ResourceDescriptor->Option == 0 || ResourceDescriptor->Option == IO_RESOURCE_PREFERRED)
884 {
885 DescriptorRaw = &DeviceNode->ResourceList->List[0].PartialResourceList.PartialDescriptors[NumberOfResources];
886 NumberOfResources++;
887
888 /* Copy ResourceDescriptor to DescriptorRaw and DescriptorTranslated */
889 DescriptorRaw->Type = ResourceDescriptor->Type;
890 DescriptorRaw->ShareDisposition = ResourceDescriptor->ShareDisposition;
891 DescriptorRaw->Flags = ResourceDescriptor->Flags;
892 switch (ResourceDescriptor->Type)
893 {
894 case CmResourceTypePort:
895 {
896 DescriptorRaw->u.Port.Start = ResourceDescriptor->u.Port.MinimumAddress;
897 DescriptorRaw->u.Port.Length = ResourceDescriptor->u.Port.Length;
898 break;
899 }
900 case CmResourceTypeInterrupt:
901 {
902 INTERFACE_TYPE BusType;
903 ULONG SlotNumber;
904 ULONG ret;
905 UCHAR Irq;
906
907 DescriptorRaw->u.Interrupt.Level = 0;
908 DescriptorRaw->u.Interrupt.Vector = ResourceDescriptor->u.Interrupt.MinimumVector;
909 /* FIXME: HACK: if we have a PCI device, we try
910 * to keep the IRQ assigned by the BIOS */
911 if (NT_SUCCESS(IoGetDeviceProperty(
912 DeviceNode->PhysicalDeviceObject,
913 DevicePropertyLegacyBusType,
914 sizeof(INTERFACE_TYPE),
915 &BusType,
916 &ret)) && BusType == PCIBus)
917 {
918 /* We have a PCI bus */
919 if (NT_SUCCESS(IoGetDeviceProperty(
920 DeviceNode->PhysicalDeviceObject,
921 DevicePropertyAddress,
922 sizeof(ULONG),
923 &SlotNumber,
924 &ret)) && SlotNumber > 0)
925 {
926 /* We have a good slot number */
927 ret = HalGetBusDataByOffset(PCIConfiguration,
928 DeviceNode->ResourceRequirements->BusNumber,
929 SlotNumber,
930 &Irq,
931 0x3c /* PCI_INTERRUPT_LINE */,
932 sizeof(UCHAR));
933 if (ret != 0 && ret != 2
934 && ResourceDescriptor->u.Interrupt.MinimumVector <= Irq
935 && ResourceDescriptor->u.Interrupt.MaximumVector >= Irq)
936 {
937 /* The device already has an assigned IRQ */
938 DescriptorRaw->u.Interrupt.Vector = Irq;
939 }
940 else
941 {
942 DPRINT1("Trying to assign IRQ 0x%lx to %wZ\n",
943 DescriptorRaw->u.Interrupt.Vector,
944 &DeviceNode->InstancePath);
945 Irq = (UCHAR)DescriptorRaw->u.Interrupt.Vector;
946 ret = HalSetBusDataByOffset(PCIConfiguration,
947 DeviceNode->ResourceRequirements->BusNumber,
948 SlotNumber,
949 &Irq,
950 0x3c /* PCI_INTERRUPT_LINE */,
951 sizeof(UCHAR));
952 if (ret == 0 || ret == 2)
953 ASSERT(FALSE);
954 }
955 }
956 }
957 break;
958 }
959 case CmResourceTypeMemory:
960 {
961 DescriptorRaw->u.Memory.Start = ResourceDescriptor->u.Memory.MinimumAddress;
962 DescriptorRaw->u.Memory.Length = ResourceDescriptor->u.Memory.Length;
963 break;
964 }
965 case CmResourceTypeDma:
966 {
967 DescriptorRaw->u.Dma.Channel = ResourceDescriptor->u.Dma.MinimumChannel;
968 DescriptorRaw->u.Dma.Port = 0; /* FIXME */
969 DescriptorRaw->u.Dma.Reserved1 = 0;
970 break;
971 }
972 case CmResourceTypeBusNumber:
973 {
974 DescriptorRaw->u.BusNumber.Start = ResourceDescriptor->u.BusNumber.MinBusNumber;
975 DescriptorRaw->u.BusNumber.Length = ResourceDescriptor->u.BusNumber.Length;
976 DescriptorRaw->u.BusNumber.Reserved = ResourceDescriptor->u.BusNumber.Reserved;
977 break;
978 }
979 /*CmResourceTypeDevicePrivate:
980 case CmResourceTypePcCardConfig:
981 case CmResourceTypeMfCardConfig:
982 {
983 RtlCopyMemory(
984 &DescriptorRaw->u.DevicePrivate,
985 &ResourceDescriptor->u.DevicePrivate,
986 sizeof(ResourceDescriptor->u.DevicePrivate));
987 RtlCopyMemory(
988 &DescriptorTranslated->u.DevicePrivate,
989 &ResourceDescriptor->u.DevicePrivate,
990 sizeof(ResourceDescriptor->u.DevicePrivate));
991 break;
992 }*/
993 default:
994 DPRINT1("IopAssignDeviceResources(): unknown resource descriptor type 0x%x\n", ResourceDescriptor->Type);
995 NumberOfResources--;
996 }
997 }
998
999 }
1000
1001 DeviceNode->ResourceList->List[0].PartialResourceList.Count = NumberOfResources;
1002
1003 *pRequiredSize = Size;
1004 return STATUS_SUCCESS;
1005
1006 ByeBye:
1007 if (DeviceNode->ResourceList)
1008 {
1009 ExFreePool(DeviceNode->ResourceList);
1010 DeviceNode->ResourceList = NULL;
1011 }
1012 *pRequiredSize = 0;
1013 return Status;
1014 }
1015
1016
1017 static NTSTATUS
1018 IopTranslateDeviceResources(
1019 IN PDEVICE_NODE DeviceNode,
1020 IN ULONG RequiredSize)
1021 {
1022 PCM_PARTIAL_RESOURCE_LIST pPartialResourceList;
1023 PCM_PARTIAL_RESOURCE_DESCRIPTOR DescriptorRaw, DescriptorTranslated;
1024 ULONG i, j;
1025 NTSTATUS Status;
1026
1027 if (!DeviceNode->ResourceList)
1028 {
1029 DeviceNode->ResourceListTranslated = NULL;
1030 return STATUS_SUCCESS;
1031 }
1032
1033 /* That's easy to translate a resource list. Just copy the
1034 * untranslated one and change few fields in the copy
1035 */
1036 DeviceNode->ResourceListTranslated = ExAllocatePool(PagedPool, RequiredSize);
1037 if (!DeviceNode->ResourceListTranslated)
1038 {
1039 Status =STATUS_NO_MEMORY;
1040 goto cleanup;
1041 }
1042 RtlCopyMemory(DeviceNode->ResourceListTranslated, DeviceNode->ResourceList, RequiredSize);
1043
1044 for (i = 0; i < DeviceNode->ResourceList->Count; i++)
1045 {
1046 pPartialResourceList = &DeviceNode->ResourceList->List[i].PartialResourceList;
1047 for (j = 0; j < pPartialResourceList->Count; j++)
1048 {
1049 DescriptorRaw = &pPartialResourceList->PartialDescriptors[j];
1050 DescriptorTranslated = &DeviceNode->ResourceListTranslated->List[i].PartialResourceList.PartialDescriptors[j];
1051 switch (DescriptorRaw->Type)
1052 {
1053 case CmResourceTypePort:
1054 {
1055 ULONG AddressSpace = 1; /* IO space */
1056 if (!HalTranslateBusAddress(
1057 DeviceNode->ResourceList->List[i].InterfaceType,
1058 DeviceNode->ResourceList->List[i].BusNumber,
1059 DescriptorRaw->u.Port.Start,
1060 &AddressSpace,
1061 &DescriptorTranslated->u.Port.Start))
1062 {
1063 Status = STATUS_UNSUCCESSFUL;
1064 goto cleanup;
1065 }
1066 break;
1067 }
1068 case CmResourceTypeInterrupt:
1069 {
1070 DescriptorTranslated->u.Interrupt.Vector = HalGetInterruptVector(
1071 DeviceNode->ResourceList->List[i].InterfaceType,
1072 DeviceNode->ResourceList->List[i].BusNumber,
1073 DescriptorRaw->u.Interrupt.Level,
1074 DescriptorRaw->u.Interrupt.Vector,
1075 (PKIRQL)&DescriptorTranslated->u.Interrupt.Level,
1076 &DescriptorRaw->u.Interrupt.Affinity);
1077 break;
1078 }
1079 case CmResourceTypeMemory:
1080 {
1081 ULONG AddressSpace = 0; /* Memory space */
1082 if (!HalTranslateBusAddress(
1083 DeviceNode->ResourceList->List[i].InterfaceType,
1084 DeviceNode->ResourceList->List[i].BusNumber,
1085 DescriptorRaw->u.Memory.Start,
1086 &AddressSpace,
1087 &DescriptorTranslated->u.Memory.Start))
1088 {
1089 Status = STATUS_UNSUCCESSFUL;
1090 goto cleanup;
1091 }
1092 }
1093
1094 case CmResourceTypeDma:
1095 case CmResourceTypeBusNumber:
1096 case CmResourceTypeDeviceSpecific:
1097 /* Nothing to do */
1098 break;
1099 default:
1100 DPRINT1("Unknown resource descriptor type 0x%x\n", DescriptorRaw->Type);
1101 Status = STATUS_NOT_IMPLEMENTED;
1102 goto cleanup;
1103 }
1104 }
1105 }
1106 return STATUS_SUCCESS;
1107
1108 cleanup:
1109 /* Yes! Also delete ResourceList because ResourceList and
1110 * ResourceListTranslated should be a pair! */
1111 ExFreePool(DeviceNode->ResourceList);
1112 DeviceNode->ResourceList = NULL;
1113 if (DeviceNode->ResourceListTranslated)
1114 {
1115 ExFreePool(DeviceNode->ResourceListTranslated);
1116 DeviceNode->ResourceList = NULL;
1117 }
1118 return Status;
1119 }
1120
1121
1122 /*
1123 * IopGetParentIdPrefix
1124 *
1125 * Retrieve (or create) a string which identifies a device.
1126 *
1127 * Parameters
1128 * DeviceNode
1129 * Pointer to device node.
1130 * ParentIdPrefix
1131 * Pointer to the string where is returned the parent node identifier
1132 *
1133 * Remarks
1134 * If the return code is STATUS_SUCCESS, the ParentIdPrefix string is
1135 * valid and its Buffer field is NULL-terminated. The caller needs to
1136 * to free the string with RtlFreeUnicodeString when it is no longer
1137 * needed.
1138 */
1139
1140 NTSTATUS
1141 IopGetParentIdPrefix(PDEVICE_NODE DeviceNode,
1142 PUNICODE_STRING ParentIdPrefix)
1143 {
1144 ULONG KeyNameBufferLength;
1145 PKEY_VALUE_PARTIAL_INFORMATION ParentIdPrefixInformation = NULL;
1146 UNICODE_STRING KeyName;
1147 UNICODE_STRING KeyValue;
1148 UNICODE_STRING ValueName;
1149 HANDLE hKey = NULL;
1150 ULONG crc32;
1151 NTSTATUS Status;
1152
1153 /* HACK: As long as some devices have a NULL device
1154 * instance path, the following test is required :(
1155 */
1156 if (DeviceNode->Parent->InstancePath.Length == 0)
1157 {
1158 DPRINT1("Parent of %wZ has NULL Instance path, please report!\n",
1159 &DeviceNode->InstancePath);
1160 return STATUS_UNSUCCESSFUL;
1161 }
1162
1163 /* 1. Try to retrieve ParentIdPrefix from registry */
1164 KeyNameBufferLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[0]) + MAX_PATH * sizeof(WCHAR);
1165 ParentIdPrefixInformation = ExAllocatePool(PagedPool, KeyNameBufferLength + sizeof(WCHAR));
1166 if (!ParentIdPrefixInformation)
1167 {
1168 Status = STATUS_INSUFFICIENT_RESOURCES;
1169 goto cleanup;
1170 }
1171
1172
1173 KeyName.Buffer = ExAllocatePool(PagedPool, (49 * sizeof(WCHAR)) + DeviceNode->Parent->InstancePath.Length);
1174 if (!KeyName.Buffer)
1175 {
1176 Status = STATUS_INSUFFICIENT_RESOURCES;
1177 goto cleanup;
1178 }
1179 KeyName.Length = 0;
1180 KeyName.MaximumLength = (49 * sizeof(WCHAR)) + DeviceNode->Parent->InstancePath.Length;
1181
1182 RtlAppendUnicodeToString(&KeyName, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
1183 RtlAppendUnicodeStringToString(&KeyName, &DeviceNode->Parent->InstancePath);
1184
1185 Status = IopOpenRegistryKeyEx(&hKey, NULL, &KeyName, KEY_QUERY_VALUE | KEY_SET_VALUE);
1186 if (!NT_SUCCESS(Status))
1187 goto cleanup;
1188 RtlInitUnicodeString(&ValueName, L"ParentIdPrefix");
1189 Status = ZwQueryValueKey(
1190 hKey, &ValueName,
1191 KeyValuePartialInformation, ParentIdPrefixInformation,
1192 KeyNameBufferLength, &KeyNameBufferLength);
1193 if (NT_SUCCESS(Status))
1194 {
1195 if (ParentIdPrefixInformation->Type != REG_SZ)
1196 Status = STATUS_UNSUCCESSFUL;
1197 else
1198 {
1199 KeyValue.Length = KeyValue.MaximumLength = (USHORT)ParentIdPrefixInformation->DataLength;
1200 KeyValue.Buffer = (PWSTR)ParentIdPrefixInformation->Data;
1201 }
1202 goto cleanup;
1203 }
1204 if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
1205 {
1206 KeyValue.Length = KeyValue.MaximumLength = (USHORT)ParentIdPrefixInformation->DataLength;
1207 KeyValue.Buffer = (PWSTR)ParentIdPrefixInformation->Data;
1208 goto cleanup;
1209 }
1210
1211 /* 2. Create the ParentIdPrefix value */
1212 crc32 = RtlComputeCrc32(0,
1213 (PUCHAR)DeviceNode->Parent->InstancePath.Buffer,
1214 DeviceNode->Parent->InstancePath.Length);
1215
1216 swprintf((PWSTR)ParentIdPrefixInformation->Data, L"%lx&%lx", DeviceNode->Parent->Level, crc32);
1217 RtlInitUnicodeString(&KeyValue, (PWSTR)ParentIdPrefixInformation->Data);
1218
1219 /* 3. Try to write the ParentIdPrefix to registry */
1220 Status = ZwSetValueKey(hKey,
1221 &ValueName,
1222 0,
1223 REG_SZ,
1224 (PVOID)KeyValue.Buffer,
1225 (wcslen(KeyValue.Buffer) + 1) * sizeof(WCHAR));
1226
1227 cleanup:
1228 if (NT_SUCCESS(Status))
1229 {
1230 /* Duplicate the string to return it */
1231 Status = RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, &KeyValue, ParentIdPrefix);
1232 }
1233 ExFreePool(ParentIdPrefixInformation);
1234 RtlFreeUnicodeString(&KeyName);
1235 if (hKey != NULL)
1236 ZwClose(hKey);
1237 return Status;
1238 }
1239
1240
1241 /*
1242 * IopActionInterrogateDeviceStack
1243 *
1244 * Retrieve information for all (direct) child nodes of a parent node.
1245 *
1246 * Parameters
1247 * DeviceNode
1248 * Pointer to device node.
1249 * Context
1250 * Pointer to parent node to retrieve child node information for.
1251 *
1252 * Remarks
1253 * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
1254 * when we reach a device node which is not a direct child of the device
1255 * node for which we retrieve information of child nodes for. Any errors
1256 * that occur is logged instead so that all child services have a chance
1257 * of being interrogated.
1258 */
1259
1260 NTSTATUS
1261 IopActionInterrogateDeviceStack(PDEVICE_NODE DeviceNode,
1262 PVOID Context)
1263 {
1264 IO_STATUS_BLOCK IoStatusBlock;
1265 PDEVICE_NODE ParentDeviceNode;
1266 WCHAR InstancePath[MAX_PATH];
1267 IO_STACK_LOCATION Stack;
1268 NTSTATUS Status;
1269 PWSTR Ptr;
1270 USHORT Length;
1271 USHORT TotalLength;
1272 ULONG RequiredLength;
1273 LCID LocaleId;
1274 HANDLE InstanceKey = NULL;
1275 UNICODE_STRING ValueName;
1276 UNICODE_STRING ParentIdPrefix = { 0, 0, NULL };
1277 DEVICE_CAPABILITIES DeviceCapabilities;
1278
1279 DPRINT("IopActionInterrogateDeviceStack(%p, %p)\n", DeviceNode, Context);
1280 DPRINT("PDO 0x%p\n", DeviceNode->PhysicalDeviceObject);
1281
1282 ParentDeviceNode = (PDEVICE_NODE)Context;
1283
1284 /*
1285 * We are called for the parent too, but we don't need to do special
1286 * handling for this node
1287 */
1288
1289 if (DeviceNode == ParentDeviceNode)
1290 {
1291 DPRINT("Success\n");
1292 return STATUS_SUCCESS;
1293 }
1294
1295 /*
1296 * Make sure this device node is a direct child of the parent device node
1297 * that is given as an argument
1298 */
1299
1300 if (DeviceNode->Parent != ParentDeviceNode)
1301 {
1302 /* Stop the traversal immediately and indicate successful operation */
1303 DPRINT("Stop\n");
1304 return STATUS_UNSUCCESSFUL;
1305 }
1306
1307 /* Get Locale ID */
1308 Status = ZwQueryDefaultLocale(FALSE, &LocaleId);
1309 if (!NT_SUCCESS(Status))
1310 {
1311 DPRINT("ZwQueryDefaultLocale() failed with status 0x%lx\n", Status);
1312 return Status;
1313 }
1314
1315 /*
1316 * FIXME: For critical errors, cleanup and disable device, but always
1317 * return STATUS_SUCCESS.
1318 */
1319
1320 DPRINT("Sending IRP_MN_QUERY_ID.BusQueryDeviceID to device stack\n");
1321
1322 Stack.Parameters.QueryId.IdType = BusQueryDeviceID;
1323 Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
1324 &IoStatusBlock,
1325 IRP_MN_QUERY_ID,
1326 &Stack);
1327 if (NT_SUCCESS(Status))
1328 {
1329 /* Copy the device id string */
1330 wcscpy(InstancePath, (PWSTR)IoStatusBlock.Information);
1331
1332 /*
1333 * FIXME: Check for valid characters, if there is invalid characters
1334 * then bugcheck.
1335 */
1336 }
1337 else
1338 {
1339 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1340 }
1341
1342 DPRINT("Sending IRP_MN_QUERY_CAPABILITIES to device stack\n");
1343
1344 Status = IopQueryDeviceCapabilities(DeviceNode, &DeviceCapabilities);
1345 if (!NT_SUCCESS(Status))
1346 {
1347 DPRINT("IopInitiatePnpIrp() failed (Status 0x%08lx)\n", Status);
1348 }
1349
1350 DeviceNode->CapabilityFlags = *(PULONG)((ULONG_PTR)&DeviceCapabilities + 4);
1351
1352 if (!DeviceCapabilities.UniqueID)
1353 {
1354 /* Device has not a unique ID. We need to prepend parent bus unique identifier */
1355 DPRINT("Instance ID is not unique\n");
1356 Status = IopGetParentIdPrefix(DeviceNode, &ParentIdPrefix);
1357 if (!NT_SUCCESS(Status))
1358 {
1359 DPRINT("IopGetParentIdPrefix() failed (Status 0x%08lx)\n", Status);
1360 }
1361 }
1362
1363 DPRINT("Sending IRP_MN_QUERY_ID.BusQueryInstanceID to device stack\n");
1364
1365 Stack.Parameters.QueryId.IdType = BusQueryInstanceID;
1366 Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
1367 &IoStatusBlock,
1368 IRP_MN_QUERY_ID,
1369 &Stack);
1370 if (NT_SUCCESS(Status))
1371 {
1372 /* Append the instance id string */
1373 wcscat(InstancePath, L"\\");
1374 if (ParentIdPrefix.Length > 0)
1375 {
1376 /* Add information from parent bus device to InstancePath */
1377 wcscat(InstancePath, ParentIdPrefix.Buffer);
1378 if (IoStatusBlock.Information && *(PWSTR)IoStatusBlock.Information)
1379 wcscat(InstancePath, L"&");
1380 }
1381 if (IoStatusBlock.Information)
1382 wcscat(InstancePath, (PWSTR)IoStatusBlock.Information);
1383
1384 /*
1385 * FIXME: Check for valid characters, if there is invalid characters
1386 * then bugcheck
1387 */
1388 }
1389 else
1390 {
1391 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1392 }
1393 RtlFreeUnicodeString(&ParentIdPrefix);
1394
1395 if (!RtlCreateUnicodeString(&DeviceNode->InstancePath, InstancePath))
1396 {
1397 DPRINT("No resources\n");
1398 /* FIXME: Cleanup and disable device */
1399 }
1400
1401 DPRINT("InstancePath is %S\n", DeviceNode->InstancePath.Buffer);
1402
1403 /*
1404 * Create registry key for the instance id, if it doesn't exist yet
1405 */
1406 Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, &InstanceKey);
1407 if (!NT_SUCCESS(Status))
1408 {
1409 DPRINT1("Failed to create the instance key! (Status %lx)\n", Status);
1410 }
1411
1412 {
1413 /* Set 'Capabilities' value */
1414 RtlInitUnicodeString(&ValueName, L"Capabilities");
1415 Status = ZwSetValueKey(InstanceKey,
1416 &ValueName,
1417 0,
1418 REG_DWORD,
1419 (PVOID)&DeviceNode->CapabilityFlags,
1420 sizeof(ULONG));
1421
1422 /* Set 'UINumber' value */
1423 if (DeviceCapabilities.UINumber != MAXULONG)
1424 {
1425 RtlInitUnicodeString(&ValueName, L"UINumber");
1426 Status = ZwSetValueKey(InstanceKey,
1427 &ValueName,
1428 0,
1429 REG_DWORD,
1430 &DeviceCapabilities.UINumber,
1431 sizeof(ULONG));
1432 }
1433 }
1434
1435 DPRINT("Sending IRP_MN_QUERY_ID.BusQueryHardwareIDs to device stack\n");
1436
1437 Stack.Parameters.QueryId.IdType = BusQueryHardwareIDs;
1438 Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
1439 &IoStatusBlock,
1440 IRP_MN_QUERY_ID,
1441 &Stack);
1442 if (NT_SUCCESS(Status))
1443 {
1444 /*
1445 * FIXME: Check for valid characters, if there is invalid characters
1446 * then bugcheck.
1447 */
1448 TotalLength = 0;
1449 Ptr = (PWSTR)IoStatusBlock.Information;
1450 DPRINT("Hardware IDs:\n");
1451 while (*Ptr)
1452 {
1453 DPRINT(" %S\n", Ptr);
1454 Length = wcslen(Ptr) + 1;
1455
1456 Ptr += Length;
1457 TotalLength += Length;
1458 }
1459 DPRINT("TotalLength: %hu\n", TotalLength);
1460 DPRINT("\n");
1461
1462 RtlInitUnicodeString(&ValueName, L"HardwareID");
1463 Status = ZwSetValueKey(InstanceKey,
1464 &ValueName,
1465 0,
1466 REG_MULTI_SZ,
1467 (PVOID)IoStatusBlock.Information,
1468 (TotalLength + 1) * sizeof(WCHAR));
1469 if (!NT_SUCCESS(Status))
1470 {
1471 DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
1472 }
1473 }
1474 else
1475 {
1476 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1477 }
1478
1479 DPRINT("Sending IRP_MN_QUERY_ID.BusQueryCompatibleIDs to device stack\n");
1480
1481 Stack.Parameters.QueryId.IdType = BusQueryCompatibleIDs;
1482 Status = IopInitiatePnpIrp(
1483 DeviceNode->PhysicalDeviceObject,
1484 &IoStatusBlock,
1485 IRP_MN_QUERY_ID,
1486 &Stack);
1487 if (NT_SUCCESS(Status) && IoStatusBlock.Information)
1488 {
1489 /*
1490 * FIXME: Check for valid characters, if there is invalid characters
1491 * then bugcheck.
1492 */
1493 TotalLength = 0;
1494 Ptr = (PWSTR)IoStatusBlock.Information;
1495 DPRINT("Compatible IDs:\n");
1496 while (*Ptr)
1497 {
1498 DPRINT(" %S\n", Ptr);
1499 Length = wcslen(Ptr) + 1;
1500
1501 Ptr += Length;
1502 TotalLength += Length;
1503 }
1504 DPRINT("TotalLength: %hu\n", TotalLength);
1505 DPRINT("\n");
1506
1507 RtlInitUnicodeString(&ValueName, L"CompatibleIDs");
1508 Status = ZwSetValueKey(InstanceKey,
1509 &ValueName,
1510 0,
1511 REG_MULTI_SZ,
1512 (PVOID)IoStatusBlock.Information,
1513 (TotalLength + 1) * sizeof(WCHAR));
1514 if (!NT_SUCCESS(Status))
1515 {
1516 DPRINT1("ZwSetValueKey() failed (Status %lx) or no Compatible ID returned\n", Status);
1517 }
1518 }
1519 else
1520 {
1521 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1522 }
1523
1524 DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextDescription to device stack\n");
1525
1526 Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextDescription;
1527 Stack.Parameters.QueryDeviceText.LocaleId = LocaleId;
1528 Status = IopInitiatePnpIrp(
1529 DeviceNode->PhysicalDeviceObject,
1530 &IoStatusBlock,
1531 IRP_MN_QUERY_DEVICE_TEXT,
1532 &Stack);
1533 /* This key is mandatory, so even if the Irp fails, we still write it */
1534 RtlInitUnicodeString(&ValueName, L"DeviceDesc");
1535 if (ZwQueryValueKey(InstanceKey, &ValueName, KeyValueBasicInformation, NULL, 0, &RequiredLength) == STATUS_OBJECT_NAME_NOT_FOUND)
1536 {
1537 if (NT_SUCCESS(Status) &&
1538 IoStatusBlock.Information &&
1539 (*(PWSTR)IoStatusBlock.Information != 0))
1540 {
1541 /* This key is overriden when a driver is installed. Don't write the
1542 * new description if another one already exists */
1543 Status = ZwSetValueKey(InstanceKey,
1544 &ValueName,
1545 0,
1546 REG_SZ,
1547 (PVOID)IoStatusBlock.Information,
1548 (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
1549 }
1550 else
1551 {
1552 UNICODE_STRING DeviceDesc = RTL_CONSTANT_STRING(L"Unknown device");
1553 DPRINT("Driver didn't return DeviceDesc (Status 0x%08lx), so place unknown device there\n", Status);
1554
1555 Status = ZwSetValueKey(InstanceKey,
1556 &ValueName,
1557 0,
1558 REG_SZ,
1559 DeviceDesc.Buffer,
1560 DeviceDesc.MaximumLength);
1561
1562 if (!NT_SUCCESS(Status))
1563 {
1564 DPRINT1("ZwSetValueKey() failed (Status 0x%lx)\n", Status);
1565 }
1566
1567 }
1568 }
1569
1570 DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextLocation to device stack\n");
1571
1572 Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextLocationInformation;
1573 Stack.Parameters.QueryDeviceText.LocaleId = LocaleId;
1574 Status = IopInitiatePnpIrp(
1575 DeviceNode->PhysicalDeviceObject,
1576 &IoStatusBlock,
1577 IRP_MN_QUERY_DEVICE_TEXT,
1578 &Stack);
1579 if (NT_SUCCESS(Status) && IoStatusBlock.Information)
1580 {
1581 DPRINT("LocationInformation: %S\n", (PWSTR)IoStatusBlock.Information);
1582 RtlInitUnicodeString(&ValueName, L"LocationInformation");
1583 Status = ZwSetValueKey(InstanceKey,
1584 &ValueName,
1585 0,
1586 REG_SZ,
1587 (PVOID)IoStatusBlock.Information,
1588 (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
1589 if (!NT_SUCCESS(Status))
1590 {
1591 DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
1592 }
1593 }
1594 else
1595 {
1596 DPRINT("IopInitiatePnpIrp() failed (Status %x) or IoStatusBlock.Information=NULL\n", Status);
1597 }
1598
1599 DPRINT("Sending IRP_MN_QUERY_BUS_INFORMATION to device stack\n");
1600
1601 Status = IopInitiatePnpIrp(
1602 DeviceNode->PhysicalDeviceObject,
1603 &IoStatusBlock,
1604 IRP_MN_QUERY_BUS_INFORMATION,
1605 NULL);
1606 if (NT_SUCCESS(Status) && IoStatusBlock.Information)
1607 {
1608 PPNP_BUS_INFORMATION BusInformation =
1609 (PPNP_BUS_INFORMATION)IoStatusBlock.Information;
1610
1611 DeviceNode->ChildBusNumber = BusInformation->BusNumber;
1612 DeviceNode->ChildInterfaceType = BusInformation->LegacyBusType;
1613 DeviceNode->ChildBusTypeIndex = IopGetBusTypeGuidIndex(&BusInformation->BusTypeGuid);
1614 ExFreePool(BusInformation);
1615 }
1616 else
1617 {
1618 DPRINT("IopInitiatePnpIrp() failed (Status %x) or IoStatusBlock.Information=NULL\n", Status);
1619
1620 DeviceNode->ChildBusNumber = 0xFFFFFFF0;
1621 DeviceNode->ChildInterfaceType = InterfaceTypeUndefined;
1622 DeviceNode->ChildBusTypeIndex = -1;
1623 }
1624
1625 DPRINT("Sending IRP_MN_QUERY_RESOURCES to device stack\n");
1626
1627 Status = IopInitiatePnpIrp(
1628 DeviceNode->PhysicalDeviceObject,
1629 &IoStatusBlock,
1630 IRP_MN_QUERY_RESOURCES,
1631 NULL);
1632 if (NT_SUCCESS(Status) && IoStatusBlock.Information)
1633 {
1634 DeviceNode->BootResources =
1635 (PCM_RESOURCE_LIST)IoStatusBlock.Information;
1636 DeviceNode->Flags |= DNF_HAS_BOOT_CONFIG;
1637 }
1638 else
1639 {
1640 DPRINT("IopInitiatePnpIrp() failed (Status %x) or IoStatusBlock.Information=NULL\n", Status);
1641 DeviceNode->BootResources = NULL;
1642 }
1643
1644 DPRINT("Sending IRP_MN_QUERY_RESOURCE_REQUIREMENTS to device stack\n");
1645
1646 Status = IopInitiatePnpIrp(
1647 DeviceNode->PhysicalDeviceObject,
1648 &IoStatusBlock,
1649 IRP_MN_QUERY_RESOURCE_REQUIREMENTS,
1650 NULL);
1651 if (NT_SUCCESS(Status))
1652 {
1653 DeviceNode->ResourceRequirements =
1654 (PIO_RESOURCE_REQUIREMENTS_LIST)IoStatusBlock.Information;
1655 if (IoStatusBlock.Information)
1656 IopDeviceNodeSetFlag(DeviceNode, DNF_RESOURCE_REPORTED);
1657 else
1658 IopDeviceNodeSetFlag(DeviceNode, DNF_NO_RESOURCE_REQUIRED);
1659 }
1660 else
1661 {
1662 DPRINT("IopInitiatePnpIrp() failed (Status %08lx)\n", Status);
1663 DeviceNode->ResourceRequirements = NULL;
1664 }
1665
1666
1667 if (InstanceKey != NULL)
1668 {
1669 IopSetDeviceInstanceData(InstanceKey, DeviceNode);
1670 }
1671
1672 ZwClose(InstanceKey);
1673
1674 IopDeviceNodeSetFlag(DeviceNode, DNF_PROCESSED);
1675
1676 if (!IopDeviceNodeHasFlag(DeviceNode, DNF_LEGACY_DRIVER))
1677 {
1678 /* Report the device to the user-mode pnp manager */
1679 IopQueueTargetDeviceEvent(&GUID_DEVICE_ENUMERATED,
1680 &DeviceNode->InstancePath);
1681 }
1682
1683 return STATUS_SUCCESS;
1684 }
1685
1686
1687 NTSTATUS
1688 IopEnumerateDevice(
1689 IN PDEVICE_OBJECT DeviceObject)
1690 {
1691 PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
1692 DEVICETREE_TRAVERSE_CONTEXT Context;
1693 PDEVICE_RELATIONS DeviceRelations;
1694 PDEVICE_OBJECT ChildDeviceObject;
1695 IO_STATUS_BLOCK IoStatusBlock;
1696 PDEVICE_NODE ChildDeviceNode;
1697 IO_STACK_LOCATION Stack;
1698 NTSTATUS Status;
1699 ULONG i;
1700
1701 DPRINT("DeviceObject 0x%p\n", DeviceObject);
1702
1703 DPRINT("Sending GUID_DEVICE_ARRIVAL\n");
1704
1705 /* Report the device to the user-mode pnp manager */
1706 IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
1707 &DeviceNode->InstancePath);
1708
1709 DPRINT("Sending IRP_MN_QUERY_DEVICE_RELATIONS to device stack\n");
1710
1711 Stack.Parameters.QueryDeviceRelations.Type = BusRelations;
1712
1713 Status = IopInitiatePnpIrp(
1714 DeviceObject,
1715 &IoStatusBlock,
1716 IRP_MN_QUERY_DEVICE_RELATIONS,
1717 &Stack);
1718 if (!NT_SUCCESS(Status) || Status == STATUS_PENDING)
1719 {
1720 DPRINT("IopInitiatePnpIrp() failed with status 0x%08lx\n", Status);
1721 return Status;
1722 }
1723
1724 DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
1725
1726 if (!DeviceRelations)
1727 {
1728 DPRINT("No PDOs\n");
1729 return STATUS_UNSUCCESSFUL;
1730 }
1731
1732 DPRINT("Got %u PDOs\n", DeviceRelations->Count);
1733
1734 /*
1735 * Create device nodes for all discovered devices
1736 */
1737 for (i = 0; i < DeviceRelations->Count; i++)
1738 {
1739 ChildDeviceObject = DeviceRelations->Objects[i];
1740 ASSERT((ChildDeviceObject->Flags & DO_DEVICE_INITIALIZING) == 0);
1741
1742 ChildDeviceNode = IopGetDeviceNode(ChildDeviceObject);
1743 if (!ChildDeviceNode)
1744 {
1745 /* One doesn't exist, create it */
1746 Status = IopCreateDeviceNode(
1747 DeviceNode,
1748 ChildDeviceObject,
1749 NULL,
1750 &ChildDeviceNode);
1751 if (NT_SUCCESS(Status))
1752 {
1753 /* Mark the node as enumerated */
1754 ChildDeviceNode->Flags |= DNF_ENUMERATED;
1755
1756 /* Mark the DO as bus enumerated */
1757 ChildDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
1758 }
1759 else
1760 {
1761 /* Ignore this DO */
1762 DPRINT1("IopCreateDeviceNode() failed with status 0x%08x. Skipping PDO %u\n", Status, i);
1763 ObDereferenceObject(ChildDeviceNode);
1764 }
1765 }
1766 else
1767 {
1768 /* Mark it as enumerated */
1769 ChildDeviceNode->Flags |= DNF_ENUMERATED;
1770 ObDereferenceObject(ChildDeviceObject);
1771 }
1772 }
1773 ExFreePool(DeviceRelations);
1774
1775 /*
1776 * Retrieve information about all discovered children from the bus driver
1777 */
1778 IopInitDeviceTreeTraverseContext(
1779 &Context,
1780 DeviceNode,
1781 IopActionInterrogateDeviceStack,
1782 DeviceNode);
1783
1784 Status = IopTraverseDeviceTree(&Context);
1785 if (!NT_SUCCESS(Status))
1786 {
1787 DPRINT("IopTraverseDeviceTree() failed with status 0x%08lx\n", Status);
1788 return Status;
1789 }
1790
1791 /*
1792 * Retrieve configuration from the registry for discovered children
1793 */
1794 IopInitDeviceTreeTraverseContext(
1795 &Context,
1796 DeviceNode,
1797 IopActionConfigureChildServices,
1798 DeviceNode);
1799
1800 Status = IopTraverseDeviceTree(&Context);
1801 if (!NT_SUCCESS(Status))
1802 {
1803 DPRINT("IopTraverseDeviceTree() failed with status 0x%08lx\n", Status);
1804 return Status;
1805 }
1806
1807 /*
1808 * Initialize services for discovered children.
1809 */
1810 Status = IopInitializePnpServices(DeviceNode);
1811 if (!NT_SUCCESS(Status))
1812 {
1813 DPRINT("IopInitializePnpServices() failed with status 0x%08lx\n", Status);
1814 return Status;
1815 }
1816
1817 DPRINT("IopEnumerateDevice() finished\n");
1818 return STATUS_SUCCESS;
1819 }
1820
1821
1822 /*
1823 * IopActionConfigureChildServices
1824 *
1825 * Retrieve configuration for all (direct) child nodes of a parent node.
1826 *
1827 * Parameters
1828 * DeviceNode
1829 * Pointer to device node.
1830 * Context
1831 * Pointer to parent node to retrieve child node configuration for.
1832 *
1833 * Remarks
1834 * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
1835 * when we reach a device node which is not a direct child of the device
1836 * node for which we configure child services for. Any errors that occur is
1837 * logged instead so that all child services have a chance of beeing
1838 * configured.
1839 */
1840
1841 NTSTATUS
1842 IopActionConfigureChildServices(PDEVICE_NODE DeviceNode,
1843 PVOID Context)
1844 {
1845 RTL_QUERY_REGISTRY_TABLE QueryTable[3];
1846 PDEVICE_NODE ParentDeviceNode;
1847 PUNICODE_STRING Service;
1848 UNICODE_STRING ClassGUID;
1849 NTSTATUS Status;
1850 DEVICE_CAPABILITIES DeviceCaps;
1851
1852 DPRINT("IopActionConfigureChildServices(%p, %p)\n", DeviceNode, Context);
1853
1854 ParentDeviceNode = (PDEVICE_NODE)Context;
1855
1856 /*
1857 * We are called for the parent too, but we don't need to do special
1858 * handling for this node
1859 */
1860 if (DeviceNode == ParentDeviceNode)
1861 {
1862 DPRINT("Success\n");
1863 return STATUS_SUCCESS;
1864 }
1865
1866 /*
1867 * Make sure this device node is a direct child of the parent device node
1868 * that is given as an argument
1869 */
1870 if (DeviceNode->Parent != ParentDeviceNode)
1871 {
1872 /* Stop the traversal immediately and indicate successful operation */
1873 DPRINT("Stop\n");
1874 return STATUS_UNSUCCESSFUL;
1875 }
1876
1877 if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED))
1878 {
1879 WCHAR RegKeyBuffer[MAX_PATH];
1880 UNICODE_STRING RegKey;
1881
1882 RegKey.Length = 0;
1883 RegKey.MaximumLength = sizeof(RegKeyBuffer);
1884 RegKey.Buffer = RegKeyBuffer;
1885
1886 /*
1887 * Retrieve configuration from Enum key
1888 */
1889
1890 Service = &DeviceNode->ServiceName;
1891
1892 RtlZeroMemory(QueryTable, sizeof(QueryTable));
1893 RtlInitUnicodeString(Service, NULL);
1894 RtlInitUnicodeString(&ClassGUID, NULL);
1895
1896 QueryTable[0].Name = L"Service";
1897 QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
1898 QueryTable[0].EntryContext = Service;
1899
1900 QueryTable[1].Name = L"ClassGUID";
1901 QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
1902 QueryTable[1].EntryContext = &ClassGUID;
1903 QueryTable[1].DefaultType = REG_SZ;
1904 QueryTable[1].DefaultData = L"";
1905 QueryTable[1].DefaultLength = 0;
1906
1907 RtlAppendUnicodeToString(&RegKey, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
1908 RtlAppendUnicodeStringToString(&RegKey, &DeviceNode->InstancePath);
1909
1910 Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
1911 RegKey.Buffer, QueryTable, NULL, NULL);
1912
1913 if (!NT_SUCCESS(Status))
1914 {
1915 /* FIXME: Log the error */
1916 DPRINT("Could not retrieve configuration for device %wZ (Status 0x%08x)\n",
1917 &DeviceNode->InstancePath, Status);
1918 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1919 return STATUS_SUCCESS;
1920 }
1921
1922 if (Service->Buffer == NULL)
1923 {
1924 if (NT_SUCCESS(IopQueryDeviceCapabilities(DeviceNode, &DeviceCaps)) &&
1925 DeviceCaps.RawDeviceOK)
1926 {
1927 DPRINT1("%wZ is using parent bus driver (%wZ)\n", &DeviceNode->InstancePath, &ParentDeviceNode->ServiceName);
1928
1929 DeviceNode->ServiceName.Length = 0;
1930 DeviceNode->ServiceName.MaximumLength = ParentDeviceNode->ServiceName.MaximumLength;
1931 DeviceNode->ServiceName.Buffer = ExAllocatePool(PagedPool, DeviceNode->ServiceName.MaximumLength);
1932 if (!DeviceNode->ServiceName.Buffer)
1933 return STATUS_SUCCESS;
1934
1935 RtlCopyUnicodeString(&DeviceNode->ServiceName, &ParentDeviceNode->ServiceName);
1936
1937 IopDeviceNodeSetFlag(DeviceNode, DNF_LEGACY_DRIVER);
1938 }
1939 else if (ClassGUID.Length != 0)
1940 {
1941 /* Device has a ClassGUID value, but no Service value.
1942 * Suppose it is using the NULL driver, so state the
1943 * device is started */
1944 DPRINT1("%wZ is using NULL driver\n", &DeviceNode->InstancePath);
1945 IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
1946 }
1947 else
1948 {
1949 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1950 }
1951 return STATUS_SUCCESS;
1952 }
1953
1954 DPRINT("Got Service %S\n", Service->Buffer);
1955 }
1956
1957 return STATUS_SUCCESS;
1958 }
1959
1960 /*
1961 * IopActionInitChildServices
1962 *
1963 * Initialize the service for all (direct) child nodes of a parent node
1964 *
1965 * Parameters
1966 * DeviceNode
1967 * Pointer to device node.
1968 * Context
1969 * Pointer to parent node to initialize child node services for.
1970 *
1971 * Remarks
1972 * If the driver image for a service is not loaded and initialized
1973 * it is done here too. We only return a status code indicating an
1974 * error (STATUS_UNSUCCESSFUL) when we reach a device node which is
1975 * not a direct child of the device node for which we initialize
1976 * child services for. Any errors that occur is logged instead so
1977 * that all child services have a chance of being initialized.
1978 */
1979
1980 NTSTATUS
1981 IopActionInitChildServices(PDEVICE_NODE DeviceNode,
1982 PVOID Context)
1983 {
1984 PDEVICE_NODE ParentDeviceNode;
1985 NTSTATUS Status;
1986 BOOLEAN BootDrivers = !PnpSystemInit;
1987
1988 DPRINT("IopActionInitChildServices(%p, %p)\n", DeviceNode, Context);
1989
1990 ParentDeviceNode = (PDEVICE_NODE)Context;
1991
1992 /*
1993 * We are called for the parent too, but we don't need to do special
1994 * handling for this node
1995 */
1996 if (DeviceNode == ParentDeviceNode)
1997 {
1998 DPRINT("Success\n");
1999 return STATUS_SUCCESS;
2000 }
2001
2002 /*
2003 * Make sure this device node is a direct child of the parent device node
2004 * that is given as an argument
2005 */
2006 #if 0
2007 if (DeviceNode->Parent != ParentDeviceNode)
2008 {
2009 /*
2010 * Stop the traversal immediately and indicate unsuccessful operation
2011 */
2012 DPRINT("Stop\n");
2013 return STATUS_UNSUCCESSFUL;
2014 }
2015 #endif
2016
2017 if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED) &&
2018 !IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) &&
2019 !IopDeviceNodeHasFlag(DeviceNode, DNF_STARTED))
2020 {
2021 PLDR_DATA_TABLE_ENTRY ModuleObject;
2022 PDRIVER_OBJECT DriverObject;
2023
2024 /* Get existing DriverObject pointer (in case the driver has
2025 already been loaded and initialized) */
2026 Status = IopGetDriverObject(
2027 &DriverObject,
2028 &DeviceNode->ServiceName,
2029 FALSE);
2030
2031 if (!NT_SUCCESS(Status))
2032 {
2033 /* Driver is not initialized, try to load it */
2034 Status = IopLoadServiceModule(&DeviceNode->ServiceName, &ModuleObject);
2035
2036 if (NT_SUCCESS(Status) || Status == STATUS_IMAGE_ALREADY_LOADED)
2037 {
2038 /* STATUS_IMAGE_ALREADY_LOADED means this driver
2039 was loaded by the bootloader */
2040 if ((Status != STATUS_IMAGE_ALREADY_LOADED) ||
2041 (Status == STATUS_IMAGE_ALREADY_LOADED && !DriverObject))
2042 {
2043 /* Initialize the driver */
2044 Status = IopInitializeDriverModule(DeviceNode, ModuleObject,
2045 &DeviceNode->ServiceName, FALSE, &DriverObject);
2046 }
2047 else
2048 {
2049 Status = STATUS_SUCCESS;
2050 }
2051 }
2052 else
2053 {
2054 DPRINT1("IopLoadServiceModule(%wZ) failed with status 0x%08x\n",
2055 &DeviceNode->ServiceName, Status);
2056 }
2057 }
2058
2059 /* Driver is loaded and initialized at this point */
2060 if (NT_SUCCESS(Status))
2061 {
2062 /* Attach lower level filter drivers. */
2063 IopAttachFilterDrivers(DeviceNode, TRUE);
2064 /* Initialize the function driver for the device node */
2065 Status = IopInitializeDevice(DeviceNode, DriverObject);
2066
2067 if (NT_SUCCESS(Status))
2068 {
2069 /* Attach upper level filter drivers. */
2070 IopAttachFilterDrivers(DeviceNode, FALSE);
2071 IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
2072
2073 Status = IopStartDevice(DeviceNode);
2074 }
2075 else
2076 {
2077 DPRINT1("IopInitializeDevice(%wZ) failed with status 0x%08x\n",
2078 &DeviceNode->InstancePath, Status);
2079 }
2080 }
2081 else
2082 {
2083 /*
2084 * Don't disable when trying to load only boot drivers
2085 */
2086 if (!BootDrivers)
2087 {
2088 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
2089 IopDeviceNodeSetFlag(DeviceNode, DNF_START_FAILED);
2090 /* FIXME: Log the error (possibly in IopInitializeDeviceNodeService) */
2091 DPRINT1("Initialization of service %S failed (Status %x)\n",
2092 DeviceNode->ServiceName.Buffer, Status);
2093 }
2094 }
2095 }
2096 else
2097 {
2098 DPRINT("Device %wZ is disabled or already initialized\n",
2099 &DeviceNode->InstancePath);
2100 }
2101
2102 return STATUS_SUCCESS;
2103 }
2104
2105 /*
2106 * IopInitializePnpServices
2107 *
2108 * Initialize services for discovered children
2109 *
2110 * Parameters
2111 * DeviceNode
2112 * Top device node to start initializing services.
2113 *
2114 * Return Value
2115 * Status
2116 */
2117 NTSTATUS
2118 IopInitializePnpServices(IN PDEVICE_NODE DeviceNode)
2119 {
2120 DEVICETREE_TRAVERSE_CONTEXT Context;
2121
2122 DPRINT("IopInitializePnpServices(%p)\n", DeviceNode);
2123
2124 IopInitDeviceTreeTraverseContext(
2125 &Context,
2126 DeviceNode,
2127 IopActionInitChildServices,
2128 DeviceNode);
2129
2130 return IopTraverseDeviceTree(&Context);
2131 }
2132
2133 static NTSTATUS INIT_FUNCTION
2134 IopEnumerateDetectedDevices(
2135 IN HANDLE hBaseKey,
2136 IN PUNICODE_STRING RelativePath OPTIONAL,
2137 IN HANDLE hRootKey,
2138 IN BOOLEAN EnumerateSubKeys,
2139 IN PCM_FULL_RESOURCE_DESCRIPTOR ParentBootResources,
2140 IN ULONG ParentBootResourcesLength)
2141 {
2142 UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
2143 UNICODE_STRING DeviceDescU = RTL_CONSTANT_STRING(L"DeviceDesc");
2144 UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
2145 UNICODE_STRING ConfigurationDataU = RTL_CONSTANT_STRING(L"Configuration Data");
2146 UNICODE_STRING BootConfigU = RTL_CONSTANT_STRING(L"BootConfig");
2147 UNICODE_STRING LogConfU = RTL_CONSTANT_STRING(L"LogConf");
2148 OBJECT_ATTRIBUTES ObjectAttributes;
2149 HANDLE hDevicesKey = NULL;
2150 HANDLE hDeviceKey = NULL;
2151 HANDLE hLevel1Key, hLevel2Key = NULL, hLogConf;
2152 UNICODE_STRING Level2NameU;
2153 WCHAR Level2Name[5];
2154 ULONG IndexDevice = 0;
2155 ULONG IndexSubKey;
2156 PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
2157 ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
2158 PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
2159 ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
2160 UNICODE_STRING DeviceName, ValueName;
2161 ULONG RequiredSize;
2162 PCM_FULL_RESOURCE_DESCRIPTOR BootResources = NULL;
2163 ULONG BootResourcesLength;
2164 NTSTATUS Status;
2165
2166 const UNICODE_STRING IdentifierPci = RTL_CONSTANT_STRING(L"PCI");
2167 UNICODE_STRING HardwareIdPci = RTL_CONSTANT_STRING(L"*PNP0A03\0");
2168 static ULONG DeviceIndexPci = 0;
2169 #ifdef ENABLE_ACPI
2170 const UNICODE_STRING IdentifierAcpi = RTL_CONSTANT_STRING(L"ACPI BIOS");
2171 UNICODE_STRING HardwareIdAcpi = RTL_CONSTANT_STRING(L"*PNP0C08\0");
2172 static ULONG DeviceIndexAcpi = 0;
2173 #endif
2174 const UNICODE_STRING IdentifierSerial = RTL_CONSTANT_STRING(L"SerialController");
2175 UNICODE_STRING HardwareIdSerial = RTL_CONSTANT_STRING(L"*PNP0501\0");
2176 static ULONG DeviceIndexSerial = 0;
2177 const UNICODE_STRING IdentifierKeyboard = RTL_CONSTANT_STRING(L"KeyboardController");
2178 UNICODE_STRING HardwareIdKeyboard = RTL_CONSTANT_STRING(L"*PNP0303\0");
2179 static ULONG DeviceIndexKeyboard = 0;
2180 const UNICODE_STRING IdentifierMouse = RTL_CONSTANT_STRING(L"PointerController");
2181 UNICODE_STRING HardwareIdMouse = RTL_CONSTANT_STRING(L"*PNP0F13\0");
2182 static ULONG DeviceIndexMouse = 0;
2183 const UNICODE_STRING IdentifierParallel = RTL_CONSTANT_STRING(L"PARALLEL");
2184 UNICODE_STRING HardwareIdParallel = RTL_CONSTANT_STRING(L"*PNP0400\0");
2185 static ULONG DeviceIndexParallel = 0;
2186 const UNICODE_STRING IdentifierFloppy = RTL_CONSTANT_STRING(L"FLOPPY");
2187 UNICODE_STRING HardwareIdFloppy = RTL_CONSTANT_STRING(L"*PNP0700\0");
2188 static ULONG DeviceIndexFloppy = 0;
2189 const UNICODE_STRING IdentifierIsa = RTL_CONSTANT_STRING(L"ISA");
2190 UNICODE_STRING HardwareIdIsa = RTL_CONSTANT_STRING(L"*PNP0A00\0");
2191 static ULONG DeviceIndexIsa = 0;
2192 UNICODE_STRING HardwareIdKey;
2193 PUNICODE_STRING pHardwareId;
2194 ULONG DeviceIndex = 0;
2195 BOOLEAN IsDeviceDesc;
2196
2197 if (RelativePath)
2198 {
2199 Status = IopOpenRegistryKeyEx(&hDevicesKey, hBaseKey, RelativePath, KEY_ENUMERATE_SUB_KEYS);
2200 if (!NT_SUCCESS(Status))
2201 {
2202 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2203 goto cleanup;
2204 }
2205 }
2206 else
2207 hDevicesKey = hBaseKey;
2208
2209 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2210 if (!pDeviceInformation)
2211 {
2212 DPRINT("ExAllocatePool() failed\n");
2213 Status = STATUS_NO_MEMORY;
2214 goto cleanup;
2215 }
2216
2217 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2218 if (!pValueInformation)
2219 {
2220 DPRINT("ExAllocatePool() failed\n");
2221 Status = STATUS_NO_MEMORY;
2222 goto cleanup;
2223 }
2224
2225 while (TRUE)
2226 {
2227 Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2228 if (Status == STATUS_NO_MORE_ENTRIES)
2229 break;
2230 else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2231 {
2232 ExFreePool(pDeviceInformation);
2233 DeviceInfoLength = RequiredSize;
2234 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2235 if (!pDeviceInformation)
2236 {
2237 DPRINT("ExAllocatePool() failed\n");
2238 Status = STATUS_NO_MEMORY;
2239 goto cleanup;
2240 }
2241 Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2242 }
2243 if (!NT_SUCCESS(Status))
2244 {
2245 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2246 goto cleanup;
2247 }
2248 IndexDevice++;
2249
2250 /* Open device key */
2251 DeviceName.Length = DeviceName.MaximumLength = (USHORT)pDeviceInformation->NameLength;
2252 DeviceName.Buffer = pDeviceInformation->Name;
2253
2254 Status = IopOpenRegistryKeyEx(&hDeviceKey, hDevicesKey, &DeviceName,
2255 KEY_QUERY_VALUE + (EnumerateSubKeys ? KEY_ENUMERATE_SUB_KEYS : 0));
2256 if (!NT_SUCCESS(Status))
2257 {
2258 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2259 goto cleanup;
2260 }
2261
2262 /* Read boot resources, and add then to parent ones */
2263 Status = ZwQueryValueKey(hDeviceKey, &ConfigurationDataU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2264 if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2265 {
2266 ExFreePool(pValueInformation);
2267 ValueInfoLength = RequiredSize;
2268 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2269 if (!pValueInformation)
2270 {
2271 DPRINT("ExAllocatePool() failed\n");
2272 ZwDeleteKey(hLevel2Key);
2273 Status = STATUS_NO_MEMORY;
2274 goto cleanup;
2275 }
2276 Status = ZwQueryValueKey(hDeviceKey, &ConfigurationDataU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2277 }
2278 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
2279 {
2280 BootResources = ParentBootResources;
2281 BootResourcesLength = ParentBootResourcesLength;
2282 }
2283 else if (!NT_SUCCESS(Status))
2284 {
2285 DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2286 goto nextdevice;
2287 }
2288 else if (pValueInformation->Type != REG_FULL_RESOURCE_DESCRIPTOR)
2289 {
2290 DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_FULL_RESOURCE_DESCRIPTOR);
2291 goto nextdevice;
2292 }
2293 else
2294 {
2295 static const ULONG Header = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList.PartialDescriptors);
2296
2297 /* Concatenate current resources and parent ones */
2298 if (ParentBootResourcesLength == 0)
2299 BootResourcesLength = pValueInformation->DataLength;
2300 else
2301 BootResourcesLength = ParentBootResourcesLength
2302 + pValueInformation->DataLength
2303 - Header;
2304 BootResources = ExAllocatePool(PagedPool, BootResourcesLength);
2305 if (!BootResources)
2306 {
2307 DPRINT("ExAllocatePool() failed\n");
2308 goto nextdevice;
2309 }
2310 if (ParentBootResourcesLength == 0)
2311 {
2312 RtlCopyMemory(BootResources, pValueInformation->Data, pValueInformation->DataLength);
2313 }
2314 else if (ParentBootResources->PartialResourceList.PartialDescriptors[ParentBootResources->PartialResourceList.Count - 1].Type == CmResourceTypeDeviceSpecific)
2315 {
2316 RtlCopyMemory(BootResources, pValueInformation->Data, pValueInformation->DataLength);
2317 RtlCopyMemory(
2318 (PVOID)((ULONG_PTR)BootResources + pValueInformation->DataLength),
2319 (PVOID)((ULONG_PTR)ParentBootResources + Header),
2320 ParentBootResourcesLength - Header);
2321 BootResources->PartialResourceList.Count += ParentBootResources->PartialResourceList.Count;
2322 }
2323 else
2324 {
2325 RtlCopyMemory(BootResources, pValueInformation->Data, Header);
2326 RtlCopyMemory(
2327 (PVOID)((ULONG_PTR)BootResources + Header),
2328 (PVOID)((ULONG_PTR)ParentBootResources + Header),
2329 ParentBootResourcesLength - Header);
2330 RtlCopyMemory(
2331 (PVOID)((ULONG_PTR)BootResources + ParentBootResourcesLength),
2332 pValueInformation->Data + Header,
2333 pValueInformation->DataLength - Header);
2334 BootResources->PartialResourceList.Count += ParentBootResources->PartialResourceList.Count;
2335 }
2336 }
2337
2338 if (EnumerateSubKeys)
2339 {
2340 IndexSubKey = 0;
2341 while (TRUE)
2342 {
2343 Status = ZwEnumerateKey(hDeviceKey, IndexSubKey, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2344 if (Status == STATUS_NO_MORE_ENTRIES)
2345 break;
2346 else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2347 {
2348 ExFreePool(pDeviceInformation);
2349 DeviceInfoLength = RequiredSize;
2350 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2351 if (!pDeviceInformation)
2352 {
2353 DPRINT("ExAllocatePool() failed\n");
2354 Status = STATUS_NO_MEMORY;
2355 goto cleanup;
2356 }
2357 Status = ZwEnumerateKey(hDeviceKey, IndexSubKey, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2358 }
2359 if (!NT_SUCCESS(Status))
2360 {
2361 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2362 goto cleanup;
2363 }
2364 IndexSubKey++;
2365 DeviceName.Length = DeviceName.MaximumLength = (USHORT)pDeviceInformation->NameLength;
2366 DeviceName.Buffer = pDeviceInformation->Name;
2367
2368 Status = IopEnumerateDetectedDevices(
2369 hDeviceKey,
2370 &DeviceName,
2371 hRootKey,
2372 TRUE,
2373 BootResources,
2374 BootResourcesLength);
2375 if (!NT_SUCCESS(Status))
2376 goto cleanup;
2377 }
2378 }
2379
2380 /* Read identifier */
2381 Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2382 if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2383 {
2384 ExFreePool(pValueInformation);
2385 ValueInfoLength = RequiredSize;
2386 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2387 if (!pValueInformation)
2388 {
2389 DPRINT("ExAllocatePool() failed\n");
2390 Status = STATUS_NO_MEMORY;
2391 goto cleanup;
2392 }
2393 Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2394 }
2395 if (!NT_SUCCESS(Status))
2396 {
2397 if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
2398 {
2399 DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2400 goto nextdevice;
2401 }
2402 ValueName.Length = ValueName.MaximumLength = 0;
2403 }
2404 else if (pValueInformation->Type != REG_SZ)
2405 {
2406 DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
2407 goto nextdevice;
2408 }
2409 else
2410 {
2411 /* Assign hardware id to this device */
2412 ValueName.Length = ValueName.MaximumLength = (USHORT)pValueInformation->DataLength;
2413 ValueName.Buffer = (PWCHAR)pValueInformation->Data;
2414 if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
2415 ValueName.Length -= sizeof(WCHAR);
2416 }
2417
2418 if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierSerial, FALSE) == 0)
2419 {
2420 pHardwareId = &HardwareIdSerial;
2421 DeviceIndex = DeviceIndexSerial++;
2422 IsDeviceDesc = TRUE;
2423 }
2424 else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierKeyboard, FALSE) == 0)
2425 {
2426 pHardwareId = &HardwareIdKeyboard;
2427 DeviceIndex = DeviceIndexKeyboard++;
2428 IsDeviceDesc = FALSE;
2429 }
2430 else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierMouse, FALSE) == 0)
2431 {
2432 pHardwareId = &HardwareIdMouse;
2433 DeviceIndex = DeviceIndexMouse++;
2434 IsDeviceDesc = FALSE;
2435 }
2436 else if (NT_SUCCESS(Status))
2437 {
2438 /* Try to also match the device identifier */
2439 if (RtlCompareUnicodeString(&ValueName, &IdentifierPci, FALSE) == 0)
2440 {
2441 pHardwareId = &HardwareIdPci;
2442 DeviceIndex = DeviceIndexPci++;
2443 IsDeviceDesc = FALSE;
2444 }
2445 else if (RtlCompareUnicodeString(&ValueName, &IdentifierIsa, FALSE) == 0)
2446 {
2447 pHardwareId = &HardwareIdIsa;
2448 DeviceIndex = DeviceIndexIsa++;
2449 IsDeviceDesc = FALSE;
2450 }
2451 #ifdef ENABLE_ACPI
2452 else if (RtlCompareUnicodeString(&ValueName, &IdentifierAcpi, FALSE) == 0)
2453 {
2454 pHardwareId = &HardwareIdAcpi;
2455 DeviceIndex = DeviceIndexAcpi++;
2456 IsDeviceDesc = FALSE;
2457 }
2458 #endif
2459 else /* Now let's detect devices with a device number at the end */
2460 {
2461 /* First, we remove the number */
2462 ValueName.Length -= sizeof(WCHAR);
2463
2464 /* Let's see if it is a floppy device */
2465 if (RtlCompareUnicodeString(&ValueName, &IdentifierFloppy, FALSE) == 0)
2466 {
2467 pHardwareId = &HardwareIdFloppy;
2468 DeviceIndex = DeviceIndexFloppy++;
2469 IsDeviceDesc = FALSE;
2470 }
2471 /* Nope, is it a parallel port? */
2472 else if (RtlCompareUnicodeString(&ValueName, &IdentifierParallel, FALSE) == 0)
2473 {
2474 pHardwareId = &HardwareIdParallel;
2475 DeviceIndex = DeviceIndexParallel++;
2476 IsDeviceDesc = FALSE;
2477 }
2478 /* Nope, out of ideas so let's skip this one */
2479 else
2480 {
2481 ValueName.Length += sizeof(WCHAR);
2482 DPRINT("Unknown device '%wZ'\n", &ValueName);
2483 goto nextdevice;
2484 }
2485
2486 /* Add the number back */
2487 ValueName.Length += sizeof(WCHAR);
2488 }
2489 }
2490 else
2491 {
2492 /* Unknown key path */
2493 DPRINT("Unknown key path '%wZ'\n", RelativePath);
2494 goto nextdevice;
2495 }
2496
2497 /* Prepare hardware id key (hardware id value without final \0) */
2498 HardwareIdKey = *pHardwareId;
2499 HardwareIdKey.Length -= sizeof(UNICODE_NULL);
2500
2501 /* Add the detected device to Root key */
2502 InitializeObjectAttributes(&ObjectAttributes, &HardwareIdKey, OBJ_KERNEL_HANDLE, hRootKey, NULL);
2503 Status = ZwCreateKey(
2504 &hLevel1Key,
2505 KEY_CREATE_SUB_KEY,
2506 &ObjectAttributes,
2507 0,
2508 NULL,
2509 REG_OPTION_NON_VOLATILE,
2510 NULL);
2511 if (!NT_SUCCESS(Status))
2512 {
2513 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2514 goto nextdevice;
2515 }
2516 swprintf(Level2Name, L"%04lu", DeviceIndex);
2517 RtlInitUnicodeString(&Level2NameU, Level2Name);
2518 InitializeObjectAttributes(&ObjectAttributes, &Level2NameU, OBJ_KERNEL_HANDLE, hLevel1Key, NULL);
2519 Status = ZwCreateKey(
2520 &hLevel2Key,
2521 KEY_SET_VALUE | KEY_CREATE_SUB_KEY,
2522 &ObjectAttributes,
2523 0,
2524 NULL,
2525 REG_OPTION_NON_VOLATILE,
2526 NULL);
2527 ZwClose(hLevel1Key);
2528 if (!NT_SUCCESS(Status))
2529 {
2530 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2531 goto nextdevice;
2532 }
2533 DPRINT("Found %wZ #%lu (%wZ)\n", &ValueName, DeviceIndex, &HardwareIdKey);
2534 if (IsDeviceDesc)
2535 {
2536 Status = ZwSetValueKey(hLevel2Key, &DeviceDescU, 0, REG_SZ, ValueName.Buffer, ValueName.MaximumLength);
2537 if (!NT_SUCCESS(Status))
2538 {
2539 DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2540 ZwDeleteKey(hLevel2Key);
2541 goto nextdevice;
2542 }
2543 }
2544 Status = ZwSetValueKey(hLevel2Key, &HardwareIDU, 0, REG_MULTI_SZ, pHardwareId->Buffer, pHardwareId->MaximumLength);
2545 if (!NT_SUCCESS(Status))
2546 {
2547 DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2548 ZwDeleteKey(hLevel2Key);
2549 goto nextdevice;
2550 }
2551 /* Create 'LogConf' subkey */
2552 InitializeObjectAttributes(&ObjectAttributes, &LogConfU, OBJ_KERNEL_HANDLE, hLevel2Key, NULL);
2553 Status = ZwCreateKey(
2554 &hLogConf,
2555 KEY_SET_VALUE,
2556 &ObjectAttributes,
2557 0,
2558 NULL,
2559 REG_OPTION_VOLATILE,
2560 NULL);
2561 if (!NT_SUCCESS(Status))
2562 {
2563 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2564 ZwDeleteKey(hLevel2Key);
2565 goto nextdevice;
2566 }
2567 if (BootResourcesLength > 0)
2568 {
2569 /* Save boot resources to 'LogConf\BootConfig' */
2570 Status = ZwSetValueKey(hLogConf, &BootConfigU, 0, REG_FULL_RESOURCE_DESCRIPTOR, BootResources, BootResourcesLength);
2571 if (!NT_SUCCESS(Status))
2572 {
2573 DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2574 ZwClose(hLogConf);
2575 ZwDeleteKey(hLevel2Key);
2576 goto nextdevice;
2577 }
2578 }
2579 ZwClose(hLogConf);
2580
2581 nextdevice:
2582 if (BootResources && BootResources != ParentBootResources)
2583 ExFreePool(BootResources);
2584 if (hLevel2Key)
2585 {
2586 ZwClose(hLevel2Key);
2587 hLevel2Key = NULL;
2588 }
2589 if (hDeviceKey)
2590 {
2591 ZwClose(hDeviceKey);
2592 hDeviceKey = NULL;
2593 }
2594 }
2595
2596 Status = STATUS_SUCCESS;
2597
2598 cleanup:
2599 if (hDevicesKey && hDevicesKey != hBaseKey)
2600 ZwClose(hDevicesKey);
2601 if (hDeviceKey)
2602 ZwClose(hDeviceKey);
2603 if (pDeviceInformation)
2604 ExFreePool(pDeviceInformation);
2605 if (pValueInformation)
2606 ExFreePool(pValueInformation);
2607 return Status;
2608 }
2609
2610 static BOOLEAN INIT_FUNCTION
2611 IopIsAcpiComputer(VOID)
2612 {
2613 #ifndef ENABLE_ACPI
2614 return FALSE;
2615 #else
2616 UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
2617 UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
2618 UNICODE_STRING AcpiBiosIdentifier = RTL_CONSTANT_STRING(L"ACPI BIOS");
2619 OBJECT_ATTRIBUTES ObjectAttributes;
2620 PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
2621 ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
2622 PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
2623 ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
2624 ULONG RequiredSize;
2625 ULONG IndexDevice = 0;
2626 UNICODE_STRING DeviceName, ValueName;
2627 HANDLE hDevicesKey = NULL;
2628 HANDLE hDeviceKey = NULL;
2629 NTSTATUS Status;
2630 BOOLEAN ret = FALSE;
2631
2632 InitializeObjectAttributes(&ObjectAttributes, &MultiKeyPathU, OBJ_KERNEL_HANDLE, NULL, NULL);
2633 Status = ZwOpenKey(&hDevicesKey, KEY_ENUMERATE_SUB_KEYS, &ObjectAttributes);
2634 if (!NT_SUCCESS(Status))
2635 {
2636 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2637 goto cleanup;
2638 }
2639
2640 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2641 if (!pDeviceInformation)
2642 {
2643 DPRINT("ExAllocatePool() failed\n");
2644 Status = STATUS_NO_MEMORY;
2645 goto cleanup;
2646 }
2647
2648 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2649 if (!pDeviceInformation)
2650 {
2651 DPRINT("ExAllocatePool() failed\n");
2652 Status = STATUS_NO_MEMORY;
2653 goto cleanup;
2654 }
2655
2656 while (TRUE)
2657 {
2658 Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2659 if (Status == STATUS_NO_MORE_ENTRIES)
2660 break;
2661 else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2662 {
2663 ExFreePool(pDeviceInformation);
2664 DeviceInfoLength = RequiredSize;
2665 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2666 if (!pDeviceInformation)
2667 {
2668 DPRINT("ExAllocatePool() failed\n");
2669 Status = STATUS_NO_MEMORY;
2670 goto cleanup;
2671 }
2672 Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2673 }
2674 if (!NT_SUCCESS(Status))
2675 {
2676 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2677 goto cleanup;
2678 }
2679 IndexDevice++;
2680
2681 /* Open device key */
2682 DeviceName.Length = DeviceName.MaximumLength = pDeviceInformation->NameLength;
2683 DeviceName.Buffer = pDeviceInformation->Name;
2684 InitializeObjectAttributes(&ObjectAttributes, &DeviceName, OBJ_KERNEL_HANDLE, hDevicesKey, NULL);
2685 Status = ZwOpenKey(
2686 &hDeviceKey,
2687 KEY_QUERY_VALUE,
2688 &ObjectAttributes);
2689 if (!NT_SUCCESS(Status))
2690 {
2691 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2692 goto cleanup;
2693 }
2694
2695 /* Read identifier */
2696 Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2697 if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2698 {
2699 ExFreePool(pValueInformation);
2700 ValueInfoLength = RequiredSize;
2701 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2702 if (!pValueInformation)
2703 {
2704 DPRINT("ExAllocatePool() failed\n");
2705 Status = STATUS_NO_MEMORY;
2706 goto cleanup;
2707 }
2708 Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2709 }
2710 if (!NT_SUCCESS(Status))
2711 {
2712 DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2713 goto nextdevice;
2714 }
2715 else if (pValueInformation->Type != REG_SZ)
2716 {
2717 DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
2718 goto nextdevice;
2719 }
2720
2721 ValueName.Length = ValueName.MaximumLength = pValueInformation->DataLength;
2722 ValueName.Buffer = (PWCHAR)pValueInformation->Data;
2723 if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
2724 ValueName.Length -= sizeof(WCHAR);
2725 if (RtlCompareUnicodeString(&ValueName, &AcpiBiosIdentifier, FALSE) == 0)
2726 {
2727 DPRINT("Found ACPI BIOS\n");
2728 ret = TRUE;
2729 goto cleanup;
2730 }
2731
2732 nextdevice:
2733 ZwClose(hDeviceKey);
2734 hDeviceKey = NULL;
2735 }
2736
2737 cleanup:
2738 if (pDeviceInformation)
2739 ExFreePool(pDeviceInformation);
2740 if (pValueInformation)
2741 ExFreePool(pValueInformation);
2742 if (hDevicesKey)
2743 ZwClose(hDevicesKey);
2744 if (hDeviceKey)
2745 ZwClose(hDeviceKey);
2746 return ret;
2747 #endif
2748 }
2749
2750 static NTSTATUS INIT_FUNCTION
2751 IopUpdateRootKey(VOID)
2752 {
2753 UNICODE_STRING EnumU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Enum");
2754 UNICODE_STRING RootPathU = RTL_CONSTANT_STRING(L"Root");
2755 UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
2756 UNICODE_STRING DeviceDescU = RTL_CONSTANT_STRING(L"DeviceDesc");
2757 UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
2758 UNICODE_STRING LogConfU = RTL_CONSTANT_STRING(L"LogConf");
2759 UNICODE_STRING HalAcpiDevice = RTL_CONSTANT_STRING(L"ACPI_HAL");
2760 UNICODE_STRING HalAcpiId = RTL_CONSTANT_STRING(L"0000");
2761 UNICODE_STRING HalAcpiDeviceDesc = RTL_CONSTANT_STRING(L"HAL ACPI");
2762 UNICODE_STRING HalAcpiHardwareID = RTL_CONSTANT_STRING(L"*PNP0C08\0");
2763 OBJECT_ATTRIBUTES ObjectAttributes;
2764 HANDLE hEnum, hRoot, hHalAcpiDevice, hHalAcpiId, hLogConf;
2765 NTSTATUS Status;
2766
2767 InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
2768 Status = ZwCreateKey(&hEnum, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2769 if (!NT_SUCCESS(Status))
2770 {
2771 DPRINT1("ZwCreateKey() failed with status 0x%08lx\n", Status);
2772 return Status;
2773 }
2774
2775 InitializeObjectAttributes(&ObjectAttributes, &RootPathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hEnum, NULL);
2776 Status = ZwCreateKey(&hRoot, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2777 ZwClose(hEnum);
2778 if (!NT_SUCCESS(Status))
2779 {
2780 DPRINT1("ZwOpenKey() failed with status 0x%08lx\n", Status);
2781 return Status;
2782 }
2783
2784 if (IopIsAcpiComputer())
2785 {
2786 InitializeObjectAttributes(&ObjectAttributes, &HalAcpiDevice, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hRoot, NULL);
2787 Status = ZwCreateKey(&hHalAcpiDevice, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
2788 ZwClose(hRoot);
2789 if (!NT_SUCCESS(Status))
2790 return Status;
2791 InitializeObjectAttributes(&ObjectAttributes, &HalAcpiId, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hHalAcpiDevice, NULL);
2792 Status = ZwCreateKey(&hHalAcpiId, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
2793 ZwClose(hHalAcpiDevice);
2794 if (!NT_SUCCESS(Status))
2795 return Status;
2796 Status = ZwSetValueKey(hHalAcpiId, &DeviceDescU, 0, REG_SZ, HalAcpiDeviceDesc.Buffer, HalAcpiDeviceDesc.MaximumLength);
2797 if (NT_SUCCESS(Status))
2798 Status = ZwSetValueKey(hHalAcpiId, &HardwareIDU, 0, REG_MULTI_SZ, HalAcpiHardwareID.Buffer, HalAcpiHardwareID.MaximumLength);
2799 if (NT_SUCCESS(Status))
2800 {
2801 InitializeObjectAttributes(&ObjectAttributes, &LogConfU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hHalAcpiId, NULL);
2802 Status = ZwCreateKey(&hLogConf, 0, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
2803 if (NT_SUCCESS(Status))
2804 ZwClose(hLogConf);
2805 }
2806 ZwClose(hHalAcpiId);
2807 return Status;
2808 }
2809 else
2810 {
2811 Status = IopOpenRegistryKeyEx(&hEnum, NULL, &MultiKeyPathU, KEY_ENUMERATE_SUB_KEYS);
2812 if (!NT_SUCCESS(Status))
2813 {
2814 /* Nothing to do, don't return with an error status */
2815 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2816 ZwClose(hRoot);
2817 return STATUS_SUCCESS;
2818 }
2819 Status = IopEnumerateDetectedDevices(
2820 hEnum,
2821 NULL,
2822 hRoot,
2823 TRUE,
2824 NULL,
2825 0);
2826 ZwClose(hEnum);
2827 ZwClose(hRoot);
2828 return Status;
2829 }
2830 }
2831
2832 NTSTATUS
2833 NTAPI
2834 IopOpenRegistryKeyEx(PHANDLE KeyHandle,
2835 HANDLE ParentKey,
2836 PUNICODE_STRING Name,
2837 ACCESS_MASK DesiredAccess)
2838 {
2839 OBJECT_ATTRIBUTES ObjectAttributes;
2840 NTSTATUS Status;
2841
2842 PAGED_CODE();
2843
2844 *KeyHandle = NULL;
2845
2846 InitializeObjectAttributes(&ObjectAttributes,
2847 Name,
2848 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
2849 ParentKey,
2850 NULL);
2851
2852 Status = ZwOpenKey(KeyHandle, DesiredAccess, &ObjectAttributes);
2853
2854 return Status;
2855 }
2856
2857 NTSTATUS
2858 NTAPI
2859 IopGetRegistryValue(IN HANDLE Handle,
2860 IN PWSTR ValueName,
2861 OUT PKEY_VALUE_FULL_INFORMATION *Information)
2862 {
2863 UNICODE_STRING ValueString;
2864 NTSTATUS Status;
2865 PKEY_VALUE_FULL_INFORMATION FullInformation;
2866 ULONG Size;
2867 PAGED_CODE();
2868
2869 RtlInitUnicodeString(&ValueString, ValueName);
2870
2871 Status = ZwQueryValueKey(Handle,
2872 &ValueString,
2873 KeyValueFullInformation,
2874 NULL,
2875 0,
2876 &Size);
2877 if ((Status != STATUS_BUFFER_OVERFLOW) &&
2878 (Status != STATUS_BUFFER_TOO_SMALL))
2879 {
2880 return Status;
2881 }
2882
2883 FullInformation = ExAllocatePool(NonPagedPool, Size);
2884 if (!FullInformation) return STATUS_INSUFFICIENT_RESOURCES;
2885
2886 Status = ZwQueryValueKey(Handle,
2887 &ValueString,
2888 KeyValueFullInformation,
2889 FullInformation,
2890 Size,
2891 &Size);
2892 if (!NT_SUCCESS(Status))
2893 {
2894 ExFreePool(FullInformation);
2895 return Status;
2896 }
2897
2898 *Information = FullInformation;
2899 return STATUS_SUCCESS;
2900 }
2901
2902 static NTSTATUS INIT_FUNCTION
2903 NTAPI
2904 PnpDriverInitializeEmpty(IN struct _DRIVER_OBJECT *DriverObject, IN PUNICODE_STRING RegistryPath)
2905 {
2906 return STATUS_SUCCESS;
2907 }
2908
2909 VOID INIT_FUNCTION
2910 PnpInit(VOID)
2911 {
2912 PDEVICE_OBJECT Pdo;
2913 NTSTATUS Status;
2914
2915 DPRINT("PnpInit()\n");
2916
2917 KeInitializeSpinLock(&IopDeviceTreeLock);
2918 ExInitializeFastMutex(&IopBusTypeGuidListLock);
2919
2920 /* Initialize the Bus Type GUID List */
2921 IopBusTypeGuidList = ExAllocatePool(NonPagedPool, sizeof(IO_BUS_TYPE_GUID_LIST));
2922 if (!IopBusTypeGuidList) {
2923 DPRINT1("ExAllocatePool() failed\n");
2924 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
2925 }
2926
2927 RtlZeroMemory(IopBusTypeGuidList, sizeof(IO_BUS_TYPE_GUID_LIST));
2928 ExInitializeFastMutex(&IopBusTypeGuidList->Lock);
2929
2930 /* Initialize PnP-Event notification support */
2931 Status = IopInitPlugPlayEvents();
2932 if (!NT_SUCCESS(Status))
2933 {
2934 DPRINT1("IopInitPlugPlayEvents() failed\n");
2935 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2936 }
2937
2938 /*
2939 * Create root device node
2940 */
2941
2942 Status = IopCreateDriver(NULL, PnpDriverInitializeEmpty, NULL, 0, 0, &IopRootDriverObject);
2943 if (!NT_SUCCESS(Status))
2944 {
2945 DPRINT1("IoCreateDriverObject() failed\n");
2946 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2947 }
2948
2949 Status = IoCreateDevice(IopRootDriverObject, 0, NULL, FILE_DEVICE_CONTROLLER,
2950 0, FALSE, &Pdo);
2951 if (!NT_SUCCESS(Status))
2952 {
2953 DPRINT1("IoCreateDevice() failed\n");
2954 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2955 }
2956
2957 Status = IopCreateDeviceNode(NULL, Pdo, NULL, &IopRootDeviceNode);
2958 if (!NT_SUCCESS(Status))
2959 {
2960 DPRINT1("Insufficient resources\n");
2961 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2962 }
2963
2964 if (!RtlCreateUnicodeString(&IopRootDeviceNode->InstancePath,
2965 L"HTREE\\ROOT\\0"))
2966 {
2967 DPRINT1("Failed to create the instance path!\n");
2968 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
2969 }
2970
2971 /* Report the device to the user-mode pnp manager */
2972 IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
2973 &IopRootDeviceNode->InstancePath);
2974
2975 IopRootDeviceNode->PhysicalDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
2976 PnpRootDriverEntry(IopRootDriverObject, NULL);
2977 IopRootDeviceNode->PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
2978 IopRootDriverObject->DriverExtension->AddDevice(
2979 IopRootDriverObject,
2980 IopRootDeviceNode->PhysicalDeviceObject);
2981
2982 /* Move information about devices detected by Freeloader to SYSTEM\CurrentControlSet\Root\ */
2983 Status = IopUpdateRootKey();
2984 if (!NT_SUCCESS(Status))
2985 {
2986 DPRINT1("IopUpdateRootKey() failed\n");
2987 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2988 }
2989 }
2990
2991 RTL_GENERIC_COMPARE_RESULTS
2992 NTAPI
2993 PiCompareInstancePath(IN PRTL_AVL_TABLE Table,
2994 IN PVOID FirstStruct,
2995 IN PVOID SecondStruct)
2996 {
2997 /* FIXME: TODO */
2998 ASSERT(FALSE);
2999 return 0;
3000 }
3001
3002 //
3003 // The allocation function is called by the generic table package whenever
3004 // it needs to allocate memory for the table.
3005 //
3006
3007 PVOID
3008 NTAPI
3009 PiAllocateGenericTableEntry(IN PRTL_AVL_TABLE Table,
3010 IN CLONG ByteSize)
3011 {
3012 /* FIXME: TODO */
3013 ASSERT(FALSE);
3014 return NULL;
3015 }
3016
3017 VOID
3018 NTAPI
3019 PiFreeGenericTableEntry(IN PRTL_AVL_TABLE Table,
3020 IN PVOID Buffer)
3021 {
3022 /* FIXME: TODO */
3023 ASSERT(FALSE);
3024 }
3025
3026 VOID
3027 NTAPI
3028 PpInitializeDeviceReferenceTable(VOID)
3029 {
3030 /* Setup the guarded mutex and AVL table */
3031 KeInitializeGuardedMutex(&PpDeviceReferenceTableLock);
3032 RtlInitializeGenericTableAvl(
3033 &PpDeviceReferenceTable,
3034 (PRTL_AVL_COMPARE_ROUTINE)PiCompareInstancePath,
3035 (PRTL_AVL_ALLOCATE_ROUTINE)PiAllocateGenericTableEntry,
3036 (PRTL_AVL_FREE_ROUTINE)PiFreeGenericTableEntry,
3037 NULL);
3038 }
3039
3040 BOOLEAN
3041 NTAPI
3042 PiInitPhase0(VOID)
3043 {
3044 /* Initialize the resource when accessing device registry data */
3045 ExInitializeResourceLite(&PpRegistryDeviceResource);
3046
3047 /* Setup the device reference AVL table */
3048 PpInitializeDeviceReferenceTable();
3049 return TRUE;
3050 }
3051
3052 BOOLEAN
3053 NTAPI
3054 PpInitSystem(VOID)
3055 {
3056 /* Check the initialization phase */
3057 switch (ExpInitializationPhase)
3058 {
3059 case 0:
3060
3061 /* Do Phase 0 */
3062 return PiInitPhase0();
3063
3064 case 1:
3065
3066 /* Do Phase 1 */
3067 return TRUE;
3068 //return PiInitPhase1();
3069
3070 default:
3071
3072 /* Don't know any other phase! Bugcheck! */
3073 KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
3074 return FALSE;
3075 }
3076 }
3077
3078 /* PUBLIC FUNCTIONS **********************************************************/
3079
3080 /*
3081 * @unimplemented
3082 */
3083 NTSTATUS
3084 NTAPI
3085 IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
3086 IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
3087 IN ULONG BufferLength,
3088 OUT PVOID PropertyBuffer,
3089 OUT PULONG ResultLength)
3090 {
3091 PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
3092 DEVICE_CAPABILITIES DeviceCaps;
3093 ULONG Length;
3094 PVOID Data = NULL;
3095 PWSTR Ptr;
3096 NTSTATUS Status;
3097
3098 DPRINT("IoGetDeviceProperty(0x%p %d)\n", DeviceObject, DeviceProperty);
3099
3100 *ResultLength = 0;
3101
3102 if (DeviceNode == NULL)
3103 return STATUS_INVALID_DEVICE_REQUEST;
3104
3105 switch (DeviceProperty)
3106 {
3107 case DevicePropertyBusNumber:
3108 Length = sizeof(ULONG);
3109 Data = &DeviceNode->ChildBusNumber;
3110 break;
3111
3112 /* Complete, untested */
3113 case DevicePropertyBusTypeGuid:
3114 /* Sanity check */
3115 if ((DeviceNode->ChildBusTypeIndex != 0xFFFF) &&
3116 (DeviceNode->ChildBusTypeIndex < IopBusTypeGuidList->GuidCount))
3117 {
3118 /* Return the GUID */
3119 *ResultLength = sizeof(GUID);
3120
3121 /* Check if the buffer given was large enough */
3122 if (BufferLength < *ResultLength)
3123 {
3124 return STATUS_BUFFER_TOO_SMALL;
3125 }
3126
3127 /* Copy the GUID */
3128 RtlCopyMemory(PropertyBuffer,
3129 &(IopBusTypeGuidList->Guids[DeviceNode->ChildBusTypeIndex]),
3130 sizeof(GUID));
3131 return STATUS_SUCCESS;
3132 }
3133 else
3134 {
3135 return STATUS_OBJECT_NAME_NOT_FOUND;
3136 }
3137 break;
3138
3139 case DevicePropertyLegacyBusType:
3140 Length = sizeof(INTERFACE_TYPE);
3141 Data = &DeviceNode->ChildInterfaceType;
3142 break;
3143
3144 case DevicePropertyAddress:
3145 /* Query the device caps */
3146 Status = IopQueryDeviceCapabilities(DeviceNode, &DeviceCaps);
3147 if (NT_SUCCESS(Status) && (DeviceCaps.Address != MAXULONG))
3148 {
3149 /* Return length */
3150 *ResultLength = sizeof(ULONG);
3151
3152 /* Check if the buffer given was large enough */
3153 if (BufferLength < *ResultLength)
3154 {
3155 return STATUS_BUFFER_TOO_SMALL;
3156 }
3157
3158 /* Return address */
3159 *(PULONG)PropertyBuffer = DeviceCaps.Address;
3160 return STATUS_SUCCESS;
3161 }
3162 else
3163 {
3164 return STATUS_OBJECT_NAME_NOT_FOUND;
3165 }
3166 break;
3167
3168 // case DevicePropertyUINumber:
3169 // if (DeviceNode->CapabilityFlags == NULL)
3170 // return STATUS_INVALID_DEVICE_REQUEST;
3171 // Length = sizeof(ULONG);
3172 // Data = &DeviceNode->CapabilityFlags->UINumber;
3173 // break;
3174
3175 case DevicePropertyClassName:
3176 case DevicePropertyClassGuid:
3177 case DevicePropertyDriverKeyName:
3178 case DevicePropertyManufacturer:
3179 case DevicePropertyFriendlyName:
3180 case DevicePropertyHardwareID:
3181 case DevicePropertyCompatibleIDs:
3182 case DevicePropertyDeviceDescription:
3183 case DevicePropertyLocationInformation:
3184 case DevicePropertyUINumber:
3185 {
3186 LPCWSTR RegistryPropertyName;
3187 UNICODE_STRING EnumRoot = RTL_CONSTANT_STRING(ENUM_ROOT);
3188 UNICODE_STRING ValueName;
3189 KEY_VALUE_PARTIAL_INFORMATION *ValueInformation;
3190 ULONG ValueInformationLength;
3191 HANDLE KeyHandle, EnumRootHandle;
3192 NTSTATUS Status;
3193
3194 switch (DeviceProperty)
3195 {
3196 case DevicePropertyClassName:
3197 RegistryPropertyName = L"Class"; break;
3198 case DevicePropertyClassGuid:
3199 RegistryPropertyName = L"ClassGuid"; break;
3200 case DevicePropertyDriverKeyName:
3201 RegistryPropertyName = L"Driver"; break;
3202 case DevicePropertyManufacturer:
3203 RegistryPropertyName = L"Mfg"; break;
3204 case DevicePropertyFriendlyName:
3205 RegistryPropertyName = L"FriendlyName"; break;
3206 case DevicePropertyHardwareID:
3207 RegistryPropertyName = L"HardwareID"; break;
3208 case DevicePropertyCompatibleIDs:
3209 RegistryPropertyName = L"CompatibleIDs"; break;
3210 case DevicePropertyDeviceDescription:
3211 RegistryPropertyName = L"DeviceDesc"; break;
3212 case DevicePropertyLocationInformation:
3213 RegistryPropertyName = L"LocationInformation"; break;
3214 case DevicePropertyUINumber:
3215 RegistryPropertyName = L"UINumber"; break;
3216 default:
3217 /* Should not happen */
3218 ASSERT(FALSE);
3219 return STATUS_UNSUCCESSFUL;
3220 }
3221
3222 DPRINT("Registry property %S\n", RegistryPropertyName);
3223
3224 /* Open Enum key */
3225 Status = IopOpenRegistryKeyEx(&EnumRootHandle, NULL,
3226 &EnumRoot, KEY_READ);
3227 if (!NT_SUCCESS(Status))
3228 {
3229 DPRINT1("Error opening ENUM_ROOT, Status=0x%08x\n", Status);
3230 return Status;
3231 }
3232
3233 /* Open instance key */
3234 Status = IopOpenRegistryKeyEx(&KeyHandle, EnumRootHandle,
3235 &DeviceNode->InstancePath, KEY_READ);
3236 if (!NT_SUCCESS(Status))
3237 {
3238 DPRINT1("Error opening InstancePath, Status=0x%08x\n", Status);
3239 ZwClose(EnumRootHandle);
3240 return Status;
3241 }
3242
3243 /* Allocate buffer to read as much data as required by the caller */
3244 ValueInformationLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,
3245 Data[0]) + BufferLength;
3246 ValueInformation = ExAllocatePool(PagedPool, ValueInformationLength);
3247 if (!ValueInformation)
3248 {
3249 ZwClose(KeyHandle);
3250 return STATUS_INSUFFICIENT_RESOURCES;
3251 }
3252
3253 /* Read the value */
3254 RtlInitUnicodeString(&ValueName, RegistryPropertyName);
3255 Status = ZwQueryValueKey(KeyHandle, &ValueName,
3256 KeyValuePartialInformation, ValueInformation,
3257 ValueInformationLength,
3258 &ValueInformationLength);
3259 ZwClose(KeyHandle);
3260
3261 /* Return data */
3262 *ResultLength = ValueInformation->DataLength;
3263
3264 if (!NT_SUCCESS(Status))
3265 {
3266 ExFreePool(ValueInformation);
3267 if (Status == STATUS_BUFFER_OVERFLOW)
3268 return STATUS_BUFFER_TOO_SMALL;
3269 DPRINT1("Problem: Status=0x%08x, ResultLength = %d\n", Status, *ResultLength);
3270 return Status;
3271 }
3272
3273 /* FIXME: Verify the value (NULL-terminated, correct format). */
3274 RtlCopyMemory(PropertyBuffer, ValueInformation->Data,
3275 ValueInformation->DataLength);
3276 ExFreePool(ValueInformation);
3277
3278 return STATUS_SUCCESS;
3279 }
3280
3281 case DevicePropertyBootConfiguration:
3282 Length = 0;
3283 if (DeviceNode->BootResources->Count != 0)
3284 {
3285 Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
3286 }
3287 Data = DeviceNode->BootResources;
3288 break;
3289
3290 /* FIXME: use a translated boot configuration instead */
3291 case DevicePropertyBootConfigurationTranslated:
3292 Length = 0;
3293 if (DeviceNode->BootResources->Count != 0)
3294 {
3295 Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
3296 }
3297 Data = DeviceNode->BootResources;
3298 break;
3299
3300 case DevicePropertyEnumeratorName:
3301 /* A buffer overflow can't happen here, since InstancePath
3302 * always contains the enumerator name followed by \\ */
3303 Ptr = wcschr(DeviceNode->InstancePath.Buffer, L'\\');
3304 ASSERT(Ptr);
3305 Length = (Ptr - DeviceNode->InstancePath.Buffer) * sizeof(WCHAR);
3306 Data = DeviceNode->InstancePath.Buffer;
3307 break;
3308
3309 case DevicePropertyPhysicalDeviceObjectName:
3310 /* InstancePath buffer is NULL terminated, so we can do this */
3311 Length = DeviceNode->InstancePath.MaximumLength;
3312 Data = DeviceNode->InstancePath.Buffer;
3313 break;
3314
3315 default:
3316 return STATUS_INVALID_PARAMETER_2;
3317 }
3318
3319 /* Prepare returned values */
3320 *ResultLength = Length;