patch by Filip Navara:
[reactos.git] / reactos / ntoskrnl / io / pnpmgr.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: ntoskrnl/io/pnpmgr.c
6 * PURPOSE: Initializes the PnP manager
7 *
8 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
9 */
10
11 /* INCLUDES ******************************************************************/
12
13 #include <ntoskrnl.h>
14 #include <ddk/wdmguid.h>
15
16 #define NDEBUG
17 #include <internal/debug.h>
18
19 /* GLOBALS *******************************************************************/
20
21 PDEVICE_NODE IopRootDeviceNode;
22 KSPIN_LOCK IopDeviceTreeLock;
23
24 /* DATA **********************************************************************/
25
26 PDRIVER_OBJECT IopRootDriverObject;
27
28 /* FUNCTIONS *****************************************************************/
29
30 /*
31 * @unimplemented
32 */
33 VOID
34 STDCALL
35 IoInvalidateDeviceRelations(
36 IN PDEVICE_OBJECT DeviceObject,
37 IN DEVICE_RELATION_TYPE Type)
38 {
39 CHECKPOINT1;
40 }
41
42 PDEVICE_NODE FASTCALL
43 IopGetDeviceNode(
44 PDEVICE_OBJECT DeviceObject)
45 {
46 return DeviceObject->DeviceObjectExtension->DeviceNode;
47 }
48
49 /*
50 * @unimplemented
51 */
52 NTSTATUS
53 STDCALL
54 IoGetDeviceProperty(
55 IN PDEVICE_OBJECT DeviceObject,
56 IN DEVICE_REGISTRY_PROPERTY DeviceProperty,
57 IN ULONG BufferLength,
58 OUT PVOID PropertyBuffer,
59 OUT PULONG ResultLength)
60 {
61 PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
62 ULONG Length;
63 PVOID Data;
64 PWSTR Ptr;
65
66 DPRINT("IoGetDeviceProperty(%x %d)\n", DeviceObject, DeviceProperty);
67
68 if (DeviceNode == NULL)
69 return STATUS_INVALID_DEVICE_REQUEST;
70
71 switch (DeviceProperty)
72 {
73 case DevicePropertyBusNumber:
74 Length = sizeof(ULONG);
75 Data = &DeviceNode->ChildBusNumber;
76 break;
77
78 /* Complete, untested */
79 case DevicePropertyBusTypeGuid:
80 *ResultLength = 39 * sizeof(WCHAR);
81 if (BufferLength < (39 * sizeof(WCHAR)))
82 return STATUS_BUFFER_TOO_SMALL;
83 swprintf((PWSTR)PropertyBuffer,
84 L"{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
85 DeviceNode->BusTypeGuid.Data1,
86 DeviceNode->BusTypeGuid.Data2,
87 DeviceNode->BusTypeGuid.Data3,
88 DeviceNode->BusTypeGuid.Data4[0],
89 DeviceNode->BusTypeGuid.Data4[1],
90 DeviceNode->BusTypeGuid.Data4[2],
91 DeviceNode->BusTypeGuid.Data4[3],
92 DeviceNode->BusTypeGuid.Data4[4],
93 DeviceNode->BusTypeGuid.Data4[5],
94 DeviceNode->BusTypeGuid.Data4[6],
95 DeviceNode->BusTypeGuid.Data4[7]);
96 return STATUS_SUCCESS;
97
98 case DevicePropertyLegacyBusType:
99 Length = sizeof(INTERFACE_TYPE);
100 Data = &DeviceNode->ChildInterfaceType;
101 break;
102
103 case DevicePropertyAddress:
104 Length = sizeof(ULONG);
105 Data = &DeviceNode->Address;
106 break;
107
108 // case DevicePropertyUINumber:
109 // if (DeviceNode->CapabilityFlags == NULL)
110 // return STATUS_INVALID_DEVICE_REQUEST;
111 // Length = sizeof(ULONG);
112 // Data = &DeviceNode->CapabilityFlags->UINumber;
113 // break;
114
115 case DevicePropertyClassName:
116 case DevicePropertyClassGuid:
117 case DevicePropertyDriverKeyName:
118 case DevicePropertyManufacturer:
119 case DevicePropertyFriendlyName:
120 case DevicePropertyHardwareID:
121 case DevicePropertyCompatibleIDs:
122 case DevicePropertyDeviceDescription:
123 case DevicePropertyLocationInformation:
124 case DevicePropertyUINumber:
125 {
126 LPWSTR RegistryPropertyName, KeyNameBuffer;
127 UNICODE_STRING KeyName, ValueName;
128 OBJECT_ATTRIBUTES ObjectAttributes;
129 KEY_VALUE_PARTIAL_INFORMATION *ValueInformation;
130 ULONG ValueInformationLength;
131 HANDLE KeyHandle;
132 NTSTATUS Status;
133
134 switch (DeviceProperty)
135 {
136 case DevicePropertyClassName:
137 RegistryPropertyName = L"Class"; break;
138 case DevicePropertyClassGuid:
139 RegistryPropertyName = L"ClassGuid"; break;
140 case DevicePropertyDriverKeyName:
141 RegistryPropertyName = L"Driver"; break;
142 case DevicePropertyManufacturer:
143 RegistryPropertyName = L"Mfg"; break;
144 case DevicePropertyFriendlyName:
145 RegistryPropertyName = L"FriendlyName"; break;
146 case DevicePropertyHardwareID:
147 RegistryPropertyName = L"HardwareID"; break;
148 case DevicePropertyCompatibleIDs:
149 RegistryPropertyName = L"CompatibleIDs"; break;
150 case DevicePropertyDeviceDescription:
151 RegistryPropertyName = L"DeviceDesc"; break;
152 case DevicePropertyLocationInformation:
153 RegistryPropertyName = L"LocationInformation"; break;
154 case DevicePropertyUINumber:
155 RegistryPropertyName = L"UINumber"; break;
156 default:
157 RegistryPropertyName = NULL; break;
158 }
159
160 KeyNameBuffer = ExAllocatePool(PagedPool,
161 (49 * sizeof(WCHAR)) + DeviceNode->InstancePath.Length);
162
163 DPRINT("KeyNameBuffer: %x, value %S\n",
164 KeyNameBuffer, RegistryPropertyName);
165
166 if (KeyNameBuffer == NULL)
167 return STATUS_INSUFFICIENT_RESOURCES;
168
169 wcscpy(KeyNameBuffer, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
170 wcscat(KeyNameBuffer, DeviceNode->InstancePath.Buffer);
171 RtlInitUnicodeString(&KeyName, KeyNameBuffer);
172 InitializeObjectAttributes(&ObjectAttributes, &KeyName,
173 OBJ_CASE_INSENSITIVE, NULL, NULL);
174
175 Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
176 ExFreePool(KeyNameBuffer);
177 if (!NT_SUCCESS(Status))
178 return Status;
179
180 RtlInitUnicodeString(&ValueName, RegistryPropertyName);
181 ValueInformationLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,
182 Data[0]) + BufferLength;
183 ValueInformation = ExAllocatePool(PagedPool, ValueInformationLength);
184 if (ValueInformation == NULL)
185 {
186 ZwClose(KeyHandle);
187 return STATUS_INSUFFICIENT_RESOURCES;
188 }
189
190 Status = ZwQueryValueKey(KeyHandle, &ValueName,
191 KeyValuePartialInformation, ValueInformation,
192 ValueInformationLength,
193 &ValueInformationLength);
194 *ResultLength = ValueInformation->DataLength;
195 ZwClose(KeyHandle);
196
197 if (ValueInformation->DataLength > BufferLength)
198 Status = STATUS_BUFFER_TOO_SMALL;
199
200 if (!NT_SUCCESS(Status))
201 {
202 ExFreePool(ValueInformation);
203 return Status;
204 }
205
206 /* FIXME: Verify the value (NULL-terminated, correct format). */
207
208 RtlCopyMemory(PropertyBuffer, ValueInformation->Data,
209 ValueInformation->DataLength);
210 ExFreePool(ValueInformation);
211
212 return STATUS_SUCCESS;
213 }
214
215 case DevicePropertyBootConfiguration:
216 Length = 0;
217 if (DeviceNode->BootResources->Count != 0)
218 {
219 Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
220 }
221 Data = &DeviceNode->BootResources;
222 break;
223
224 /* FIXME: use a translated boot configuration instead */
225 case DevicePropertyBootConfigurationTranslated:
226 Length = 0;
227 if (DeviceNode->BootResources->Count != 0)
228 {
229 Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
230 }
231 Data = &DeviceNode->BootResources;
232 break;
233
234 case DevicePropertyEnumeratorName:
235 Ptr = wcschr(DeviceNode->InstancePath.Buffer, L'\\');
236 if (Ptr != NULL)
237 {
238 Length = (ULONG)((ULONG_PTR)Ptr - (ULONG_PTR)DeviceNode->InstancePath.Buffer) + sizeof(WCHAR);
239 }
240 else
241 {
242 Length = 0;
243 Data = NULL;
244 }
245
246 case DevicePropertyPhysicalDeviceObjectName:
247 return STATUS_NOT_IMPLEMENTED;
248
249 default:
250 return STATUS_INVALID_PARAMETER_2;
251 }
252
253 *ResultLength = Length;
254 if (BufferLength < Length)
255 return STATUS_BUFFER_TOO_SMALL;
256 RtlCopyMemory(PropertyBuffer, Data, Length);
257
258 /* Terminate the string */
259 if (DeviceProperty == DevicePropertyEnumeratorName)
260 {
261 Ptr = (PWSTR)PropertyBuffer;
262 Ptr[(Length / sizeof(WCHAR)) - 1] = 0;
263 }
264
265 return STATUS_SUCCESS;
266 }
267
268 /*
269 * @unimplemented
270 */
271 VOID
272 STDCALL
273 IoInvalidateDeviceState(
274 IN PDEVICE_OBJECT PhysicalDeviceObject)
275 {
276 }
277
278 /**
279 * @name IoOpenDeviceRegistryKey
280 *
281 * Open a registry key unique for a specified driver or device instance.
282 *
283 * @param DeviceObject Device to get the registry key for.
284 * @param DevInstKeyType Type of the key to return.
285 * @param DesiredAccess Access mask (eg. KEY_READ | KEY_WRITE).
286 * @param DevInstRegKey Handle to the opened registry key on
287 * successful return.
288 *
289 * @return Status.
290 *
291 * @implemented
292 */
293 NTSTATUS
294 STDCALL
295 IoOpenDeviceRegistryKey(
296 IN PDEVICE_OBJECT DeviceObject,
297 IN ULONG DevInstKeyType,
298 IN ACCESS_MASK DesiredAccess,
299 OUT PHANDLE DevInstRegKey)
300 {
301 static WCHAR RootKeyName[] =
302 L"\\Registry\\Machine\\System\\CurrentControlSet\\";
303 static WCHAR ProfileKeyName[] =
304 L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
305 static WCHAR ClassKeyName[] = L"Control\\Class\\";
306 static WCHAR EnumKeyName[] = L"Enum\\";
307 static WCHAR DeviceParametersKeyName[] = L"Device Parameters\\";
308 ULONG KeyNameLength;
309 LPWSTR KeyNameBuffer;
310 UNICODE_STRING KeyName;
311 ULONG DriverKeyLength;
312 OBJECT_ATTRIBUTES ObjectAttributes;
313 PDEVICE_NODE DeviceNode = NULL;
314 NTSTATUS Status;
315
316 if ((DevInstKeyType & (PLUGPLAY_REGKEY_DEVICE | PLUGPLAY_REGKEY_DRIVER)) == 0)
317 return STATUS_INVALID_PARAMETER;
318
319 /*
320 * Calculate the length of the base key name. This is the full
321 * name for driver key or the name excluding "Device Parameters"
322 * subkey for device key.
323 */
324
325 KeyNameLength = sizeof(RootKeyName);
326 if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
327 KeyNameLength += sizeof(ProfileKeyName) - sizeof(UNICODE_NULL);
328 if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
329 {
330 KeyNameLength += sizeof(ClassKeyName) - sizeof(UNICODE_NULL);
331 Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
332 0, NULL, &DriverKeyLength);
333 if (Status != STATUS_BUFFER_TOO_SMALL)
334 return Status;
335 KeyNameLength += DriverKeyLength;
336 }
337 else
338 {
339 DeviceNode = IopGetDeviceNode(DeviceObject);
340 KeyNameLength += sizeof(EnumKeyName) - sizeof(UNICODE_NULL) +
341 DeviceNode->InstancePath.Length;
342 }
343
344 /*
345 * Now allocate the buffer for the key name...
346 */
347
348 KeyNameBuffer = ExAllocatePool(PagedPool, KeyNameLength);
349 if (KeyNameBuffer == NULL)
350 return STATUS_INSUFFICIENT_RESOURCES;
351
352 KeyName.Length = 0;
353 KeyName.MaximumLength = KeyNameLength;
354 KeyName.Buffer = KeyNameBuffer;
355
356 /*
357 * ...and build the key name.
358 */
359
360 KeyName.Length += sizeof(RootKeyName) - sizeof(UNICODE_NULL);
361 RtlCopyMemory(KeyNameBuffer, RootKeyName, KeyName.Length);
362
363 if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
364 RtlAppendUnicodeToString(&KeyName, ProfileKeyName);
365
366 if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
367 {
368 RtlAppendUnicodeToString(&KeyName, ClassKeyName);
369 Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
370 DriverKeyLength, KeyNameBuffer +
371 (KeyName.Length / sizeof(WCHAR)),
372 &DriverKeyLength);
373 if (!NT_SUCCESS(Status))
374 {
375 ExFreePool(KeyNameBuffer);
376 return Status;
377 }
378 KeyName.Length += DriverKeyLength - sizeof(UNICODE_NULL);
379 }
380 else
381 {
382 RtlAppendUnicodeToString(&KeyName, EnumKeyName);
383 Status = RtlAppendUnicodeStringToString(&KeyName, &DeviceNode->InstancePath);
384 if (DeviceNode->InstancePath.Length == 0)
385 {
386 ExFreePool(KeyNameBuffer);
387 return Status;
388 }
389 }
390
391 /*
392 * Open the base key.
393 */
394
395 InitializeObjectAttributes(&ObjectAttributes, &KeyName,
396 OBJ_CASE_INSENSITIVE, NULL, NULL);
397 Status = ZwOpenKey(DevInstRegKey, DesiredAccess, &ObjectAttributes);
398 ExFreePool(KeyNameBuffer);
399
400 /*
401 * For driver key we're done now. Also if the base key doesn't
402 * exist we can bail out with error...
403 */
404
405 if ((DevInstKeyType & PLUGPLAY_REGKEY_DRIVER) || !NT_SUCCESS(Status))
406 return Status;
407
408 /*
409 * Let's go further. For device key we must open "Device Parameters"
410 * subkey and create it if it doesn't exist yet.
411 */
412
413 RtlInitUnicodeString(&KeyName, DeviceParametersKeyName);
414 InitializeObjectAttributes(&ObjectAttributes, &KeyName,
415 OBJ_CASE_INSENSITIVE, *DevInstRegKey, NULL);
416 Status = ZwCreateKey(DevInstRegKey, DesiredAccess, &ObjectAttributes,
417 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
418 ZwClose(ObjectAttributes.RootDirectory);
419
420 return Status;
421 }
422
423 /*
424 * @unimplemented
425 */
426 VOID
427 STDCALL
428 IoRequestDeviceEject(
429 IN PDEVICE_OBJECT PhysicalDeviceObject
430 )
431 {
432 UNIMPLEMENTED;
433 }
434
435
436 BOOLEAN
437 IopCreateUnicodeString(
438 PUNICODE_STRING Destination,
439 PWSTR Source,
440 POOL_TYPE PoolType)
441 {
442 ULONG Length;
443
444 if (!Source)
445 {
446 RtlInitUnicodeString(Destination, NULL);
447 return TRUE;
448 }
449
450 Length = (wcslen(Source) + 1) * sizeof(WCHAR);
451
452 Destination->Buffer = ExAllocatePool(PoolType, Length);
453
454 if (Destination->Buffer == NULL)
455 {
456 return FALSE;
457 }
458
459 RtlCopyMemory(Destination->Buffer, Source, Length);
460
461 Destination->MaximumLength = Length;
462
463 Destination->Length = Length - sizeof(WCHAR);
464
465 return TRUE;
466 }
467
468 NTSTATUS
469 IopGetSystemPowerDeviceObject(PDEVICE_OBJECT *DeviceObject)
470 {
471 KIRQL OldIrql;
472
473 if (PopSystemPowerDeviceNode)
474 {
475 KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
476 *DeviceObject = PopSystemPowerDeviceNode->PhysicalDeviceObject;
477 KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
478
479 return STATUS_SUCCESS;
480 }
481
482 return STATUS_UNSUCCESSFUL;
483 }
484
485 /*
486 * DESCRIPTION
487 * Creates a device node
488 *
489 * ARGUMENTS
490 * ParentNode = Pointer to parent device node
491 * PhysicalDeviceObject = Pointer to PDO for device object. Pass NULL
492 * to have the root device node create one
493 * (eg. for legacy drivers)
494 * DeviceNode = Pointer to storage for created device node
495 *
496 * RETURN VALUE
497 * Status
498 */
499 NTSTATUS
500 IopCreateDeviceNode(PDEVICE_NODE ParentNode,
501 PDEVICE_OBJECT PhysicalDeviceObject,
502 PDEVICE_NODE *DeviceNode)
503 {
504 PDEVICE_NODE Node;
505 NTSTATUS Status;
506 KIRQL OldIrql;
507
508 DPRINT("ParentNode %x PhysicalDeviceObject %x\n",
509 ParentNode, PhysicalDeviceObject);
510
511 Node = (PDEVICE_NODE)ExAllocatePool(NonPagedPool, sizeof(DEVICE_NODE));
512 if (!Node)
513 {
514 return STATUS_INSUFFICIENT_RESOURCES;
515 }
516
517 RtlZeroMemory(Node, sizeof(DEVICE_NODE));
518
519 if (!PhysicalDeviceObject)
520 {
521 Status = PnpRootCreateDevice(&PhysicalDeviceObject);
522 if (!NT_SUCCESS(Status))
523 {
524 ExFreePool(Node);
525 return Status;
526 }
527
528 /* This is for drivers passed on the command line to ntoskrnl.exe */
529 IopDeviceNodeSetFlag(Node, DNF_STARTED);
530 IopDeviceNodeSetFlag(Node, DNF_LEGACY_DRIVER);
531 }
532
533 Node->PhysicalDeviceObject = PhysicalDeviceObject;
534
535 PhysicalDeviceObject->DeviceObjectExtension->DeviceNode = Node;
536
537 if (ParentNode)
538 {
539 KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
540 Node->Parent = ParentNode;
541 Node->NextSibling = ParentNode->Child;
542 if (ParentNode->Child != NULL)
543 {
544 ParentNode->Child->PrevSibling = Node;
545 }
546 ParentNode->Child = Node;
547 KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
548 }
549
550 *DeviceNode = Node;
551
552 return STATUS_SUCCESS;
553 }
554
555 NTSTATUS
556 IopFreeDeviceNode(PDEVICE_NODE DeviceNode)
557 {
558 KIRQL OldIrql;
559
560 /* All children must be deleted before a parent is deleted */
561 ASSERT(!DeviceNode->Child);
562
563 KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
564
565 ASSERT(DeviceNode->PhysicalDeviceObject);
566
567 ObDereferenceObject(DeviceNode->PhysicalDeviceObject);
568
569 /* Unlink from parent if it exists */
570
571 if ((DeviceNode->Parent) && (DeviceNode->Parent->Child == DeviceNode))
572 {
573 DeviceNode->Parent->Child = DeviceNode->NextSibling;
574 }
575
576 /* Unlink from sibling list */
577
578 if (DeviceNode->PrevSibling)
579 {
580 DeviceNode->PrevSibling->NextSibling = DeviceNode->NextSibling;
581 }
582
583 if (DeviceNode->NextSibling)
584 {
585 DeviceNode->NextSibling->PrevSibling = DeviceNode->PrevSibling;
586 }
587
588 KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
589
590 RtlFreeUnicodeString(&DeviceNode->InstancePath);
591
592 RtlFreeUnicodeString(&DeviceNode->ServiceName);
593
594 if (DeviceNode->ResourceList)
595 {
596 ExFreePool(DeviceNode->ResourceList);
597 }
598
599 if (DeviceNode->ResourceListTranslated)
600 {
601 ExFreePool(DeviceNode->ResourceListTranslated);
602 }
603
604 if (DeviceNode->ResourceRequirements)
605 {
606 ExFreePool(DeviceNode->ResourceRequirements);
607 }
608
609 if (DeviceNode->BootResources)
610 {
611 ExFreePool(DeviceNode->BootResources);
612 }
613
614 ExFreePool(DeviceNode);
615
616 return STATUS_SUCCESS;
617 }
618
619 NTSTATUS
620 IopInitiatePnpIrp(
621 PDEVICE_OBJECT DeviceObject,
622 PIO_STATUS_BLOCK IoStatusBlock,
623 ULONG MinorFunction,
624 PIO_STACK_LOCATION Stack OPTIONAL)
625 {
626 PDEVICE_OBJECT TopDeviceObject;
627 PIO_STACK_LOCATION IrpSp;
628 NTSTATUS Status;
629 KEVENT Event;
630 PIRP Irp;
631
632 /* Always call the top of the device stack */
633 TopDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
634
635 KeInitializeEvent(
636 &Event,
637 NotificationEvent,
638 FALSE);
639
640 Irp = IoBuildSynchronousFsdRequest(
641 IRP_MJ_PNP,
642 TopDeviceObject,
643 NULL,
644 0,
645 NULL,
646 &Event,
647 IoStatusBlock);
648
649 /* PNP IRPs are always initialized with a status code of
650 STATUS_NOT_IMPLEMENTED */
651 Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
652 Irp->IoStatus.Information = 0;
653
654 IrpSp = IoGetNextIrpStackLocation(Irp);
655 IrpSp->MinorFunction = MinorFunction;
656
657 if (Stack)
658 {
659 RtlMoveMemory(
660 &IrpSp->Parameters,
661 &Stack->Parameters,
662 sizeof(Stack->Parameters));
663 }
664
665 Status = IoCallDriver(TopDeviceObject, Irp);
666 if (Status == STATUS_PENDING)
667 {
668 KeWaitForSingleObject(
669 &Event,
670 Executive,
671 KernelMode,
672 FALSE,
673 NULL);
674 Status = IoStatusBlock->Status;
675 }
676
677 ObDereferenceObject(TopDeviceObject);
678
679 return Status;
680 }
681
682
683 NTSTATUS
684 IopTraverseDeviceTreeNode(
685 PDEVICETREE_TRAVERSE_CONTEXT Context)
686 {
687 PDEVICE_NODE ParentDeviceNode;
688 PDEVICE_NODE ChildDeviceNode;
689 NTSTATUS Status;
690
691 /* Copy context data so we don't overwrite it in subsequent calls to this function */
692 ParentDeviceNode = Context->DeviceNode;
693
694 /* Call the action routine */
695 Status = (Context->Action)(ParentDeviceNode, Context->Context);
696 if (!NT_SUCCESS(Status))
697 {
698 return Status;
699 }
700
701 /* Traversal of all children nodes */
702 for (ChildDeviceNode = ParentDeviceNode->Child;
703 ChildDeviceNode != NULL;
704 ChildDeviceNode = ChildDeviceNode->NextSibling)
705 {
706 /* Pass the current device node to the action routine */
707 Context->DeviceNode = ChildDeviceNode;
708
709 Status = IopTraverseDeviceTreeNode(Context);
710 if (!NT_SUCCESS(Status))
711 {
712 return Status;
713 }
714 }
715
716 return Status;
717 }
718
719
720 NTSTATUS
721 IopTraverseDeviceTree(
722 PDEVICETREE_TRAVERSE_CONTEXT Context)
723 {
724 NTSTATUS Status;
725
726 DPRINT("Context %x\n", Context);
727
728 DPRINT("IopTraverseDeviceTree(DeviceNode %x FirstDeviceNode %x Action %x Context %x)\n",
729 Context->DeviceNode, Context->FirstDeviceNode, Context->Action, Context->Context);
730
731 /* Start from the specified device node */
732 Context->DeviceNode = Context->FirstDeviceNode;
733
734 /* Recursively traverse the device tree */
735 Status = IopTraverseDeviceTreeNode(Context);
736 if (Status == STATUS_UNSUCCESSFUL)
737 {
738 /* The action routine just wanted to terminate the traversal with status
739 code STATUS_SUCCESS */
740 Status = STATUS_SUCCESS;
741 }
742
743 return Status;
744 }
745
746
747 static NTSTATUS
748 IopCreateDeviceKeyPath(PWSTR Path,
749 PHANDLE Handle)
750 {
751 OBJECT_ATTRIBUTES ObjectAttributes;
752 WCHAR KeyBuffer[MAX_PATH];
753 UNICODE_STRING KeyName;
754 HANDLE KeyHandle;
755 NTSTATUS Status;
756 PWCHAR Current;
757 PWCHAR Next;
758
759 *Handle = NULL;
760
761 if (_wcsnicmp(Path, L"\\Registry\\", 10) != 0)
762 {
763 return STATUS_INVALID_PARAMETER;
764 }
765
766 wcsncpy (KeyBuffer, Path, MAX_PATH-1);
767
768 /* Skip \\Registry\\ */
769 Current = KeyBuffer;
770 Current = wcschr (Current, L'\\') + 1;
771 Current = wcschr (Current, L'\\') + 1;
772
773 while (TRUE)
774 {
775 Next = wcschr (Current, L'\\');
776 if (Next == NULL)
777 {
778 /* The end */
779 }
780 else
781 {
782 *Next = 0;
783 }
784
785 RtlInitUnicodeString (&KeyName, KeyBuffer);
786 InitializeObjectAttributes (&ObjectAttributes,
787 &KeyName,
788 OBJ_CASE_INSENSITIVE,
789 NULL,
790 NULL);
791
792 DPRINT("Create '%S'\n", KeyName.Buffer);
793
794 Status = ZwCreateKey (&KeyHandle,
795 KEY_ALL_ACCESS,
796 &ObjectAttributes,
797 0,
798 NULL,
799 0,
800 NULL);
801 if (!NT_SUCCESS (Status))
802 {
803 DPRINT ("ZwCreateKey() failed with status %x\n", Status);
804 return Status;
805 }
806
807 if (Next == NULL)
808 {
809 *Handle = KeyHandle;
810 return STATUS_SUCCESS;
811 }
812 else
813 {
814 ZwClose (KeyHandle);
815 *Next = L'\\';
816 }
817
818 Current = Next + 1;
819 }
820
821 return STATUS_UNSUCCESSFUL;
822 }
823
824
825 static NTSTATUS
826 IopSetDeviceInstanceData(HANDLE InstanceKey,
827 PDEVICE_NODE DeviceNode)
828 {
829 OBJECT_ATTRIBUTES ObjectAttributes;
830 UNICODE_STRING KeyName;
831 HANDLE LogConfKey;
832 ULONG ResCount;
833 ULONG ListSize;
834 NTSTATUS Status;
835
836 DPRINT("IopSetDeviceInstanceData() called\n");
837
838 /* Create the 'LogConf' key */
839 RtlInitUnicodeString(&KeyName,
840 L"LogConf");
841 InitializeObjectAttributes(&ObjectAttributes,
842 &KeyName,
843 OBJ_CASE_INSENSITIVE,
844 InstanceKey,
845 NULL);
846 Status = ZwCreateKey(&LogConfKey,
847 KEY_ALL_ACCESS,
848 &ObjectAttributes,
849 0,
850 NULL,
851 0,
852 NULL);
853 if (NT_SUCCESS(Status))
854 {
855 /* Set 'BootConfig' value */
856 if (DeviceNode->BootResources != NULL)
857 {
858 ResCount = DeviceNode->BootResources->Count;
859 if (ResCount != 0)
860 {
861 ListSize = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
862
863 RtlInitUnicodeString(&KeyName,
864 L"BootConfig");
865 Status = ZwSetValueKey(LogConfKey,
866 &KeyName,
867 0,
868 REG_RESOURCE_LIST,
869 &DeviceNode->BootResources,
870 ListSize);
871 }
872 }
873
874 /* Set 'BasicConfigVector' value */
875 if (DeviceNode->ResourceRequirements != NULL &&
876 DeviceNode->ResourceRequirements->ListSize != 0)
877 {
878 RtlInitUnicodeString(&KeyName,
879 L"BasicConfigVector");
880 Status = ZwSetValueKey(LogConfKey,
881 &KeyName,
882 0,
883 REG_RESOURCE_REQUIREMENTS_LIST,
884 &DeviceNode->ResourceRequirements,
885 DeviceNode->ResourceRequirements->ListSize);
886 }
887
888 ZwClose(LogConfKey);
889 }
890
891 DPRINT("IopSetDeviceInstanceData() done\n");
892
893 return STATUS_SUCCESS;
894 }
895
896
897 /*
898 * IopActionInterrogateDeviceStack
899 *
900 * Retrieve information for all (direct) child nodes of a parent node.
901 *
902 * Parameters
903 * DeviceNode
904 * Pointer to device node.
905 * Context
906 * Pointer to parent node to retrieve child node information for.
907 *
908 * Remarks
909 * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
910 * when we reach a device node which is not a direct child of the device
911 * node for which we retrieve information of child nodes for. Any errors
912 * that occur is logged instead so that all child services have a chance
913 * of being interrogated.
914 */
915
916 NTSTATUS
917 IopActionInterrogateDeviceStack(
918 PDEVICE_NODE DeviceNode,
919 PVOID Context)
920 {
921 IO_STATUS_BLOCK IoStatusBlock;
922 PDEVICE_NODE ParentDeviceNode;
923 WCHAR InstancePath[MAX_PATH];
924 IO_STACK_LOCATION Stack;
925 NTSTATUS Status;
926 PWSTR KeyBuffer;
927 PWSTR Ptr;
928 USHORT Length;
929 USHORT TotalLength;
930 HANDLE InstanceKey = NULL;
931 UNICODE_STRING ValueName;
932 DEVICE_CAPABILITIES DeviceCapabilities;
933
934 DPRINT("IopActionInterrogateDeviceStack(%p, %p)\n", DeviceNode, Context);
935 DPRINT("PDO %x\n", DeviceNode->PhysicalDeviceObject);
936
937 ParentDeviceNode = (PDEVICE_NODE)Context;
938
939 /*
940 * We are called for the parent too, but we don't need to do special
941 * handling for this node
942 */
943
944 if (DeviceNode == ParentDeviceNode)
945 {
946 DPRINT("Success\n");
947 return STATUS_SUCCESS;
948 }
949
950 /*
951 * Make sure this device node is a direct child of the parent device node
952 * that is given as an argument
953 */
954
955 if (DeviceNode->Parent != ParentDeviceNode)
956 {
957 /* Stop the traversal immediately and indicate successful operation */
958 DPRINT("Stop\n");
959 return STATUS_UNSUCCESSFUL;
960 }
961
962 /*
963 * FIXME: For critical errors, cleanup and disable device, but always
964 * return STATUS_SUCCESS.
965 */
966
967 DPRINT("Sending IRP_MN_QUERY_ID.BusQueryDeviceID to device stack\n");
968
969 Stack.Parameters.QueryId.IdType = BusQueryDeviceID;
970 Status = IopInitiatePnpIrp(
971 DeviceNode->PhysicalDeviceObject,
972 &IoStatusBlock,
973 IRP_MN_QUERY_ID,
974 &Stack);
975 if (NT_SUCCESS(Status))
976 {
977 /* Copy the device id string */
978 wcscpy(InstancePath, (PWSTR)IoStatusBlock.Information);
979
980 /*
981 * FIXME: Check for valid characters, if there is invalid characters
982 * then bugcheck.
983 */
984 }
985 else
986 {
987 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
988 }
989
990 DPRINT("Sending IRP_MN_QUERY_ID.BusQueryInstanceID to device stack\n");
991
992 Stack.Parameters.QueryId.IdType = BusQueryInstanceID;
993 Status = IopInitiatePnpIrp(
994 DeviceNode->PhysicalDeviceObject,
995 &IoStatusBlock,
996 IRP_MN_QUERY_ID,
997 &Stack);
998 if (NT_SUCCESS(Status))
999 {
1000 /* Append the instance id string */
1001 wcscat(InstancePath, L"\\");
1002 wcscat(InstancePath, (PWSTR)IoStatusBlock.Information);
1003
1004 /*
1005 * FIXME: Check for valid characters, if there is invalid characters
1006 * then bugcheck
1007 */
1008 }
1009 else
1010 {
1011 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1012 }
1013
1014 RtlZeroMemory(&DeviceCapabilities, sizeof(DEVICE_CAPABILITIES));
1015 DeviceCapabilities.Size = sizeof(DEVICE_CAPABILITIES);
1016 DeviceCapabilities.Version = 1;
1017 DeviceCapabilities.Address = -1;
1018 DeviceCapabilities.UINumber = -1;
1019
1020 Stack.Parameters.DeviceCapabilities.Capabilities = &DeviceCapabilities;
1021 Status = IopInitiatePnpIrp(
1022 DeviceNode->PhysicalDeviceObject,
1023 &IoStatusBlock,
1024 IRP_MN_QUERY_CAPABILITIES,
1025 &Stack);
1026 if (NT_SUCCESS(Status))
1027 {
1028 }
1029 else
1030 {
1031 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1032 }
1033
1034 DeviceNode->CapabilityFlags = *(PULONG)((ULONG_PTR)&DeviceCapabilities + 4);
1035 DeviceNode->Address = DeviceCapabilities.Address;
1036
1037 if (!DeviceCapabilities.UniqueID)
1038 {
1039 DPRINT("Instance ID is not unique\n");
1040 /* FIXME: Add information from parent bus driver to InstancePath */
1041 }
1042
1043 if (!IopCreateUnicodeString(&DeviceNode->InstancePath, InstancePath, PagedPool))
1044 {
1045 DPRINT("No resources\n");
1046 /* FIXME: Cleanup and disable device */
1047 }
1048
1049 DPRINT("InstancePath is %S\n", DeviceNode->InstancePath.Buffer);
1050
1051 /*
1052 * Create registry key for the instance id, if it doesn't exist yet
1053 */
1054 KeyBuffer = ExAllocatePool(
1055 PagedPool,
1056 (49 * sizeof(WCHAR)) + DeviceNode->InstancePath.Length);
1057 wcscpy(KeyBuffer, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
1058 wcscat(KeyBuffer, DeviceNode->InstancePath.Buffer);
1059 Status = IopCreateDeviceKeyPath(KeyBuffer,
1060 &InstanceKey);
1061 ExFreePool(KeyBuffer);
1062 if (!NT_SUCCESS(Status))
1063 {
1064 DPRINT1("Failed to create the instance key! (Status %lx)\n", Status);
1065 }
1066
1067
1068 {
1069 /* Set 'Capabilities' value */
1070 RtlInitUnicodeString(&ValueName,
1071 L"Capabilities");
1072 Status = ZwSetValueKey(InstanceKey,
1073 &ValueName,
1074 0,
1075 REG_DWORD,
1076 (PVOID)&DeviceNode->CapabilityFlags,
1077 sizeof(ULONG));
1078
1079 /* Set 'UINumber' value */
1080 if (DeviceCapabilities.UINumber != (ULONG)-1)
1081 {
1082 RtlInitUnicodeString(&ValueName,
1083 L"UINumber");
1084 Status = ZwSetValueKey(InstanceKey,
1085 &ValueName,
1086 0,
1087 REG_DWORD,
1088 &DeviceCapabilities.UINumber,
1089 sizeof(ULONG));
1090 }
1091 }
1092
1093 DPRINT("Sending IRP_MN_QUERY_ID.BusQueryHardwareIDs to device stack\n");
1094
1095 Stack.Parameters.QueryId.IdType = BusQueryHardwareIDs;
1096 Status = IopInitiatePnpIrp(
1097 DeviceNode->PhysicalDeviceObject,
1098 &IoStatusBlock,
1099 IRP_MN_QUERY_ID,
1100 &Stack);
1101 if (NT_SUCCESS(Status))
1102 {
1103 /*
1104 * FIXME: Check for valid characters, if there is invalid characters
1105 * then bugcheck.
1106 */
1107 TotalLength = 0;
1108 Ptr = (PWSTR)IoStatusBlock.Information;
1109 DPRINT("Hardware IDs:\n");
1110 while (*Ptr)
1111 {
1112 DPRINT(" %S\n", Ptr);
1113 Length = wcslen(Ptr) + 1;
1114
1115 Ptr += Length;
1116 TotalLength += Length;
1117 }
1118 DPRINT("TotalLength: %hu\n", TotalLength);
1119 DPRINT("\n");
1120
1121 RtlInitUnicodeString(&ValueName,
1122 L"HardwareID");
1123 Status = ZwSetValueKey(InstanceKey,
1124 &ValueName,
1125 0,
1126 REG_MULTI_SZ,
1127 (PVOID)IoStatusBlock.Information,
1128 (TotalLength + 1) * sizeof(WCHAR));
1129 if (!NT_SUCCESS(Status))
1130 {
1131 DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
1132 }
1133 }
1134 else
1135 {
1136 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1137 }
1138
1139 DPRINT("Sending IRP_MN_QUERY_ID.BusQueryCompatibleIDs to device stack\n");
1140
1141 Stack.Parameters.QueryId.IdType = BusQueryCompatibleIDs;
1142 Status = IopInitiatePnpIrp(
1143 DeviceNode->PhysicalDeviceObject,
1144 &IoStatusBlock,
1145 IRP_MN_QUERY_ID,
1146 &Stack);
1147 if (NT_SUCCESS(Status))
1148 {
1149 /*
1150 * FIXME: Check for valid characters, if there is invalid characters
1151 * then bugcheck.
1152 */
1153 TotalLength = 0;
1154 Ptr = (PWSTR)IoStatusBlock.Information;
1155 DPRINT("Compatible IDs:\n");
1156 while (*Ptr)
1157 {
1158 DPRINT(" %S\n", Ptr);
1159 Length = wcslen(Ptr) + 1;
1160
1161 Ptr += Length;
1162 TotalLength += Length;
1163 }
1164 DPRINT("TotalLength: %hu\n", TotalLength);
1165 DPRINT("\n");
1166
1167 RtlInitUnicodeString(&ValueName,
1168 L"CompatibleIDs");
1169 Status = ZwSetValueKey(InstanceKey,
1170 &ValueName,
1171 0,
1172 REG_MULTI_SZ,
1173 (PVOID)IoStatusBlock.Information,
1174 (TotalLength + 1) * sizeof(WCHAR));
1175 if (!NT_SUCCESS(Status))
1176 {
1177 DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
1178 }
1179 }
1180 else
1181 {
1182 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1183 }
1184
1185
1186 DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextDescription to device stack\n");
1187
1188 Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextDescription;
1189 Stack.Parameters.QueryDeviceText.LocaleId = 0; /* FIXME */
1190 Status = IopInitiatePnpIrp(
1191 DeviceNode->PhysicalDeviceObject,
1192 &IoStatusBlock,
1193 IRP_MN_QUERY_DEVICE_TEXT,
1194 &Stack);
1195 if (NT_SUCCESS(Status))
1196 {
1197 RtlInitUnicodeString(&ValueName,
1198 L"DeviceDesc");
1199 Status = ZwSetValueKey(InstanceKey,
1200 &ValueName,
1201 0,
1202 REG_SZ,
1203 (PVOID)IoStatusBlock.Information,
1204 (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
1205 if (!NT_SUCCESS(Status))
1206 {
1207 DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
1208 }
1209 }
1210 else
1211 {
1212 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1213 }
1214
1215 DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextLocation to device stack\n");
1216
1217 Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextLocationInformation;
1218 Stack.Parameters.QueryDeviceText.LocaleId = 0; // FIXME
1219 Status = IopInitiatePnpIrp(
1220 DeviceNode->PhysicalDeviceObject,
1221 &IoStatusBlock,
1222 IRP_MN_QUERY_DEVICE_TEXT,
1223 &Stack);
1224 if (NT_SUCCESS(Status))
1225 {
1226 DPRINT("LocationInformation: %S\n", (PWSTR)IoStatusBlock.Information);
1227 RtlInitUnicodeString(&ValueName,
1228 L"LocationInformation");
1229 Status = ZwSetValueKey(InstanceKey,
1230 &ValueName,
1231 0,
1232 REG_SZ,
1233 (PVOID)IoStatusBlock.Information,
1234 (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
1235 if (!NT_SUCCESS(Status))
1236 {
1237 DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
1238 }
1239 }
1240 else
1241 {
1242 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1243 }
1244
1245 DPRINT("Sending IRP_MN_QUERY_BUS_INFORMATION to device stack\n");
1246
1247 Status = IopInitiatePnpIrp(
1248 DeviceNode->PhysicalDeviceObject,
1249 &IoStatusBlock,
1250 IRP_MN_QUERY_BUS_INFORMATION,
1251 NULL);
1252 if (NT_SUCCESS(Status))
1253 {
1254 PPNP_BUS_INFORMATION BusInformation =
1255 (PPNP_BUS_INFORMATION)IoStatusBlock.Information;
1256
1257 DeviceNode->ChildBusNumber = BusInformation->BusNumber;
1258 DeviceNode->ChildInterfaceType = BusInformation->LegacyBusType;
1259 memcpy(&DeviceNode->BusTypeGuid,
1260 &BusInformation->BusTypeGuid,
1261 sizeof(GUID));
1262 ExFreePool(BusInformation);
1263 }
1264 else
1265 {
1266 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1267
1268 DeviceNode->ChildBusNumber = -1;
1269 DeviceNode->ChildInterfaceType = -1;
1270 memset(&DeviceNode->BusTypeGuid,
1271 0,
1272 sizeof(GUID));
1273 }
1274
1275 DPRINT("Sending IRP_MN_QUERY_RESOURCES to device stack\n");
1276
1277 Status = IopInitiatePnpIrp(
1278 DeviceNode->PhysicalDeviceObject,
1279 &IoStatusBlock,
1280 IRP_MN_QUERY_RESOURCES,
1281 NULL);
1282 if (NT_SUCCESS(Status))
1283 {
1284 DeviceNode->BootResources =
1285 (PCM_RESOURCE_LIST)IoStatusBlock.Information;
1286 DeviceNode->Flags |= DNF_HAS_BOOT_CONFIG;
1287 }
1288 else
1289 {
1290 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1291 DeviceNode->BootResources = NULL;
1292 }
1293
1294 DPRINT("Sending IRP_MN_QUERY_RESOURCE_REQUIREMENTS to device stack\n");
1295
1296 Status = IopInitiatePnpIrp(
1297 DeviceNode->PhysicalDeviceObject,
1298 &IoStatusBlock,
1299 IRP_MN_QUERY_RESOURCE_REQUIREMENTS,
1300 NULL);
1301 if (NT_SUCCESS(Status))
1302 {
1303 DeviceNode->ResourceRequirements =
1304 (PIO_RESOURCE_REQUIREMENTS_LIST)IoStatusBlock.Information;
1305 }
1306 else
1307 {
1308 DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
1309 DeviceNode->ResourceRequirements = NULL;
1310 }
1311
1312
1313 if (InstanceKey != NULL)
1314 {
1315 IopSetDeviceInstanceData(InstanceKey, DeviceNode);
1316 }
1317
1318 ZwClose(InstanceKey);
1319
1320 DeviceNode->Flags |= DNF_PROCESSED;
1321
1322 /* Report the device to the user-mode pnp manager */
1323 IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
1324 &DeviceNode->InstancePath);
1325
1326 return STATUS_SUCCESS;
1327 }
1328
1329 /*
1330 * IopActionConfigureChildServices
1331 *
1332 * Retrieve configuration for all (direct) child nodes of a parent node.
1333 *
1334 * Parameters
1335 * DeviceNode
1336 * Pointer to device node.
1337 * Context
1338 * Pointer to parent node to retrieve child node configuration for.
1339 *
1340 * Remarks
1341 * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
1342 * when we reach a device node which is not a direct child of the device
1343 * node for which we configure child services for. Any errors that occur is
1344 * logged instead so that all child services have a chance of beeing
1345 * configured.
1346 */
1347
1348 NTSTATUS
1349 IopActionConfigureChildServices(
1350 PDEVICE_NODE DeviceNode,
1351 PVOID Context)
1352 {
1353 RTL_QUERY_REGISTRY_TABLE QueryTable[2];
1354 PDEVICE_NODE ParentDeviceNode;
1355 PUNICODE_STRING Service;
1356 NTSTATUS Status;
1357
1358 DPRINT("IopActionConfigureChildServices(%p, %p)\n", DeviceNode, Context);
1359
1360 ParentDeviceNode = (PDEVICE_NODE)Context;
1361
1362 /*
1363 * We are called for the parent too, but we don't need to do special
1364 * handling for this node
1365 */
1366 if (DeviceNode == ParentDeviceNode)
1367 {
1368 DPRINT("Success\n");
1369 return STATUS_SUCCESS;
1370 }
1371
1372 /*
1373 * Make sure this device node is a direct child of the parent device node
1374 * that is given as an argument
1375 */
1376 if (DeviceNode->Parent != ParentDeviceNode)
1377 {
1378 /* Stop the traversal immediately and indicate successful operation */
1379 DPRINT("Stop\n");
1380 return STATUS_UNSUCCESSFUL;
1381 }
1382
1383 if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED))
1384 {
1385 WCHAR RegKeyBuffer[MAX_PATH];
1386 UNICODE_STRING RegKey;
1387
1388 RegKey.Length = 0;
1389 RegKey.MaximumLength = sizeof(RegKeyBuffer);
1390 RegKey.Buffer = RegKeyBuffer;
1391
1392 /*
1393 * Retrieve configuration from Enum key
1394 */
1395
1396 Service = &DeviceNode->ServiceName;
1397
1398 RtlZeroMemory(QueryTable, sizeof(QueryTable));
1399 RtlInitUnicodeString(Service, NULL);
1400
1401 QueryTable[0].Name = L"Service";
1402 QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
1403 QueryTable[0].EntryContext = Service;
1404
1405 RtlAppendUnicodeToString(&RegKey, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
1406 RtlAppendUnicodeStringToString(&RegKey, &DeviceNode->InstancePath);
1407
1408 Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
1409 RegKey.Buffer, QueryTable, NULL, NULL);
1410
1411 if (!NT_SUCCESS(Status))
1412 {
1413 DPRINT("RtlQueryRegistryValues() failed (Status %x)\n", Status);
1414 /* FIXME: Log the error */
1415 CPRINT("Could not retrieve configuration for device %S (Status %x)\n",
1416 DeviceNode->InstancePath.Buffer, Status);
1417 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1418 return STATUS_SUCCESS;
1419 }
1420
1421 if (Service->Buffer == NULL)
1422 {
1423 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1424 return STATUS_SUCCESS;
1425 }
1426
1427 DPRINT("Got Service %S\n", Service->Buffer);
1428 }
1429
1430 return STATUS_SUCCESS;
1431 }
1432
1433 /*
1434 * IopActionInitChildServices
1435 *
1436 * Initialize the service for all (direct) child nodes of a parent node
1437 *
1438 * Parameters
1439 * DeviceNode
1440 * Pointer to device node.
1441 * Context
1442 * Pointer to parent node to initialize child node services for.
1443 * BootDrivers
1444 * Load only driver marked as boot start.
1445 *
1446 * Remarks
1447 * If the driver image for a service is not loaded and initialized
1448 * it is done here too. We only return a status code indicating an
1449 * error (STATUS_UNSUCCESSFUL) when we reach a device node which is
1450 * not a direct child of the device node for which we initialize
1451 * child services for. Any errors that occur is logged instead so
1452 * that all child services have a chance of being initialized.
1453 */
1454
1455 NTSTATUS
1456 IopActionInitChildServices(
1457 PDEVICE_NODE DeviceNode,
1458 PVOID Context,
1459 BOOLEAN BootDrivers)
1460 {
1461 PDEVICE_NODE ParentDeviceNode;
1462 NTSTATUS Status;
1463
1464 DPRINT("IopActionInitChildServices(%p, %p, %d)\n", DeviceNode, Context,
1465 BootDrivers);
1466
1467 ParentDeviceNode = (PDEVICE_NODE)Context;
1468
1469 /*
1470 * We are called for the parent too, but we don't need to do special
1471 * handling for this node
1472 */
1473 if (DeviceNode == ParentDeviceNode)
1474 {
1475 DPRINT("Success\n");
1476 return STATUS_SUCCESS;
1477 }
1478
1479 /*
1480 * Make sure this device node is a direct child of the parent device node
1481 * that is given as an argument
1482 */
1483 #if 0
1484 if (DeviceNode->Parent != ParentDeviceNode)
1485 {
1486 /*
1487 * Stop the traversal immediately and indicate unsuccessful operation
1488 */
1489 DPRINT("Stop\n");
1490 return STATUS_UNSUCCESSFUL;
1491 }
1492 #endif
1493
1494 if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED) &&
1495 !IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) &&
1496 !IopDeviceNodeHasFlag(DeviceNode, DNF_STARTED))
1497 {
1498 PMODULE_OBJECT ModuleObject;
1499 PDRIVER_OBJECT DriverObject;
1500
1501 Status = IopLoadServiceModule(&DeviceNode->ServiceName, &ModuleObject);
1502 if (NT_SUCCESS(Status))
1503 {
1504 Status = IopInitializeDriverModule(DeviceNode, ModuleObject, FALSE, &DriverObject);
1505 if (NT_SUCCESS(Status))
1506 {
1507 /* Attach lower level filter drivers. */
1508 IopAttachFilterDrivers(DeviceNode, TRUE);
1509 /* Initialize the function driver for the device node */
1510 Status = IopInitializeDevice(DeviceNode, DriverObject);
1511 if (NT_SUCCESS(Status))
1512 {
1513 IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
1514 /* Attach upper level filter drivers. */
1515 IopAttachFilterDrivers(DeviceNode, FALSE);
1516 }
1517 }
1518 }
1519 else
1520 {
1521 /*
1522 * Don't disable when trying to load only boot drivers
1523 */
1524 if (!BootDrivers)
1525 {
1526 IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
1527 IopDeviceNodeSetFlag(DeviceNode, DNF_START_FAILED);
1528 }
1529 /* FIXME: Log the error (possibly in IopInitializeDeviceNodeService) */
1530 CPRINT("Initialization of service %S failed (Status %x)\n",
1531 DeviceNode->ServiceName.Buffer, Status);
1532 }
1533 } else
1534 {
1535 DPRINT("Service %S is disabled or already initialized\n",
1536 DeviceNode->ServiceName.Buffer);
1537 }
1538
1539 return STATUS_SUCCESS;
1540 }
1541
1542 /*
1543 * IopActionInitAllServices
1544 *
1545 * Initialize the service for all (direct) child nodes of a parent node. This
1546 * function just calls IopActionInitChildServices with BootDrivers = FALSE.
1547 */
1548
1549 NTSTATUS
1550 IopActionInitAllServices(
1551 PDEVICE_NODE DeviceNode,
1552 PVOID Context)
1553 {
1554 return IopActionInitChildServices(DeviceNode, Context, FALSE);
1555 }
1556
1557 /*
1558 * IopActionInitBootServices
1559 *
1560 * Initialize the boot start services for all (direct) child nodes of a
1561 * parent node. This function just calls IopActionInitChildServices with
1562 * BootDrivers = TRUE.
1563 */
1564 NTSTATUS
1565 IopActionInitBootServices(
1566 PDEVICE_NODE DeviceNode,
1567 PVOID Context)
1568 {
1569 return IopActionInitChildServices(DeviceNode, Context, TRUE);
1570 }
1571
1572 /*
1573 * IopInitializePnpServices
1574 *
1575 * Initialize services for discovered children
1576 *
1577 * Parameters
1578 * DeviceNode
1579 * Top device node to start initializing services.
1580 *
1581 * BootDrivers
1582 * When set to TRUE, only drivers marked as boot start will
1583 * be loaded. Otherwise, all drivers will be loaded.
1584 *
1585 * Return Value
1586 * Status
1587 */
1588 NTSTATUS
1589 IopInitializePnpServices(
1590 IN PDEVICE_NODE DeviceNode,
1591 IN BOOLEAN BootDrivers)
1592 {
1593 DEVICETREE_TRAVERSE_CONTEXT Context;
1594
1595 DPRINT("IopInitializePnpServices(%p, %d)\n", DeviceNode, BootDrivers);
1596
1597 if (BootDrivers)
1598 {
1599 IopInitDeviceTreeTraverseContext(
1600 &Context,
1601 DeviceNode,
1602 IopActionInitBootServices,
1603 DeviceNode);
1604 } else
1605 {
1606 IopInitDeviceTreeTraverseContext(
1607 &Context,
1608 DeviceNode,
1609 IopActionInitAllServices,
1610 DeviceNode);
1611 }
1612
1613 return IopTraverseDeviceTree(&Context);
1614 }
1615
1616
1617 NTSTATUS
1618 IopInvalidateDeviceRelations(
1619 IN PDEVICE_NODE DeviceNode,
1620 IN DEVICE_RELATION_TYPE Type)
1621 {
1622 DEVICETREE_TRAVERSE_CONTEXT Context;
1623 PDEVICE_RELATIONS DeviceRelations;
1624 IO_STATUS_BLOCK IoStatusBlock;
1625 PDEVICE_NODE ChildDeviceNode;
1626 IO_STACK_LOCATION Stack;
1627 BOOL BootDrivers;
1628 OBJECT_ATTRIBUTES ObjectAttributes;
1629 UNICODE_STRING LinkName;
1630 HANDLE Handle;
1631 NTSTATUS Status;
1632 ULONG i;
1633
1634 DPRINT("DeviceNode %x\n", DeviceNode);
1635
1636 DPRINT("Sending IRP_MN_QUERY_DEVICE_RELATIONS to device stack\n");
1637
1638 Stack.Parameters.QueryDeviceRelations.Type = Type/*BusRelations*/;
1639
1640 Status = IopInitiatePnpIrp(
1641 DeviceNode->PhysicalDeviceObject,
1642 &IoStatusBlock,
1643 IRP_MN_QUERY_DEVICE_RELATIONS,
1644 &Stack);
1645 if (!NT_SUCCESS(Status))
1646 {
1647 DPRINT("IopInitiatePnpIrp() failed\n");
1648 return Status;
1649 }
1650
1651 DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
1652
1653 if ((!DeviceRelations) || (DeviceRelations->Count <= 0))
1654 {
1655 DPRINT("No PDOs\n");
1656 if (DeviceRelations)
1657 {
1658 ExFreePool(DeviceRelations);
1659 }
1660 return STATUS_SUCCESS;
1661 }
1662
1663 DPRINT("Got %d PDOs\n", DeviceRelations->Count);
1664
1665 /*
1666 * Create device nodes for all discovered devices
1667 */
1668
1669 for (i = 0; i < DeviceRelations->Count; i++)
1670 {
1671 Status = IopCreateDeviceNode(
1672 DeviceNode,
1673 DeviceRelations->Objects[i],
1674 &ChildDeviceNode);
1675 DeviceNode->Flags |= DNF_ENUMERATED;
1676 if (!NT_SUCCESS(Status))
1677 {
1678 DPRINT("No resources\n");
1679 for (i = 0; i < DeviceRelations->Count; i++)
1680 ObDereferenceObject(DeviceRelations->Objects[i]);
1681 ExFreePool(DeviceRelations);
1682 return STATUS_INSUFFICIENT_RESOURCES;
1683 }
1684 }
1685 ExFreePool(DeviceRelations);
1686
1687 /*
1688 * Retrieve information about all discovered children from the bus driver
1689 */
1690
1691 IopInitDeviceTreeTraverseContext(
1692 &Context,
1693 DeviceNode,
1694 IopActionInterrogateDeviceStack,
1695 DeviceNode);
1696
1697 Status = IopTraverseDeviceTree(&Context);
1698 if (!NT_SUCCESS(Status))
1699 {
1700 DPRINT("IopTraverseDeviceTree() failed with status (%x)\n", Status);
1701 return Status;
1702 }
1703
1704 /*
1705 * Retrieve configuration from the registry for discovered children
1706 */
1707
1708 IopInitDeviceTreeTraverseContext(
1709 &Context,
1710 DeviceNode,
1711 IopActionConfigureChildServices,
1712 DeviceNode);
1713
1714 Status = IopTraverseDeviceTree(&Context);
1715 if (!NT_SUCCESS(Status))
1716 {
1717 DPRINT("IopTraverseDeviceTree() failed with status (%x)\n", Status);
1718 return Status;
1719 }
1720
1721 /*
1722 * Get the state of the system boot. If the \\SystemRoot link isn't
1723 * created yet, we will assume that it's possible to load only boot
1724 * drivers.
1725 */
1726
1727 RtlInitUnicodeString(&LinkName, L"\\SystemRoot");
1728
1729 InitializeObjectAttributes(
1730 &ObjectAttributes,
1731 &LinkName,
1732 0,
1733 NULL,
1734 NULL);
1735
1736 Status = ZwOpenFile(
1737 &Handle,
1738 FILE_ALL_ACCESS,
1739 &ObjectAttributes,
1740 &IoStatusBlock,
1741 0,
1742 0);
1743 if(NT_SUCCESS(Status))
1744 {
1745 BootDrivers = FALSE;
1746 ZwClose(Handle);
1747 }
1748 else
1749 BootDrivers = TRUE;
1750
1751 /*
1752 * Initialize services for discovered children. Only boot drivers will
1753 * be loaded from boot driver!
1754 */
1755
1756 Status = IopInitializePnpServices(DeviceNode, BootDrivers);
1757 if (!NT_SUCCESS(Status))
1758 {
1759 DPRINT("IopInitializePnpServices() failed with status (%x)\n", Status);
1760 return Status;
1761 }
1762
1763 return STATUS_SUCCESS;
1764 }
1765
1766
1767 VOID INIT_FUNCTION
1768 PnpInit(VOID)
1769 {
1770 PDEVICE_OBJECT Pdo;
1771 NTSTATUS Status;
1772
1773 DPRINT("PnpInit()\n");
1774
1775 KeInitializeSpinLock(&IopDeviceTreeLock);
1776
1777 /* Initialize PnP-Event notification support */
1778 Status = IopInitPlugPlayEvents();
1779 if (!NT_SUCCESS(Status))
1780 {
1781 CPRINT("IopInitPlugPlayEvents() failed\n");
1782 KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
1783 }
1784
1785 /*
1786 * Create root device node
1787 */
1788
1789 Status = IopCreateDriverObject(&IopRootDriverObject, NULL, FALSE, NULL, 0);
1790 if (!NT_SUCCESS(Status))
1791 {
1792 CPRINT("IoCreateDriverObject() failed\n");
1793 KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
1794 }
1795
1796 Status = IoCreateDevice(IopRootDriverObject, 0, NULL, FILE_DEVICE_CONTROLLER,
1797 0, FALSE, &Pdo);
1798 if (!NT_SUCCESS(Status))
1799 {
1800 CPRINT("IoCreateDevice() failed\n");
1801 KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
1802 }
1803
1804 Status = IopCreateDeviceNode(NULL, Pdo, &IopRootDeviceNode);
1805 if (!NT_SUCCESS(Status))
1806 {
1807 CPRINT("Insufficient resources\n");
1808 KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
1809 }
1810
1811 if (!IopCreateUnicodeString(&IopRootDeviceNode->InstancePath,
1812 L"HTREE\\Root\\0",
1813 PagedPool))
1814 {
1815 CPRINT("Failed to create the instance path!\n");
1816 KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, STATUS_UNSUCCESSFUL, 0, 0, 0);
1817 }
1818
1819 /* Report the device to the user-mode pnp manager */
1820 IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
1821 &IopRootDeviceNode->InstancePath);
1822
1823 IopRootDeviceNode->PhysicalDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
1824 PnpRootDriverEntry(IopRootDriverObject, NULL);
1825 IopRootDriverObject->DriverExtension->AddDevice(
1826 IopRootDriverObject,
1827 IopRootDeviceNode->PhysicalDeviceObject);
1828 }
1829
1830 /* EOF */