projects / reactos.git / blob
? search:


890fd60d12aa75f466d7a960f8f083530b3cd0b7
[reactos.git] / reactos / 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
1851 DPRINT("IopActionConfigureChildServices(%p, %p)\n", DeviceNode, Context);
1852
1853 ParentDeviceNode = (PDEVICE_NODE)Context;
1854
1855 /*
1856 * We are called for the parent too, but we don't need to do special
1857 * handling for this node
1858 */
1859 if (DeviceNode == ParentDeviceNode)
1860 {
1861 DPRINT("Success\n");
1862 return STATUS_SUCCESS;
1863 }
1864
1865 /*
1866 * Make sure this device node is a direct child of the parent device node
1867 * that is given as an argument
1868 */
1869 if (DeviceNode->Parent != ParentDeviceNode)
1870 {
1871 /* Stop the traversal immediately and indicate successful operation */
1872 DPRINT("Stop\n");
1873 return STATUS_UNSUCCESSFUL;
1874 }
1875
1876 if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED))
1877 {
1878 WCHAR RegKeyBuffer[MAX_PATH];
1879 UNICODE_STRING RegKey;
1880
1881 RegKey.Length = 0;
1882 RegKey.MaximumLength = sizeof(RegKeyBuffer);
1883 RegKey.Buffer = RegKeyBuffer;
1884
1885 /*
1886 * Retrieve configuration from Enum key
1887 */
1888
1889 Service = &DeviceNode->ServiceName;
1890
1891 RtlZeroMemory(QueryTable, sizeof(QueryTable));
1892 RtlInitUnicodeString(Service, NULL);
1893 RtlInitUnicodeString(&ClassGUID, NULL);
1894
1895 QueryTable[0].Name = L"Service";
1896 QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
1897 QueryTable[0].EntryContext = Service;
1898
1899 QueryTable[1].Name = L"ClassGUID";
1900 QueryTable[1].Flags = RTL_QUERY_REGISTRY_DIRECT;
1901 QueryTable[1].EntryContext = &ClassGUID;
1902 QueryTable[1].DefaultType = REG_SZ;
1903 QueryTable[1].DefaultData = L"";
1904 QueryTable[1].DefaultLength = 0;
1905
1906 RtlAppendUnicodeToString(&RegKey, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
1907 RtlAppendUnicodeStringToString(&RegKey, &DeviceNode->InstancePath);
1908
1909 Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
1910 RegKey.Buffer, QueryTable, NULL, NULL);
1911
1912 if (!NT_SUCCESS(Status))
1913 {
1914 /* FIXME: Log the error */
1915 DPRINT("Could not retrieve configuration for device %wZ (Status 0x%08x)\n",
1916 &DeviceNode->InstancePath, Status);
1917 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1918 return STATUS_SUCCESS;
1919 }
1920
1921 if (Service->Buffer == NULL)
1922 {
1923 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1924
1925 if (ClassGUID.Length != 0)
1926 {
1927 /* Device has a ClassGUID value, but no Service value.
1928 * Suppose it is using the NULL driver, so state the
1929 * device is started */
1930 DPRINT1("%wZ is using NULL driver\n", &DeviceNode->InstancePath);
1931 IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
1932 }
1933 return STATUS_SUCCESS;
1934 }
1935
1936 DPRINT("Got Service %S\n", Service->Buffer);
1937 }
1938
1939 return STATUS_SUCCESS;
1940 }
1941
1942 /*
1943 * IopActionInitChildServices
1944 *
1945 * Initialize the service for all (direct) child nodes of a parent node
1946 *
1947 * Parameters
1948 * DeviceNode
1949 * Pointer to device node.
1950 * Context
1951 * Pointer to parent node to initialize child node services for.
1952 *
1953 * Remarks
1954 * If the driver image for a service is not loaded and initialized
1955 * it is done here too. We only return a status code indicating an
1956 * error (STATUS_UNSUCCESSFUL) when we reach a device node which is
1957 * not a direct child of the device node for which we initialize
1958 * child services for. Any errors that occur is logged instead so
1959 * that all child services have a chance of being initialized.
1960 */
1961
1962 NTSTATUS
1963 IopActionInitChildServices(PDEVICE_NODE DeviceNode,
1964 PVOID Context)
1965 {
1966 PDEVICE_NODE ParentDeviceNode;
1967 NTSTATUS Status;
1968 BOOLEAN BootDrivers = !PnpSystemInit;
1969
1970 DPRINT("IopActionInitChildServices(%p, %p)\n", DeviceNode, Context);
1971
1972 ParentDeviceNode = (PDEVICE_NODE)Context;
1973
1974 /*
1975 * We are called for the parent too, but we don't need to do special
1976 * handling for this node
1977 */
1978 if (DeviceNode == ParentDeviceNode)
1979 {
1980 DPRINT("Success\n");
1981 return STATUS_SUCCESS;
1982 }
1983
1984 /*
1985 * Make sure this device node is a direct child of the parent device node
1986 * that is given as an argument
1987 */
1988 #if 0
1989 if (DeviceNode->Parent != ParentDeviceNode)
1990 {
1991 /*
1992 * Stop the traversal immediately and indicate unsuccessful operation
1993 */
1994 DPRINT("Stop\n");
1995 return STATUS_UNSUCCESSFUL;
1996 }
1997 #endif
1998
1999 if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED) &&
2000 !IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) &&
2001 !IopDeviceNodeHasFlag(DeviceNode, DNF_STARTED))
2002 {
2003 PLDR_DATA_TABLE_ENTRY ModuleObject;
2004 PDRIVER_OBJECT DriverObject;
2005
2006 /* Get existing DriverObject pointer (in case the driver has
2007 already been loaded and initialized) */
2008 Status = IopGetDriverObject(
2009 &DriverObject,
2010 &DeviceNode->ServiceName,
2011 FALSE);
2012
2013 if (!NT_SUCCESS(Status))
2014 {
2015 /* Driver is not initialized, try to load it */
2016 Status = IopLoadServiceModule(&DeviceNode->ServiceName, &ModuleObject);
2017
2018 if (NT_SUCCESS(Status) || Status == STATUS_IMAGE_ALREADY_LOADED)
2019 {
2020 /* STATUS_IMAGE_ALREADY_LOADED means this driver
2021 was loaded by the bootloader */
2022 if ((Status != STATUS_IMAGE_ALREADY_LOADED) ||
2023 (Status == STATUS_IMAGE_ALREADY_LOADED && !DriverObject))
2024 {
2025 /* Initialize the driver */
2026 Status = IopInitializeDriverModule(DeviceNode, ModuleObject,
2027 &DeviceNode->ServiceName, FALSE, &DriverObject);
2028 }
2029 else
2030 {
2031 Status = STATUS_SUCCESS;
2032 }
2033 }
2034 else
2035 {
2036 DPRINT1("IopLoadServiceModule(%wZ) failed with status 0x%08x\n",
2037 &DeviceNode->ServiceName, Status);
2038 }
2039 }
2040
2041 /* Driver is loaded and initialized at this point */
2042 if (NT_SUCCESS(Status))
2043 {
2044 /* Attach lower level filter drivers. */
2045 IopAttachFilterDrivers(DeviceNode, TRUE);
2046 /* Initialize the function driver for the device node */
2047 Status = IopInitializeDevice(DeviceNode, DriverObject);
2048
2049 if (NT_SUCCESS(Status))
2050 {
2051 /* Attach upper level filter drivers. */
2052 IopAttachFilterDrivers(DeviceNode, FALSE);
2053 IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
2054
2055 Status = IopStartDevice(DeviceNode);
2056 }
2057 else
2058 {
2059 DPRINT1("IopInitializeDevice(%wZ) failed with status 0x%08x\n",
2060 &DeviceNode->InstancePath, Status);
2061 }
2062 }
2063 else
2064 {
2065 /*
2066 * Don't disable when trying to load only boot drivers
2067 */
2068 if (!BootDrivers)
2069 {
2070 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
2071 IopDeviceNodeSetFlag(DeviceNode, DNF_START_FAILED);
2072 /* FIXME: Log the error (possibly in IopInitializeDeviceNodeService) */
2073 DPRINT1("Initialization of service %S failed (Status %x)\n",
2074 DeviceNode->ServiceName.Buffer, Status);
2075 }
2076 }
2077 }
2078 else
2079 {
2080 DPRINT("Device %wZ is disabled or already initialized\n",
2081 &DeviceNode->InstancePath);
2082 }
2083
2084 return STATUS_SUCCESS;
2085 }
2086
2087 /*
2088 * IopInitializePnpServices
2089 *
2090 * Initialize services for discovered children
2091 *
2092 * Parameters
2093 * DeviceNode
2094 * Top device node to start initializing services.
2095 *
2096 * Return Value
2097 * Status
2098 */
2099 NTSTATUS
2100 IopInitializePnpServices(IN PDEVICE_NODE DeviceNode)
2101 {
2102 DEVICETREE_TRAVERSE_CONTEXT Context;
2103
2104 DPRINT("IopInitializePnpServices(%p)\n", DeviceNode);
2105
2106 IopInitDeviceTreeTraverseContext(
2107 &Context,
2108 DeviceNode,
2109 IopActionInitChildServices,
2110 DeviceNode);
2111
2112 return IopTraverseDeviceTree(&Context);
2113 }
2114
2115 static NTSTATUS INIT_FUNCTION
2116 IopEnumerateDetectedDevices(
2117 IN HANDLE hBaseKey,
2118 IN PUNICODE_STRING RelativePath OPTIONAL,
2119 IN HANDLE hRootKey,
2120 IN BOOLEAN EnumerateSubKeys,
2121 IN PCM_FULL_RESOURCE_DESCRIPTOR ParentBootResources,
2122 IN ULONG ParentBootResourcesLength)
2123 {
2124 UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
2125 UNICODE_STRING DeviceDescU = RTL_CONSTANT_STRING(L"DeviceDesc");
2126 UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
2127 UNICODE_STRING ConfigurationDataU = RTL_CONSTANT_STRING(L"Configuration Data");
2128 UNICODE_STRING BootConfigU = RTL_CONSTANT_STRING(L"BootConfig");
2129 UNICODE_STRING LogConfU = RTL_CONSTANT_STRING(L"LogConf");
2130 OBJECT_ATTRIBUTES ObjectAttributes;
2131 HANDLE hDevicesKey = NULL;
2132 HANDLE hDeviceKey = NULL;
2133 HANDLE hLevel1Key, hLevel2Key = NULL, hLogConf;
2134 UNICODE_STRING Level2NameU;
2135 WCHAR Level2Name[5];
2136 ULONG IndexDevice = 0;
2137 ULONG IndexSubKey;
2138 PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
2139 ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
2140 PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
2141 ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
2142 UNICODE_STRING DeviceName, ValueName;
2143 ULONG RequiredSize;
2144 PCM_FULL_RESOURCE_DESCRIPTOR BootResources = NULL;
2145 ULONG BootResourcesLength;
2146 NTSTATUS Status;
2147
2148 const UNICODE_STRING IdentifierPci = RTL_CONSTANT_STRING(L"PCI");
2149 UNICODE_STRING HardwareIdPci = RTL_CONSTANT_STRING(L"*PNP0A03\0");
2150 static ULONG DeviceIndexPci = 0;
2151 #ifdef ENABLE_ACPI
2152 const UNICODE_STRING IdentifierAcpi = RTL_CONSTANT_STRING(L"ACPI BIOS");
2153 UNICODE_STRING HardwareIdAcpi = RTL_CONSTANT_STRING(L"*PNP0C08\0");
2154 static ULONG DeviceIndexAcpi = 0;
2155 #endif
2156 const UNICODE_STRING IdentifierSerial = RTL_CONSTANT_STRING(L"SerialController");
2157 UNICODE_STRING HardwareIdSerial = RTL_CONSTANT_STRING(L"*PNP0501\0");
2158 static ULONG DeviceIndexSerial = 0;
2159 const UNICODE_STRING IdentifierKeyboard = RTL_CONSTANT_STRING(L"KeyboardController");
2160 UNICODE_STRING HardwareIdKeyboard = RTL_CONSTANT_STRING(L"*PNP0303\0");
2161 static ULONG DeviceIndexKeyboard = 0;
2162 const UNICODE_STRING IdentifierMouse = RTL_CONSTANT_STRING(L"PointerController");
2163 UNICODE_STRING HardwareIdMouse = RTL_CONSTANT_STRING(L"*PNP0F13\0");
2164 static ULONG DeviceIndexMouse = 0;
2165 UNICODE_STRING HardwareIdKey;
2166 PUNICODE_STRING pHardwareId;
2167 ULONG DeviceIndex = 0;
2168
2169 if (RelativePath)
2170 {
2171 Status = IopOpenRegistryKeyEx(&hDevicesKey, hBaseKey, RelativePath, KEY_ENUMERATE_SUB_KEYS);
2172 if (!NT_SUCCESS(Status))
2173 {
2174 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2175 goto cleanup;
2176 }
2177 }
2178 else
2179 hDevicesKey = hBaseKey;
2180
2181 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2182 if (!pDeviceInformation)
2183 {
2184 DPRINT("ExAllocatePool() failed\n");
2185 Status = STATUS_NO_MEMORY;
2186 goto cleanup;
2187 }
2188
2189 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2190 if (!pValueInformation)
2191 {
2192 DPRINT("ExAllocatePool() failed\n");
2193 Status = STATUS_NO_MEMORY;
2194 goto cleanup;
2195 }
2196
2197 while (TRUE)
2198 {
2199 Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2200 if (Status == STATUS_NO_MORE_ENTRIES)
2201 break;
2202 else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2203 {
2204 ExFreePool(pDeviceInformation);
2205 DeviceInfoLength = RequiredSize;
2206 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2207 if (!pDeviceInformation)
2208 {
2209 DPRINT("ExAllocatePool() failed\n");
2210 Status = STATUS_NO_MEMORY;
2211 goto cleanup;
2212 }
2213 Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2214 }
2215 if (!NT_SUCCESS(Status))
2216 {
2217 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2218 goto cleanup;
2219 }
2220 IndexDevice++;
2221
2222 /* Open device key */
2223 DeviceName.Length = DeviceName.MaximumLength = (USHORT)pDeviceInformation->NameLength;
2224 DeviceName.Buffer = pDeviceInformation->Name;
2225
2226 Status = IopOpenRegistryKeyEx(&hDeviceKey, hDevicesKey, &DeviceName,
2227 KEY_QUERY_VALUE + (EnumerateSubKeys ? KEY_ENUMERATE_SUB_KEYS : 0));
2228 if (!NT_SUCCESS(Status))
2229 {
2230 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2231 goto cleanup;
2232 }
2233
2234 /* Read boot resources, and add then to parent ones */
2235 Status = ZwQueryValueKey(hDeviceKey, &ConfigurationDataU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2236 if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2237 {
2238 ExFreePool(pValueInformation);
2239 ValueInfoLength = RequiredSize;
2240 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2241 if (!pValueInformation)
2242 {
2243 DPRINT("ExAllocatePool() failed\n");
2244 ZwDeleteKey(hLevel2Key);
2245 Status = STATUS_NO_MEMORY;
2246 goto cleanup;
2247 }
2248 Status = ZwQueryValueKey(hDeviceKey, &ConfigurationDataU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2249 }
2250 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
2251 {
2252 BootResources = ParentBootResources;
2253 BootResourcesLength = ParentBootResourcesLength;
2254 }
2255 else if (!NT_SUCCESS(Status))
2256 {
2257 DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2258 goto nextdevice;
2259 }
2260 else if (pValueInformation->Type != REG_FULL_RESOURCE_DESCRIPTOR)
2261 {
2262 DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_FULL_RESOURCE_DESCRIPTOR);
2263 goto nextdevice;
2264 }
2265 else
2266 {
2267 static const ULONG Header = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList.PartialDescriptors);
2268
2269 /* Concatenate current resources and parent ones */
2270 if (ParentBootResourcesLength == 0)
2271 BootResourcesLength = pValueInformation->DataLength;
2272 else
2273 BootResourcesLength = ParentBootResourcesLength
2274 + pValueInformation->DataLength
2275 - Header;
2276 BootResources = ExAllocatePool(PagedPool, BootResourcesLength);
2277 if (!BootResources)
2278 {
2279 DPRINT("ExAllocatePool() failed\n");
2280 goto nextdevice;
2281 }
2282 if (ParentBootResourcesLength == 0)
2283 {
2284 RtlCopyMemory(BootResources, pValueInformation->Data, pValueInformation->DataLength);
2285 }
2286 else if (ParentBootResources->PartialResourceList.PartialDescriptors[ParentBootResources->PartialResourceList.Count - 1].Type == CmResourceTypeDeviceSpecific)
2287 {
2288 RtlCopyMemory(BootResources, pValueInformation->Data, pValueInformation->DataLength);
2289 RtlCopyMemory(
2290 (PVOID)((ULONG_PTR)BootResources + pValueInformation->DataLength),
2291 (PVOID)((ULONG_PTR)ParentBootResources + Header),
2292 ParentBootResourcesLength - Header);
2293 BootResources->PartialResourceList.Count += ParentBootResources->PartialResourceList.Count;
2294 }
2295 else
2296 {
2297 RtlCopyMemory(BootResources, pValueInformation->Data, Header);
2298 RtlCopyMemory(
2299 (PVOID)((ULONG_PTR)BootResources + Header),
2300 (PVOID)((ULONG_PTR)ParentBootResources + Header),
2301 ParentBootResourcesLength - Header);
2302 RtlCopyMemory(
2303 (PVOID)((ULONG_PTR)BootResources + ParentBootResourcesLength),
2304 pValueInformation->Data + Header,
2305 pValueInformation->DataLength - Header);
2306 BootResources->PartialResourceList.Count += ParentBootResources->PartialResourceList.Count;
2307 }
2308 }
2309
2310 if (EnumerateSubKeys)
2311 {
2312 IndexSubKey = 0;
2313 while (TRUE)
2314 {
2315 Status = ZwEnumerateKey(hDeviceKey, IndexSubKey, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2316 if (Status == STATUS_NO_MORE_ENTRIES)
2317 break;
2318 else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2319 {
2320 ExFreePool(pDeviceInformation);
2321 DeviceInfoLength = RequiredSize;
2322 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2323 if (!pDeviceInformation)
2324 {
2325 DPRINT("ExAllocatePool() failed\n");
2326 Status = STATUS_NO_MEMORY;
2327 goto cleanup;
2328 }
2329 Status = ZwEnumerateKey(hDeviceKey, IndexSubKey, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2330 }
2331 if (!NT_SUCCESS(Status))
2332 {
2333 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2334 goto cleanup;
2335 }
2336 IndexSubKey++;
2337 DeviceName.Length = DeviceName.MaximumLength = (USHORT)pDeviceInformation->NameLength;
2338 DeviceName.Buffer = pDeviceInformation->Name;
2339
2340 Status = IopEnumerateDetectedDevices(
2341 hDeviceKey,
2342 &DeviceName,
2343 hRootKey,
2344 TRUE,
2345 BootResources,
2346 BootResourcesLength);
2347 if (!NT_SUCCESS(Status))
2348 goto cleanup;
2349 }
2350 }
2351
2352 /* Read identifier */
2353 Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2354 if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2355 {
2356 ExFreePool(pValueInformation);
2357 ValueInfoLength = RequiredSize;
2358 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2359 if (!pValueInformation)
2360 {
2361 DPRINT("ExAllocatePool() failed\n");
2362 Status = STATUS_NO_MEMORY;
2363 goto cleanup;
2364 }
2365 Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2366 }
2367 if (!NT_SUCCESS(Status))
2368 {
2369 if (Status != STATUS_OBJECT_NAME_NOT_FOUND)
2370 {
2371 DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2372 goto nextdevice;
2373 }
2374 ValueName.Length = ValueName.MaximumLength = 0;
2375 }
2376 else if (pValueInformation->Type != REG_SZ)
2377 {
2378 DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
2379 goto nextdevice;
2380 }
2381 else
2382 {
2383 /* Assign hardware id to this device */
2384 ValueName.Length = ValueName.MaximumLength = (USHORT)pValueInformation->DataLength;
2385 ValueName.Buffer = (PWCHAR)pValueInformation->Data;
2386 if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
2387 ValueName.Length -= sizeof(WCHAR);
2388 }
2389
2390 if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierSerial, FALSE) == 0)
2391 {
2392 pHardwareId = &HardwareIdSerial;
2393 DeviceIndex = DeviceIndexSerial++;
2394 }
2395 else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierKeyboard, FALSE) == 0)
2396 {
2397 pHardwareId = &HardwareIdKeyboard;
2398 DeviceIndex = DeviceIndexKeyboard++;
2399 }
2400 else if (RelativePath && RtlCompareUnicodeString(RelativePath, &IdentifierMouse, FALSE) == 0)
2401 {
2402 pHardwareId = &HardwareIdMouse;
2403 DeviceIndex = DeviceIndexMouse++;
2404 }
2405 else if (NT_SUCCESS(Status))
2406 {
2407 /* Try to also match the device identifier */
2408 if (RtlCompareUnicodeString(&ValueName, &IdentifierPci, FALSE) == 0)
2409 {
2410 pHardwareId = &HardwareIdPci;
2411 DeviceIndex = DeviceIndexPci++;
2412 }
2413 #ifdef ENABLE_ACPI
2414 else if (RtlCompareUnicodeString(&ValueName, &IdentifierAcpi, FALSE) == 0)
2415 {
2416 pHardwareId = &HardwareIdAcpi;
2417 DeviceIndex = DeviceIndexAcpi++;
2418 }
2419 #endif
2420 else
2421 {
2422 /* Unknown device */
2423 DPRINT("Unknown device '%wZ'\n", &ValueName);
2424 goto nextdevice;
2425 }
2426 }
2427 else
2428 {
2429 /* Unknown key path */
2430 DPRINT("Unknown key path '%wZ'\n", RelativePath);
2431 goto nextdevice;
2432 }
2433
2434 /* Prepare hardware id key (hardware id value without final \0) */
2435 HardwareIdKey = *pHardwareId;
2436 HardwareIdKey.Length -= sizeof(UNICODE_NULL);
2437
2438 /* Add the detected device to Root key */
2439 InitializeObjectAttributes(&ObjectAttributes, &HardwareIdKey, OBJ_KERNEL_HANDLE, hRootKey, NULL);
2440 Status = ZwCreateKey(
2441 &hLevel1Key,
2442 KEY_CREATE_SUB_KEY,
2443 &ObjectAttributes,
2444 0,
2445 NULL,
2446 REG_OPTION_NON_VOLATILE,
2447 NULL);
2448 if (!NT_SUCCESS(Status))
2449 {
2450 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2451 goto nextdevice;
2452 }
2453 swprintf(Level2Name, L"%04lu", DeviceIndex);
2454 RtlInitUnicodeString(&Level2NameU, Level2Name);
2455 InitializeObjectAttributes(&ObjectAttributes, &Level2NameU, OBJ_KERNEL_HANDLE, hLevel1Key, NULL);
2456 Status = ZwCreateKey(
2457 &hLevel2Key,
2458 KEY_SET_VALUE | KEY_CREATE_SUB_KEY,
2459 &ObjectAttributes,
2460 0,
2461 NULL,
2462 REG_OPTION_NON_VOLATILE,
2463 NULL);
2464 ZwClose(hLevel1Key);
2465 if (!NT_SUCCESS(Status))
2466 {
2467 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2468 goto nextdevice;
2469 }
2470 DPRINT("Found %wZ #%lu (%wZ)\n", &ValueName, DeviceIndex, &HardwareIdKey);
2471 Status = ZwSetValueKey(hLevel2Key, &DeviceDescU, 0, REG_SZ, ValueName.Buffer, ValueName.MaximumLength);
2472 if (!NT_SUCCESS(Status))
2473 {
2474 DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2475 ZwDeleteKey(hLevel2Key);
2476 goto nextdevice;
2477 }
2478 Status = ZwSetValueKey(hLevel2Key, &HardwareIDU, 0, REG_MULTI_SZ, pHardwareId->Buffer, pHardwareId->MaximumLength);
2479 if (!NT_SUCCESS(Status))
2480 {
2481 DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2482 ZwDeleteKey(hLevel2Key);
2483 goto nextdevice;
2484 }
2485 /* Create 'LogConf' subkey */
2486 InitializeObjectAttributes(&ObjectAttributes, &LogConfU, OBJ_KERNEL_HANDLE, hLevel2Key, NULL);
2487 Status = ZwCreateKey(
2488 &hLogConf,
2489 KEY_SET_VALUE,
2490 &ObjectAttributes,
2491 0,
2492 NULL,
2493 REG_OPTION_VOLATILE,
2494 NULL);
2495 if (!NT_SUCCESS(Status))
2496 {
2497 DPRINT("ZwCreateKey() failed with status 0x%08lx\n", Status);
2498 ZwDeleteKey(hLevel2Key);
2499 goto nextdevice;
2500 }
2501 if (BootResourcesLength > 0)
2502 {
2503 /* Save boot resources to 'LogConf\BootConfig' */
2504 Status = ZwSetValueKey(hLogConf, &BootConfigU, 0, REG_FULL_RESOURCE_DESCRIPTOR, BootResources, BootResourcesLength);
2505 if (!NT_SUCCESS(Status))
2506 {
2507 DPRINT("ZwSetValueKey() failed with status 0x%08lx\n", Status);
2508 ZwClose(hLogConf);
2509 ZwDeleteKey(hLevel2Key);
2510 goto nextdevice;
2511 }
2512 }
2513 ZwClose(hLogConf);
2514
2515 nextdevice:
2516 if (BootResources && BootResources != ParentBootResources)
2517 ExFreePool(BootResources);
2518 if (hLevel2Key)
2519 {
2520 ZwClose(hLevel2Key);
2521 hLevel2Key = NULL;
2522 }
2523 if (hDeviceKey)
2524 {
2525 ZwClose(hDeviceKey);
2526 hDeviceKey = NULL;
2527 }
2528 }
2529
2530 Status = STATUS_SUCCESS;
2531
2532 cleanup:
2533 if (hDevicesKey && hDevicesKey != hBaseKey)
2534 ZwClose(hDevicesKey);
2535 if (hDeviceKey)
2536 ZwClose(hDeviceKey);
2537 if (pDeviceInformation)
2538 ExFreePool(pDeviceInformation);
2539 if (pValueInformation)
2540 ExFreePool(pValueInformation);
2541 return Status;
2542 }
2543
2544 static BOOLEAN INIT_FUNCTION
2545 IopIsAcpiComputer(VOID)
2546 {
2547 #ifndef ENABLE_ACPI
2548 return FALSE;
2549 #else
2550 UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
2551 UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
2552 UNICODE_STRING AcpiBiosIdentifier = RTL_CONSTANT_STRING(L"ACPI BIOS");
2553 OBJECT_ATTRIBUTES ObjectAttributes;
2554 PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
2555 ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
2556 PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
2557 ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
2558 ULONG RequiredSize;
2559 ULONG IndexDevice = 0;
2560 UNICODE_STRING DeviceName, ValueName;
2561 HANDLE hDevicesKey = NULL;
2562 HANDLE hDeviceKey = NULL;
2563 NTSTATUS Status;
2564 BOOLEAN ret = FALSE;
2565
2566 InitializeObjectAttributes(&ObjectAttributes, &MultiKeyPathU, OBJ_KERNEL_HANDLE, NULL, NULL);
2567 Status = ZwOpenKey(&hDevicesKey, KEY_ENUMERATE_SUB_KEYS, &ObjectAttributes);
2568 if (!NT_SUCCESS(Status))
2569 {
2570 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2571 goto cleanup;
2572 }
2573
2574 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2575 if (!pDeviceInformation)
2576 {
2577 DPRINT("ExAllocatePool() failed\n");
2578 Status = STATUS_NO_MEMORY;
2579 goto cleanup;
2580 }
2581
2582 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2583 if (!pDeviceInformation)
2584 {
2585 DPRINT("ExAllocatePool() failed\n");
2586 Status = STATUS_NO_MEMORY;
2587 goto cleanup;
2588 }
2589
2590 while (TRUE)
2591 {
2592 Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2593 if (Status == STATUS_NO_MORE_ENTRIES)
2594 break;
2595 else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2596 {
2597 ExFreePool(pDeviceInformation);
2598 DeviceInfoLength = RequiredSize;
2599 pDeviceInformation = ExAllocatePool(PagedPool, DeviceInfoLength);
2600 if (!pDeviceInformation)
2601 {
2602 DPRINT("ExAllocatePool() failed\n");
2603 Status = STATUS_NO_MEMORY;
2604 goto cleanup;
2605 }
2606 Status = ZwEnumerateKey(hDevicesKey, IndexDevice, KeyBasicInformation, pDeviceInformation, DeviceInfoLength, &RequiredSize);
2607 }
2608 if (!NT_SUCCESS(Status))
2609 {
2610 DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
2611 goto cleanup;
2612 }
2613 IndexDevice++;
2614
2615 /* Open device key */
2616 DeviceName.Length = DeviceName.MaximumLength = pDeviceInformation->NameLength;
2617 DeviceName.Buffer = pDeviceInformation->Name;
2618 InitializeObjectAttributes(&ObjectAttributes, &DeviceName, OBJ_KERNEL_HANDLE, hDevicesKey, NULL);
2619 Status = ZwOpenKey(
2620 &hDeviceKey,
2621 KEY_QUERY_VALUE,
2622 &ObjectAttributes);
2623 if (!NT_SUCCESS(Status))
2624 {
2625 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2626 goto cleanup;
2627 }
2628
2629 /* Read identifier */
2630 Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2631 if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
2632 {
2633 ExFreePool(pValueInformation);
2634 ValueInfoLength = RequiredSize;
2635 pValueInformation = ExAllocatePool(PagedPool, ValueInfoLength);
2636 if (!pValueInformation)
2637 {
2638 DPRINT("ExAllocatePool() failed\n");
2639 Status = STATUS_NO_MEMORY;
2640 goto cleanup;
2641 }
2642 Status = ZwQueryValueKey(hDeviceKey, &IdentifierU, KeyValuePartialInformation, pValueInformation, ValueInfoLength, &RequiredSize);
2643 }
2644 if (!NT_SUCCESS(Status))
2645 {
2646 DPRINT("ZwQueryValueKey() failed with status 0x%08lx\n", Status);
2647 goto nextdevice;
2648 }
2649 else if (pValueInformation->Type != REG_SZ)
2650 {
2651 DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
2652 goto nextdevice;
2653 }
2654
2655 ValueName.Length = ValueName.MaximumLength = pValueInformation->DataLength;
2656 ValueName.Buffer = (PWCHAR)pValueInformation->Data;
2657 if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
2658 ValueName.Length -= sizeof(WCHAR);
2659 if (RtlCompareUnicodeString(&ValueName, &AcpiBiosIdentifier, FALSE) == 0)
2660 {
2661 DPRINT("Found ACPI BIOS\n");
2662 ret = TRUE;
2663 goto cleanup;
2664 }
2665
2666 nextdevice:
2667 ZwClose(hDeviceKey);
2668 hDeviceKey = NULL;
2669 }
2670
2671 cleanup:
2672 if (pDeviceInformation)
2673 ExFreePool(pDeviceInformation);
2674 if (pValueInformation)
2675 ExFreePool(pValueInformation);
2676 if (hDevicesKey)
2677 ZwClose(hDevicesKey);
2678 if (hDeviceKey)
2679 ZwClose(hDeviceKey);
2680 return ret;
2681 #endif
2682 }
2683
2684 static NTSTATUS INIT_FUNCTION
2685 IopUpdateRootKey(VOID)
2686 {
2687 UNICODE_STRING EnumU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Enum");
2688 UNICODE_STRING RootPathU = RTL_CONSTANT_STRING(L"Root");
2689 UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
2690 UNICODE_STRING DeviceDescU = RTL_CONSTANT_STRING(L"DeviceDesc");
2691 UNICODE_STRING HardwareIDU = RTL_CONSTANT_STRING(L"HardwareID");
2692 UNICODE_STRING LogConfU = RTL_CONSTANT_STRING(L"LogConf");
2693 UNICODE_STRING HalAcpiDevice = RTL_CONSTANT_STRING(L"ACPI_HAL");
2694 UNICODE_STRING HalAcpiId = RTL_CONSTANT_STRING(L"0000");
2695 UNICODE_STRING HalAcpiDeviceDesc = RTL_CONSTANT_STRING(L"HAL ACPI");
2696 UNICODE_STRING HalAcpiHardwareID = RTL_CONSTANT_STRING(L"*PNP0C08\0");
2697 OBJECT_ATTRIBUTES ObjectAttributes;
2698 HANDLE hEnum, hRoot, hHalAcpiDevice, hHalAcpiId, hLogConf;
2699 NTSTATUS Status;
2700
2701 InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
2702 Status = ZwCreateKey(&hEnum, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2703 if (!NT_SUCCESS(Status))
2704 {
2705 DPRINT1("ZwCreateKey() failed with status 0x%08lx\n", Status);
2706 return Status;
2707 }
2708
2709 InitializeObjectAttributes(&ObjectAttributes, &RootPathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hEnum, NULL);
2710 Status = ZwCreateKey(&hRoot, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, 0, NULL);
2711 ZwClose(hEnum);
2712 if (!NT_SUCCESS(Status))
2713 {
2714 DPRINT1("ZwOpenKey() failed with status 0x%08lx\n", Status);
2715 return Status;
2716 }
2717
2718 if (IopIsAcpiComputer())
2719 {
2720 InitializeObjectAttributes(&ObjectAttributes, &HalAcpiDevice, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hRoot, NULL);
2721 Status = ZwCreateKey(&hHalAcpiDevice, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
2722 ZwClose(hRoot);
2723 if (!NT_SUCCESS(Status))
2724 return Status;
2725 InitializeObjectAttributes(&ObjectAttributes, &HalAcpiId, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hHalAcpiDevice, NULL);
2726 Status = ZwCreateKey(&hHalAcpiId, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
2727 ZwClose(hHalAcpiDevice);
2728 if (!NT_SUCCESS(Status))
2729 return Status;
2730 Status = ZwSetValueKey(hHalAcpiId, &DeviceDescU, 0, REG_SZ, HalAcpiDeviceDesc.Buffer, HalAcpiDeviceDesc.MaximumLength);
2731 if (NT_SUCCESS(Status))
2732 Status = ZwSetValueKey(hHalAcpiId, &HardwareIDU, 0, REG_MULTI_SZ, HalAcpiHardwareID.Buffer, HalAcpiHardwareID.MaximumLength);
2733 if (NT_SUCCESS(Status))
2734 {
2735 InitializeObjectAttributes(&ObjectAttributes, &LogConfU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hHalAcpiId, NULL);
2736 Status = ZwCreateKey(&hLogConf, 0, &ObjectAttributes, 0, NULL, REG_OPTION_VOLATILE, NULL);
2737 if (NT_SUCCESS(Status))
2738 ZwClose(hLogConf);
2739 }
2740 ZwClose(hHalAcpiId);
2741 return Status;
2742 }
2743 else
2744 {
2745 Status = IopOpenRegistryKeyEx(&hEnum, NULL, &MultiKeyPathU, KEY_ENUMERATE_SUB_KEYS);
2746 if (!NT_SUCCESS(Status))
2747 {
2748 /* Nothing to do, don't return with an error status */
2749 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
2750 ZwClose(hRoot);
2751 return STATUS_SUCCESS;
2752 }
2753 Status = IopEnumerateDetectedDevices(
2754 hEnum,
2755 NULL,
2756 hRoot,
2757 TRUE,
2758 NULL,
2759 0);
2760 ZwClose(hEnum);
2761 ZwClose(hRoot);
2762 return Status;
2763 }
2764 }
2765
2766 NTSTATUS
2767 NTAPI
2768 IopOpenRegistryKeyEx(PHANDLE KeyHandle,
2769 HANDLE ParentKey,
2770 PUNICODE_STRING Name,
2771 ACCESS_MASK DesiredAccess)
2772 {
2773 OBJECT_ATTRIBUTES ObjectAttributes;
2774 NTSTATUS Status;
2775
2776 PAGED_CODE();
2777
2778 *KeyHandle = NULL;
2779
2780 InitializeObjectAttributes(&ObjectAttributes,
2781 Name,
2782 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
2783 ParentKey,
2784 NULL);
2785
2786 Status = ZwOpenKey(KeyHandle, DesiredAccess, &ObjectAttributes);
2787
2788 return Status;
2789 }
2790
2791 NTSTATUS
2792 NTAPI
2793 IopGetRegistryValue(IN HANDLE Handle,
2794 IN PWSTR ValueName,
2795 OUT PKEY_VALUE_FULL_INFORMATION *Information)
2796 {
2797 UNICODE_STRING ValueString;
2798 NTSTATUS Status;
2799 PKEY_VALUE_FULL_INFORMATION FullInformation;
2800 ULONG Size;
2801 PAGED_CODE();
2802
2803 RtlInitUnicodeString(&ValueString, ValueName);
2804
2805 Status = ZwQueryValueKey(Handle,
2806 &ValueString,
2807 KeyValueFullInformation,
2808 NULL,
2809 0,
2810 &Size);
2811 if ((Status != STATUS_BUFFER_OVERFLOW) &&
2812 (Status != STATUS_BUFFER_TOO_SMALL))
2813 {
2814 return Status;
2815 }
2816
2817 FullInformation = ExAllocatePool(NonPagedPool, Size);
2818 if (!FullInformation) return STATUS_INSUFFICIENT_RESOURCES;
2819
2820 Status = ZwQueryValueKey(Handle,
2821 &ValueString,
2822 KeyValueFullInformation,
2823 FullInformation,
2824 Size,
2825 &Size);
2826 if (!NT_SUCCESS(Status))
2827 {
2828 ExFreePool(FullInformation);
2829 return Status;
2830 }
2831
2832 *Information = FullInformation;
2833 return STATUS_SUCCESS;
2834 }
2835
2836 static NTSTATUS INIT_FUNCTION
2837 NTAPI
2838 PnpDriverInitializeEmpty(IN struct _DRIVER_OBJECT *DriverObject, IN PUNICODE_STRING RegistryPath)
2839 {
2840 return STATUS_SUCCESS;
2841 }
2842
2843 VOID INIT_FUNCTION
2844 PnpInit(VOID)
2845 {
2846 PDEVICE_OBJECT Pdo;
2847 NTSTATUS Status;
2848
2849 DPRINT("PnpInit()\n");
2850
2851 KeInitializeSpinLock(&IopDeviceTreeLock);
2852 ExInitializeFastMutex(&IopBusTypeGuidListLock);
2853
2854 /* Initialize the Bus Type GUID List */
2855 IopBusTypeGuidList = ExAllocatePool(NonPagedPool, sizeof(IO_BUS_TYPE_GUID_LIST));
2856 if (!IopBusTypeGuidList) {
2857 DPRINT1("ExAllocatePool() failed\n");
2858 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
2859 }
2860
2861 RtlZeroMemory(IopBusTypeGuidList, sizeof(IO_BUS_TYPE_GUID_LIST));
2862 ExInitializeFastMutex(&IopBusTypeGuidList->Lock);
2863
2864 /* Initialize PnP-Event notification support */
2865 Status = IopInitPlugPlayEvents();
2866 if (!NT_SUCCESS(Status))
2867 {
2868 DPRINT1("IopInitPlugPlayEvents() failed\n");
2869 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2870 }
2871
2872 /*
2873 * Create root device node
2874 */
2875
2876 Status = IopCreateDriver(NULL, PnpDriverInitializeEmpty, NULL, 0, 0, &IopRootDriverObject);
2877 if (!NT_SUCCESS(Status))
2878 {
2879 DPRINT1("IoCreateDriverObject() failed\n");
2880 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2881 }
2882
2883 Status = IoCreateDevice(IopRootDriverObject, 0, NULL, FILE_DEVICE_CONTROLLER,
2884 0, FALSE, &Pdo);
2885 if (!NT_SUCCESS(Status))
2886 {
2887 DPRINT1("IoCreateDevice() failed\n");
2888 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2889 }
2890
2891 Status = IopCreateDeviceNode(NULL, Pdo, NULL, &IopRootDeviceNode);
2892 if (!NT_SUCCESS(Status))
2893 {
2894 DPRINT1("Insufficient resources\n");
2895 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2896 }
2897
2898 if (!RtlCreateUnicodeString(&IopRootDeviceNode->InstancePath,
2899 L"HTREE\\ROOT\\0"))
2900 {
2901 DPRINT1("Failed to create the instance path!\n");
2902 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, STATUS_NO_MEMORY, 0, 0, 0);
2903 }
2904
2905 /* Report the device to the user-mode pnp manager */
2906 IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
2907 &IopRootDeviceNode->InstancePath);
2908
2909 IopRootDeviceNode->PhysicalDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
2910 PnpRootDriverEntry(IopRootDriverObject, NULL);
2911 IopRootDeviceNode->PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
2912 IopRootDriverObject->DriverExtension->AddDevice(
2913 IopRootDriverObject,
2914 IopRootDeviceNode->PhysicalDeviceObject);
2915
2916 /* Move information about devices detected by Freeloader to SYSTEM\CurrentControlSet\Root\ */
2917 Status = IopUpdateRootKey();
2918 if (!NT_SUCCESS(Status))
2919 {
2920 DPRINT1("IopUpdateRootKey() failed\n");
2921 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
2922 }
2923 }
2924
2925 RTL_GENERIC_COMPARE_RESULTS
2926 NTAPI
2927 PiCompareInstancePath(IN PRTL_AVL_TABLE Table,
2928 IN PVOID FirstStruct,
2929 IN PVOID SecondStruct)
2930 {
2931 /* FIXME: TODO */
2932 ASSERT(FALSE);
2933 return 0;
2934 }
2935
2936 //
2937 // The allocation function is called by the generic table package whenever
2938 // it needs to allocate memory for the table.
2939 //
2940
2941 PVOID
2942 NTAPI
2943 PiAllocateGenericTableEntry(IN PRTL_AVL_TABLE Table,
2944 IN CLONG ByteSize)
2945 {
2946 /* FIXME: TODO */
2947 ASSERT(FALSE);
2948 return NULL;
2949 }
2950
2951 VOID
2952 NTAPI
2953 PiFreeGenericTableEntry(IN PRTL_AVL_TABLE Table,
2954 IN PVOID Buffer)
2955 {
2956 /* FIXME: TODO */
2957 ASSERT(FALSE);
2958 }
2959
2960 VOID
2961 NTAPI
2962 PpInitializeDeviceReferenceTable(VOID)
2963 {
2964 /* Setup the guarded mutex and AVL table */
2965 KeInitializeGuardedMutex(&PpDeviceReferenceTableLock);
2966 RtlInitializeGenericTableAvl(
2967 &PpDeviceReferenceTable,
2968 (PRTL_AVL_COMPARE_ROUTINE)PiCompareInstancePath,
2969 (PRTL_AVL_ALLOCATE_ROUTINE)PiAllocateGenericTableEntry,
2970 (PRTL_AVL_FREE_ROUTINE)PiFreeGenericTableEntry,
2971 NULL);
2972 }
2973
2974 BOOLEAN
2975 NTAPI
2976 PiInitPhase0(VOID)
2977 {
2978 /* Initialize the resource when accessing device registry data */
2979 ExInitializeResourceLite(&PpRegistryDeviceResource);
2980
2981 /* Setup the device reference AVL table */
2982 PpInitializeDeviceReferenceTable();
2983 return TRUE;
2984 }
2985
2986 BOOLEAN
2987 NTAPI
2988 PpInitSystem(VOID)
2989 {
2990 /* Check the initialization phase */
2991 switch (ExpInitializationPhase)
2992 {
2993 case 0:
2994
2995 /* Do Phase 0 */
2996 return PiInitPhase0();
2997
2998 case 1:
2999
3000 /* Do Phase 1 */
3001 return TRUE;
3002 //return PiInitPhase1();
3003
3004 default:
3005
3006 /* Don't know any other phase! Bugcheck! */
3007 KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
3008 return FALSE;
3009 }
3010 }
3011
3012 /* PUBLIC FUNCTIONS **********************************************************/
3013
3014 /*
3015 * @unimplemented
3016 */
3017 NTSTATUS
3018 NTAPI
3019 IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject,
3020 IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
3021 IN ULONG BufferLength,
3022 OUT PVOID PropertyBuffer,
3023 OUT PULONG ResultLength)
3024 {
3025 PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
3026 DEVICE_CAPABILITIES DeviceCaps;
3027 ULONG Length;
3028 PVOID Data = NULL;
3029 PWSTR Ptr;
3030 NTSTATUS Status;
3031
3032 DPRINT("IoGetDeviceProperty(0x%p %d)\n", DeviceObject, DeviceProperty);
3033
3034 *ResultLength = 0;
3035
3036 if (DeviceNode == NULL)
3037 return STATUS_INVALID_DEVICE_REQUEST;
3038
3039 switch (DeviceProperty)
3040 {
3041 case DevicePropertyBusNumber:
3042 Length = sizeof(ULONG);
3043 Data = &DeviceNode->ChildBusNumber;
3044 break;
3045
3046 /* Complete, untested */
3047 case DevicePropertyBusTypeGuid:
3048 /* Sanity check */
3049 if ((DeviceNode->ChildBusTypeIndex != 0xFFFF) &&
3050 (DeviceNode->ChildBusTypeIndex < IopBusTypeGuidList->GuidCount))
3051 {
3052 /* Return the GUID */
3053 *ResultLength = sizeof(GUID);
3054
3055 /* Check if the buffer given was large enough */
3056 if (BufferLength < *ResultLength)
3057 {
3058 return STATUS_BUFFER_TOO_SMALL;
3059 }
3060
3061 /* Copy the GUID */
3062 RtlCopyMemory(PropertyBuffer,
3063 &(IopBusTypeGuidList->Guids[DeviceNode->ChildBusTypeIndex]),
3064 sizeof(GUID));
3065 return STATUS_SUCCESS;
3066 }
3067 else
3068 {
3069 return STATUS_OBJECT_NAME_NOT_FOUND;
3070 }
3071 break;
3072
3073 case DevicePropertyLegacyBusType:
3074 Length = sizeof(INTERFACE_TYPE);
3075 Data = &DeviceNode->ChildInterfaceType;
3076 break;
3077
3078 case DevicePropertyAddress:
3079 /* Query the device caps */
3080 Status = IopQueryDeviceCapabilities(DeviceNode, &DeviceCaps);
3081 if (NT_SUCCESS(Status) && (DeviceCaps.Address != MAXULONG))
3082 {
3083 /* Return length */
3084 *ResultLength = sizeof(ULONG);
3085
3086 /* Check if the buffer given was large enough */
3087 if (BufferLength < *ResultLength)
3088 {
3089 return STATUS_BUFFER_TOO_SMALL;
3090 }
3091
3092 /* Return address */
3093 *(PULONG)PropertyBuffer = DeviceCaps.Address;
3094 return STATUS_SUCCESS;
3095 }
3096 else
3097 {
3098 return STATUS_OBJECT_NAME_NOT_FOUND;
3099 }
3100 break;
3101
3102 // case DevicePropertyUINumber:
3103 // if (DeviceNode->CapabilityFlags == NULL)
3104 // return STATUS_INVALID_DEVICE_REQUEST;
3105 // Length = sizeof(ULONG);
3106 // Data = &DeviceNode->CapabilityFlags->UINumber;
3107 // break;
3108
3109 case DevicePropertyClassName:
3110 case DevicePropertyClassGuid:
3111 case DevicePropertyDriverKeyName:
3112 case DevicePropertyManufacturer:
3113 case DevicePropertyFriendlyName:
3114 case DevicePropertyHardwareID:
3115 case DevicePropertyCompatibleIDs:
3116 case DevicePropertyDeviceDescription:
3117 case DevicePropertyLocationInformation:
3118 case DevicePropertyUINumber:
3119 {
3120 LPCWSTR RegistryPropertyName;
3121 UNICODE_STRING EnumRoot = RTL_CONSTANT_STRING(ENUM_ROOT);
3122 UNICODE_STRING ValueName;
3123 KEY_VALUE_PARTIAL_INFORMATION *ValueInformation;
3124 ULONG ValueInformationLength;
3125 HANDLE KeyHandle, EnumRootHandle;
3126 NTSTATUS Status;
3127
3128 switch (DeviceProperty)
3129 {
3130 case DevicePropertyClassName:
3131 RegistryPropertyName = L"Class"; break;
3132 case DevicePropertyClassGuid:
3133 RegistryPropertyName = L"ClassGuid"; break;
3134 case DevicePropertyDriverKeyName:
3135 RegistryPropertyName = L"Driver"; break;
3136 case DevicePropertyManufacturer:
3137 RegistryPropertyName = L"Mfg"; break;
3138 case DevicePropertyFriendlyName:
3139 RegistryPropertyName = L"FriendlyName"; break;
3140 case DevicePropertyHardwareID:
3141 RegistryPropertyName = L"HardwareID"; break;
3142 case DevicePropertyCompatibleIDs:
3143 RegistryPropertyName = L"CompatibleIDs"; break;
3144 case DevicePropertyDeviceDescription:
3145 RegistryPropertyName = L"DeviceDesc"; break;
3146 case DevicePropertyLocationInformation:
3147 RegistryPropertyName = L"LocationInformation"; break;
3148 case DevicePropertyUINumber:
3149 RegistryPropertyName = L"UINumber"; break;
3150 default:
3151 /* Should not happen */
3152 ASSERT(FALSE);
3153 return STATUS_UNSUCCESSFUL;
3154 }
3155
3156 DPRINT("Registry property %S\n", RegistryPropertyName);
3157
3158 /* Open Enum key */
3159 Status = IopOpenRegistryKeyEx(&EnumRootHandle, NULL,
3160 &EnumRoot, KEY_READ);
3161 if (!NT_SUCCESS(Status))
3162 {
3163 DPRINT1("Error opening ENUM_ROOT, Status=0x%08x\n", Status);
3164 return Status;
3165 }
3166
3167 /* Open instance key */
3168 Status = IopOpenRegistryKeyEx(&KeyHandle, EnumRootHandle,
3169 &DeviceNode->InstancePath, KEY_READ);
3170 if (!NT_SUCCESS(Status))
3171 {
3172 DPRINT1("Error opening InstancePath, Status=0x%08x\n", Status);
3173 ZwClose(EnumRootHandle);
3174 return Status;
3175 }
3176
3177 /* Allocate buffer to read as much data as required by the caller */
3178 ValueInformationLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,
3179 Data[0]) + BufferLength;
3180 ValueInformation = ExAllocatePool(PagedPool, ValueInformationLength);
3181 if (!ValueInformation)
3182 {
3183 ZwClose(KeyHandle);
3184 return STATUS_INSUFFICIENT_RESOURCES;
3185 }
3186
3187 /* Read the value */
3188 RtlInitUnicodeString(&ValueName, RegistryPropertyName);
3189 Status = ZwQueryValueKey(KeyHandle, &ValueName,
3190 KeyValuePartialInformation, ValueInformation,
3191 ValueInformationLength,
3192 &ValueInformationLength);
3193 ZwClose(KeyHandle);
3194
3195 /* Return data */
3196 *ResultLength = ValueInformation->DataLength;
3197
3198 if (!NT_SUCCESS(Status))
3199 {
3200 ExFreePool(ValueInformation);
3201 if (Status == STATUS_BUFFER_OVERFLOW)
3202 return STATUS_BUFFER_TOO_SMALL;
3203 DPRINT1("Problem: Status=0x%08x, ResultLength = %d\n", Status, *ResultLength);
3204 return Status;
3205 }
3206
3207 /* FIXME: Verify the value (NULL-terminated, correct format). */
3208 RtlCopyMemory(PropertyBuffer, ValueInformation->Data,
3209 ValueInformation->DataLength);
3210 ExFreePool(ValueInformation);
3211
3212 return STATUS_SUCCESS;
3213 }
3214
3215 case DevicePropertyBootConfiguration:
3216 Length = 0;
3217 if (DeviceNode->BootResources->Count != 0)
3218 {
3219 Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
3220 }
3221 Data = DeviceNode->BootResources;
3222 break;
3223
3224 /* FIXME: use a translated boot configuration instead */
3225 case DevicePropertyBootConfigurationTranslated:
3226 Length = 0;
3227 if (DeviceNode->BootResources->Count != 0)
3228 {
3229 Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
3230 }
3231 Data = DeviceNode->BootResources;
3232 break;
3233
3234 case DevicePropertyEnumeratorName:
3235 /* A buffer overflow can't happen here, since InstancePath
3236 * always contains the enumerator name followed by \\ */
3237 Ptr = wcschr(DeviceNode->InstancePath.Buffer, L'\\');
3238 ASSERT(Ptr);
3239 Length = (Ptr - DeviceNode->InstancePath.Buffer) * sizeof(WCHAR);
3240 Data = DeviceNode->InstancePath.Buffer;
3241 break;
3242
3243 case DevicePropertyPhysicalDeviceObjectName:
3244 /* InstancePath buffer is NULL terminated, so we can do this */
3245 Length = DeviceNode->InstancePath.MaximumLength;
3246 Data = DeviceNode->InstancePath.Buffer;
3247 break;
3248
3249 default:
3250 return STATUS_INVALID_PARAMETER_2;
3251 }
3252
3253 /* Prepare returned values */
3254 *ResultLength = Length;
3255 if (BufferLength < Length)
3256 return STATUS_BUFFER_TOO_SMALL;
3257 RtlCopyMemory(PropertyBuffer, Data, Length);
3258
3259 /* NULL terminate the string (if required) */
3260 if (DeviceProperty == DevicePropertyEnumeratorName)
3261 ((LPWSTR)PropertyBuffer)[Length / sizeof(WCHAR)] = UNICODE_NULL;
3262
3263 return STATUS_SUCCESS;
3264 }
3265
3266 /*
3267 * @unimplemented
3268 */
3269 VOID
3270 NTAPI
3271 IoInvalidateDeviceState(IN PDEVICE_OBJECT PhysicalDeviceObject)
3272 {
3273 UNIMPLEMENTED;
3274 }
3275
3276 /**
3277 * @name IoOpenDeviceRegistryKey
3278 *
3279 * Open a registry key unique for a specified driver or device instance.
3280 *
3281 * @param DeviceObject Device to get the registry key for.
3282 * @param DevInstKeyType Type of the key to return.
3283 * @param DesiredAccess Access mask (eg. KEY_READ | KEY_WRITE).
3284 * @param DevInstRegKey Handle to the opened registry key on
3285 * successful return.
3286 *
3287 * @return Status.
3288 *
3289 * @implemented
3290 */
3291 NTSTATUS
3292 NTAPI
3293 IoOpenDeviceRegistryKey(IN PDEVICE_OBJECT DeviceObject,
3294 IN ULONG DevInstKeyType,
3295 IN ACCESS_MASK DesiredAccess,
3296 OUT PHANDLE DevInstRegKey)
3297 {
3298 static WCHAR RootKeyName[] =
3299 L"\\Registry\\Machine\\System\\CurrentControlSet\\";
3300 static WCHAR ProfileKeyName[] =
3301 L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
3302 static WCHAR ClassKeyName[] = L"Control\\Class\\";
3303 static WCHAR EnumKeyName[] = L"Enum\\";
3304 static WCHAR DeviceParametersKeyName[] = L"Device Parameters";
3305 ULONG KeyNameLength;
3306 LPWSTR KeyNameBuffer;
3307 UNICODE_STRING KeyName;
3308 ULONG DriverKeyLength;
3309 OBJECT_ATTRIBUTES ObjectAttributes;
3310 PDEVICE_NODE DeviceNode = NULL;
3311 NTSTATUS Status;
3312
3313 DPRINT("IoOpenDeviceRegistryKey() called\n");
3314
3315 if ((DevInstKeyType & (PLUGPLAY_REGKEY_DEVICE | PLUGPLAY_REGKEY_DRIVER)) == 0)
3316 {
3317 DPRINT1("IoOpenDeviceRegistryKey(): got wrong params, exiting... \n");
3318 return STATUS_INVALID_PARAMETER;
3319 }
3320
3321 /*
3322 * Calculate the length of the base key name. This is the full
3323 * name for driver key or the name excluding "Device Parameters"
3324 * subkey for device key.
3325 */
3326
3327 KeyNameLength = sizeof(RootKeyName);
3328 if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
3329 KeyNameLength += sizeof(ProfileKeyName) - sizeof(UNICODE_NULL);
3330 if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3331 {
3332 KeyNameLength += sizeof(ClassKeyName) - sizeof(UNICODE_NULL);
3333 Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
3334 0, NULL, &DriverKeyLength);
3335 if (Status != STATUS_BUFFER_TOO_SMALL)
3336 return Status;
3337 KeyNameLength += DriverKeyLength;
3338 }
3339 else
3340 {
3341 DeviceNode = IopGetDeviceNode(DeviceObject);
3342 KeyNameLength += sizeof(EnumKeyName) - sizeof(UNICODE_NULL) +
3343 DeviceNode->InstancePath.Length;
3344 }
3345
3346 /*
3347 * Now allocate the buffer for the key name...
3348 */
3349
3350 KeyNameBuffer = ExAllocatePool(PagedPool, KeyNameLength);
3351 if (KeyNameBuffer == NULL)
3352 return STATUS_INSUFFICIENT_RESOURCES;
3353
3354 KeyName.Length = 0;
3355 KeyName.MaximumLength = (USHORT)KeyNameLength;
3356 KeyName.Buffer = KeyNameBuffer;
3357
3358 /*
3359 * ...and build the key name.
3360 */
3361
3362 KeyName.Length += sizeof(RootKeyName) - sizeof(UNICODE_NULL);
3363 RtlCopyMemory(KeyNameBuffer, RootKeyName, KeyName.Length);
3364
3365 if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
3366 RtlAppendUnicodeToString(&KeyName, ProfileKeyName);
3367
3368 if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3369 {
3370 RtlAppendUnicodeToString(&KeyName, ClassKeyName);
3371 Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
3372 DriverKeyLength, KeyNameBuffer +
3373 (KeyName.Length / sizeof(WCHAR)),
3374 &DriverKeyLength);
3375 if (!NT_SUCCESS(Status))
3376 {
3377 DPRINT1("Call to IoGetDeviceProperty() failed with Status 0x%08lx\n", Status);
3378 ExFreePool(KeyNameBuffer);
3379 return Status;
3380 }
3381 KeyName.Length += (USHORT)DriverKeyLength - sizeof(UNICODE_NULL);
3382 }
3383 else
3384 {
3385 RtlAppendUnicodeToString(&KeyName, EnumKeyName);
3386 Status = RtlAppendUnicodeStringToString(&KeyName, &DeviceNode->InstancePath);
3387 if (DeviceNode->InstancePath.Length == 0)
3388 {
3389 ExFreePool(KeyNameBuffer);
3390 return Status;
3391 }
3392 }
3393
3394 /*
3395 * Open the base key.
3396 */
3397 Status = IopOpenRegistryKeyEx(DevInstRegKey, NULL, &KeyName, DesiredAccess);
3398 if (!NT_SUCCESS(Status))
3399 {
3400 DPRINT1("IoOpenDeviceRegistryKey(%wZ): Base key doesn't exist, exiting... (Status 0x%08lx)\n", &KeyName, Status);
3401 ExFreePool(KeyNameBuffer);
3402 return Status;
3403 }
3404 ExFreePool(KeyNameBuffer);
3405
3406 /*
3407 * For driver key we're done now.
3408 */
3409
3410 if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
3411 return Status;
3412
3413 /*
3414 * Let's go further. For device key we must open "Device Parameters"
3415 * subkey and create it if it doesn't exist yet.
3416 */
3417
3418 RtlInitUnicodeString(&KeyName, DeviceParametersKeyName);
3419 InitializeObjectAttributes(&ObjectAttributes, &KeyName,
3420 OBJ_CASE_INSENSITIVE, *DevInstRegKey, NULL);
3421 Status = ZwCreateKey(DevInstRegKey, DesiredAccess, &ObjectAttributes,
3422 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
3423 ZwClose(ObjectAttributes.RootDirectory);
3424
3425 return Status;
3426 }
3427
3428 /*
3429 * @unimplemented
3430 */
3431 VOID
3432 NTAPI
3433 IoRequestDeviceEject(IN PDEVICE_OBJECT PhysicalDeviceObject)
3434 {
3435 UNIMPLEMENTED;
3436 }
3437
3438 /*
3439 * @implemented
3440 */
3441 VOID
3442 NTAPI
3443 IoInvalidateDeviceRelations(
3444 IN PDEVICE_OBJECT DeviceObject,
3445 IN DEVICE_RELATION_TYPE Type)
3446 {
3447 PIO_WORKITEM WorkItem;
3448 PINVALIDATE_DEVICE_RELATION_DATA Data;
3449
3450 Data = ExAllocatePool(PagedPool, sizeof(INVALIDATE_DEVICE_RELATION_DATA));
3451 if (!Data)
3452 return;
3453 WorkItem = IoAllocateWorkItem(DeviceObject);
3454 if (!WorkItem)
3455 {
3456 ExFreePool(Data);
3457 return;
3458 }
3459
3460 ObReferenceObject(DeviceObject);
3461 Data->DeviceObject = DeviceObject;
3462 Data->Type = Type;
3463 Data->WorkItem = WorkItem;
3464
3465 IoQueueWorkItem(
3466 WorkItem,
3467 IopAsynchronousInvalidateDeviceRelations,
3468 DelayedWorkQueue,
3469 Data);
3470 }
3471
3472 /*
3473 * @implemented
3474 */
3475 NTSTATUS
3476 NTAPI
3477 IoSynchronousInvalidateDeviceRelations(
3478 IN PDEVICE_OBJECT DeviceObject,
3479 IN DEVICE_RELATION_TYPE Type)
3480 {
3481 PAGED_CODE();
3482
3483 switch (Type)
3484 {
3485 case BusRelations:
3486 /* Enumerate the device */
3487 return IopEnumerateDevice(DeviceObject);
3488 case PowerRelations:
3489 /* Not handled yet */
3490 return STATUS_NOT_IMPLEMENTED;
3491 case TargetDeviceRelation:
3492 /* Nothing to do */
3493 return STATUS_SUCCESS;
3494 default:
3495 /* Ejection relations are not supported */
3496 return STATUS_NOT_SUPPORTED;
3497 }
3498 }
3499
3500 /*
3501 * @unimplemented
3502 */
3503 BOOLEAN
3504 NTAPI
3505 IoTranslateBusAddress(IN INTERFACE_TYPE InterfaceType,
3506 IN ULONG BusNumber,
3507 IN PHYSICAL_ADDRESS BusAddress,
3508 IN OUT PULONG AddressSpace,
3509 OUT PPHYSICAL_ADDRESS TranslatedAddress)
3510 {
3511 UNIMPLEMENTED;
3512 return FALSE;
3513 }
A free Windows-compatible Operating System