[NTOS:IO]
[reactos.git] / reactos / ntoskrnl / io / pnpmgr / pnpinit.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: ntoskrnl/io/pnpmgr/pnpinit.c
5 * PURPOSE: PnP Initialization Code
6 * PROGRAMMERS: ReactOS Portable Systems Group
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 /* GLOBALS ********************************************************************/
16
17 typedef struct _IOPNP_DEVICE_EXTENSION
18 {
19 PWCHAR CompatibleIdList;
20 ULONG CompatibleIdListSize;
21 } IOPNP_DEVICE_EXTENSION, *PIOPNP_DEVICE_EXTENSION;
22
23 PUNICODE_STRING PiInitGroupOrderTable;
24 USHORT PiInitGroupOrderTableCount;
25 INTERFACE_TYPE PnpDefaultInterfaceType;
26
27 /* FUNCTIONS ******************************************************************/
28
29 INTERFACE_TYPE
30 NTAPI
31 IopDetermineDefaultInterfaceType(VOID)
32 {
33 /* FIXME: ReactOS doesn't support MicroChannel yet */
34 return Isa;
35 }
36
37 NTSTATUS
38 NTAPI
39 IopInitializeArbiters(VOID)
40 {
41 /* FIXME: TODO */
42 return STATUS_SUCCESS;
43 }
44
45 NTSTATUS
46 NTAPI
47 INIT_FUNCTION
48 PiInitCacheGroupInformation(VOID)
49 {
50 HANDLE KeyHandle;
51 NTSTATUS Status;
52 PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
53 PUNICODE_STRING GroupTable;
54 ULONG Count;
55 UNICODE_STRING GroupString =
56 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet"
57 L"\\Control\\ServiceGroupOrder");
58
59 /* ReactOS HACK for SETUPLDR */
60 if (KeLoaderBlock->SetupLdrBlock)
61 {
62 DPRINT1("WARNING!! In PiInitCacheGroupInformation, using ReactOS HACK for SETUPLDR!!\n");
63
64 /* Bogus data */
65 PiInitGroupOrderTableCount = 0;
66 PiInitGroupOrderTable = (PVOID)0xBABEB00B;
67 return STATUS_SUCCESS;
68 }
69
70 /* Open the registry key */
71 Status = IopOpenRegistryKeyEx(&KeyHandle,
72 NULL,
73 &GroupString,
74 KEY_READ);
75 if (NT_SUCCESS(Status))
76 {
77 /* Get the list */
78 Status = IopGetRegistryValue(KeyHandle, L"List", &KeyValueInformation);
79 ZwClose(KeyHandle);
80
81 /* Make sure we got it */
82 if (NT_SUCCESS(Status))
83 {
84 /* Make sure it's valid */
85 if ((KeyValueInformation->Type == REG_MULTI_SZ) &&
86 (KeyValueInformation->DataLength))
87 {
88 /* Convert it to unicode strings */
89 Status = PnpRegMultiSzToUnicodeStrings(KeyValueInformation,
90 &GroupTable,
91 &Count);
92
93 /* Cache it for later */
94 PiInitGroupOrderTable = GroupTable;
95 PiInitGroupOrderTableCount = (USHORT)Count;
96 }
97 else
98 {
99 /* Fail */
100 Status = STATUS_UNSUCCESSFUL;
101 }
102
103 /* Free the information */
104 ExFreePool(KeyValueInformation);
105 }
106 }
107
108 /* Return status */
109 return Status;
110 }
111
112 USHORT
113 NTAPI
114 PpInitGetGroupOrderIndex(IN HANDLE ServiceHandle)
115 {
116 NTSTATUS Status;
117 PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
118 USHORT i;
119 PVOID Buffer;
120 UNICODE_STRING Group;
121 PAGED_CODE();
122
123 /* Make sure we have a cache */
124 if (!PiInitGroupOrderTable) return -1;
125
126 /* If we don't have a handle, the rest is easy -- return the count */
127 if (!ServiceHandle) return PiInitGroupOrderTableCount + 1;
128
129 /* Otherwise, get the group value */
130 Status = IopGetRegistryValue(ServiceHandle, L"Group", &KeyValueInformation);
131 if (!NT_SUCCESS(Status)) return PiInitGroupOrderTableCount;
132
133 /* Make sure we have a valid string */
134 ASSERT(KeyValueInformation->Type == REG_SZ);
135 ASSERT(KeyValueInformation->DataLength);
136
137 /* Convert to unicode string */
138 Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
139 PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &Group.Length);
140 Group.MaximumLength = (USHORT)KeyValueInformation->DataLength;
141 Group.Buffer = Buffer;
142
143 /* Loop the groups */
144 for (i = 0; i < PiInitGroupOrderTableCount; i++)
145 {
146 /* Try to find a match */
147 if (RtlEqualUnicodeString(&Group, &PiInitGroupOrderTable[i], TRUE)) break;
148 }
149
150 /* We're done */
151 ExFreePool(KeyValueInformation);
152 return i;
153 }
154
155 USHORT
156 NTAPI
157 PipGetDriverTagPriority(IN HANDLE ServiceHandle)
158 {
159 NTSTATUS Status;
160 HANDLE KeyHandle = NULL;
161 PKEY_VALUE_FULL_INFORMATION KeyValueInformation = NULL;
162 PKEY_VALUE_FULL_INFORMATION KeyValueInformationTag;
163 PKEY_VALUE_FULL_INFORMATION KeyValueInformationGroupOrderList;
164 PVOID Buffer;
165 UNICODE_STRING Group;
166 PULONG GroupOrder;
167 ULONG Count, Tag = 0;
168 USHORT i = -1;
169 UNICODE_STRING GroupString =
170 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet"
171 L"\\Control\\ServiceGroupOrder");
172
173 /* Open the key */
174 Status = IopOpenRegistryKeyEx(&KeyHandle, NULL, &GroupString, KEY_READ);
175 if (!NT_SUCCESS(Status)) goto Quickie;
176
177 /* Read the group */
178 Status = IopGetRegistryValue(ServiceHandle, L"Group", &KeyValueInformation);
179 if (!NT_SUCCESS(Status)) goto Quickie;
180
181 /* Make sure we have a group */
182 if ((KeyValueInformation->Type == REG_SZ) &&
183 (KeyValueInformation->DataLength))
184 {
185 /* Convert to unicode string */
186 Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
187 PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &Group.Length);
188 Group.MaximumLength = (USHORT)KeyValueInformation->DataLength;
189 Group.Buffer = Buffer;
190 }
191
192 /* Now read the tag */
193 Status = IopGetRegistryValue(ServiceHandle, L"Tag", &KeyValueInformationTag);
194 if (!NT_SUCCESS(Status)) goto Quickie;
195
196 /* Make sure we have a tag */
197 if ((KeyValueInformationTag->Type == REG_DWORD) &&
198 (KeyValueInformationTag->DataLength))
199 {
200 /* Read it */
201 Tag = *(PULONG)((ULONG_PTR)KeyValueInformationTag +
202 KeyValueInformationTag->DataOffset);
203 }
204
205 /* We can get rid of this now */
206 ExFreePool(KeyValueInformationTag);
207
208 /* Now let's read the group's tag order */
209 Status = IopGetRegistryValue(KeyHandle,
210 Group.Buffer,
211 &KeyValueInformationGroupOrderList);
212
213 /* We can get rid of this now */
214 Quickie:
215 if (KeyValueInformation) ExFreePool(KeyValueInformation);
216 if (KeyHandle) NtClose(KeyHandle);
217 if (!NT_SUCCESS(Status)) return -1;
218
219 /* We're on the success path -- validate the tag order*/
220 if ((KeyValueInformationGroupOrderList->Type == REG_BINARY) &&
221 (KeyValueInformationGroupOrderList->DataLength))
222 {
223 /* Get the order array */
224 GroupOrder = (PULONG)((ULONG_PTR)KeyValueInformationGroupOrderList +
225 KeyValueInformationGroupOrderList->DataOffset);
226
227 /* Get the count */
228 Count = *GroupOrder;
229 ASSERT(((Count + 1) * sizeof(ULONG)) <=
230 KeyValueInformationGroupOrderList->DataLength);
231
232 /* Now loop each tag */
233 GroupOrder++;
234 for (i = 1; i <= Count; i++)
235 {
236 /* If we found it, we're out */
237 if (Tag == *GroupOrder) break;
238
239 /* Try the next one */
240 GroupOrder++;
241 }
242 }
243
244 /* Last buffer to free */
245 ExFreePool(KeyValueInformationGroupOrderList);
246 return i;
247 }
248
249 NTSTATUS
250 NTAPI
251 PipCallDriverAddDevice(IN PDEVICE_NODE DeviceNode,
252 IN BOOLEAN LoadDriver,
253 IN PDRIVER_OBJECT DriverObject)
254 {
255 NTSTATUS Status;
256 HANDLE EnumRootKey, SubKey, ControlKey, ClassKey, PropertiesKey;
257 UNICODE_STRING ClassGuid, Properties;
258 UNICODE_STRING EnumRoot = RTL_CONSTANT_STRING(ENUM_ROOT);
259 UNICODE_STRING ControlClass =
260 RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Class");
261 PKEY_VALUE_FULL_INFORMATION KeyValueInformation = NULL;
262 PWCHAR Buffer;
263
264 /* Open enumeration root key */
265 Status = IopOpenRegistryKeyEx(&EnumRootKey,
266 NULL,
267 &EnumRoot,
268 KEY_READ);
269 if (!NT_SUCCESS(Status))
270 {
271 DPRINT1("IopOpenRegistryKeyEx() failed for '%wZ' with status 0x%lx\n",
272 &EnumRoot, Status);
273 return Status;
274 }
275
276 /* Open instance subkey */
277 Status = IopOpenRegistryKeyEx(&SubKey,
278 EnumRootKey,
279 &DeviceNode->InstancePath,
280 KEY_READ);
281 ZwClose(EnumRootKey);
282 if (!NT_SUCCESS(Status))
283 {
284 DPRINT1("IopOpenRegistryKeyEx() failed for '%wZ' with status 0x%lx\n",
285 &DeviceNode->InstancePath, Status);
286 return Status;
287 }
288
289 /* Get class GUID */
290 Status = IopGetRegistryValue(SubKey,
291 REGSTR_VAL_CLASSGUID,
292 &KeyValueInformation);
293 if (NT_SUCCESS(Status))
294 {
295 /* Convert to unicode string */
296 Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
297 PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &ClassGuid.Length);
298 ClassGuid.MaximumLength = (USHORT)KeyValueInformation->DataLength;
299 ClassGuid.Buffer = Buffer;
300
301 /* Open the key */
302 Status = IopOpenRegistryKeyEx(&ControlKey,
303 NULL,
304 &ControlClass,
305 KEY_READ);
306 if (!NT_SUCCESS(Status))
307 {
308 /* No class key */
309 DPRINT1("IopOpenRegistryKeyEx() failed for '%wZ' with status 0x%lx\n",
310 &ControlClass, Status);
311 ClassKey = NULL;
312 }
313 else
314 {
315 /* Open the class key */
316 Status = IopOpenRegistryKeyEx(&ClassKey,
317 ControlKey,
318 &ClassGuid,
319 KEY_READ);
320 ZwClose(ControlKey);
321 if (!NT_SUCCESS(Status))
322 {
323 /* No class key */
324 DPRINT1("IopOpenRegistryKeyEx() failed for '%wZ' with status 0x%lx\n",
325 &ClassGuid, Status);
326 ClassKey = NULL;
327 }
328 }
329
330 /* Check if we made it till here */
331 if (ClassKey)
332 {
333 /* Get the device properties */
334 RtlInitUnicodeString(&Properties, REGSTR_KEY_DEVICE_PROPERTIES);
335 Status = IopOpenRegistryKeyEx(&PropertiesKey,
336 ClassKey,
337 &Properties,
338 KEY_READ);
339 ZwClose(ClassKey);
340 if (!NT_SUCCESS(Status))
341 {
342 /* No properties */
343 DPRINT("IopOpenRegistryKeyEx() failed for '%wZ' with status 0x%lx\n",
344 &Properties, Status);
345 PropertiesKey = NULL;
346 }
347 else
348 {
349 ZwClose(PropertiesKey);
350 }
351 }
352
353 /* Free the registry data */
354 ExFreePool(KeyValueInformation);
355 }
356
357 /* Do ReactOS-style setup */
358 Status = IopAttachFilterDrivers(DeviceNode, SubKey, TRUE);
359 if (!NT_SUCCESS(Status))
360 {
361 IopRemoveDevice(DeviceNode);
362 goto Exit;
363 }
364
365 Status = IopInitializeDevice(DeviceNode, DriverObject);
366 if (!NT_SUCCESS(Status))
367 {
368 goto Exit;
369 }
370
371 Status = IopAttachFilterDrivers(DeviceNode, SubKey, FALSE);
372 if (!NT_SUCCESS(Status))
373 {
374 IopRemoveDevice(DeviceNode);
375 goto Exit;
376 }
377
378 Status = IopStartDevice(DeviceNode);
379
380 Exit:
381 /* Close key and return status */
382 ZwClose(SubKey);
383 return Status;
384 }
385
386 NTSTATUS
387 NTAPI
388 INIT_FUNCTION
389 IopInitializePlugPlayServices(VOID)
390 {
391 NTSTATUS Status;
392 ULONG Disposition;
393 HANDLE KeyHandle, EnumHandle, ParentHandle, TreeHandle, ControlHandle;
394 UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET");
395 UNICODE_STRING PnpManagerDriverName = RTL_CONSTANT_STRING(DRIVER_ROOT_NAME L"PnpManager");
396 PDEVICE_OBJECT Pdo;
397
398 /* Initialize locks and such */
399 KeInitializeSpinLock(&IopDeviceTreeLock);
400 KeInitializeSpinLock(&IopDeviceRelationsSpinLock);
401 InitializeListHead(&IopDeviceRelationsRequestList);
402
403 /* Get the default interface */
404 PnpDefaultInterfaceType = IopDetermineDefaultInterfaceType();
405
406 /* Initialize arbiters */
407 Status = IopInitializeArbiters();
408 if (!NT_SUCCESS(Status)) return Status;
409
410 /* Setup the group cache */
411 Status = PiInitCacheGroupInformation();
412 if (!NT_SUCCESS(Status)) return Status;
413
414 /* Open the current control set */
415 Status = IopOpenRegistryKeyEx(&KeyHandle,
416 NULL,
417 &KeyName,
418 KEY_ALL_ACCESS);
419 if (!NT_SUCCESS(Status)) return Status;
420
421 /* Create the control key */
422 RtlInitUnicodeString(&KeyName, L"Control");
423 Status = IopCreateRegistryKeyEx(&ControlHandle,
424 KeyHandle,
425 &KeyName,
426 KEY_ALL_ACCESS,
427 REG_OPTION_NON_VOLATILE,
428 &Disposition);
429 if (!NT_SUCCESS(Status)) return Status;
430
431 /* Check if it's a new key */
432 if (Disposition == REG_CREATED_NEW_KEY)
433 {
434 HANDLE DeviceClassesHandle;
435
436 /* Create the device classes key */
437 RtlInitUnicodeString(&KeyName, L"DeviceClasses");
438 Status = IopCreateRegistryKeyEx(&DeviceClassesHandle,
439 ControlHandle,
440 &KeyName,
441 KEY_ALL_ACCESS,
442 REG_OPTION_NON_VOLATILE,
443 &Disposition);
444 if (!NT_SUCCESS(Status)) return Status;
445
446 ZwClose(DeviceClassesHandle);
447 }
448
449 ZwClose(ControlHandle);
450
451 /* Create the enum key */
452 RtlInitUnicodeString(&KeyName, REGSTR_KEY_ENUM);
453 Status = IopCreateRegistryKeyEx(&EnumHandle,
454 KeyHandle,
455 &KeyName,
456 KEY_ALL_ACCESS,
457 REG_OPTION_NON_VOLATILE,
458 &Disposition);
459 if (!NT_SUCCESS(Status)) return Status;
460
461 /* Check if it's a new key */
462 if (Disposition == REG_CREATED_NEW_KEY)
463 {
464 /* FIXME: DACLs */
465 }
466
467 /* Create the root key */
468 ParentHandle = EnumHandle;
469 RtlInitUnicodeString(&KeyName, REGSTR_KEY_ROOTENUM);
470 Status = IopCreateRegistryKeyEx(&EnumHandle,
471 ParentHandle,
472 &KeyName,
473 KEY_ALL_ACCESS,
474 REG_OPTION_NON_VOLATILE,
475 &Disposition);
476 NtClose(ParentHandle);
477 if (!NT_SUCCESS(Status)) return Status;
478 NtClose(EnumHandle);
479
480 /* Open the root key now */
481 RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET\\ENUM");
482 Status = IopOpenRegistryKeyEx(&EnumHandle,
483 NULL,
484 &KeyName,
485 KEY_ALL_ACCESS);
486 if (NT_SUCCESS(Status))
487 {
488 /* Create the root dev node */
489 RtlInitUnicodeString(&KeyName, REGSTR_VAL_ROOT_DEVNODE);
490 Status = IopCreateRegistryKeyEx(&TreeHandle,
491 EnumHandle,
492 &KeyName,
493 KEY_ALL_ACCESS,
494 REG_OPTION_NON_VOLATILE,
495 NULL);
496 NtClose(EnumHandle);
497 if (NT_SUCCESS(Status)) NtClose(TreeHandle);
498 }
499
500 /* Create the root driver */
501 Status = IoCreateDriver(&PnpManagerDriverName, PnpRootDriverEntry);
502 if (!NT_SUCCESS(Status))
503 {
504 DPRINT1("IoCreateDriverObject() failed\n");
505 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
506 }
507
508 /* Create the root PDO */
509 Status = IoCreateDevice(IopRootDriverObject,
510 sizeof(IOPNP_DEVICE_EXTENSION),
511 NULL,
512 FILE_DEVICE_CONTROLLER,
513 0,
514 FALSE,
515 &Pdo);
516 if (!NT_SUCCESS(Status))
517 {
518 DPRINT1("IoCreateDevice() failed\n");
519 KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
520 }
521
522 /* This is a bus enumerated device */
523 Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
524
525 /* Create the root device node */
526 IopRootDeviceNode = PipAllocateDeviceNode(Pdo);
527
528 /* Set flags */
529 IopRootDeviceNode->Flags |= DNF_STARTED + DNF_PROCESSED + DNF_ENUMERATED +
530 DNF_MADEUP + DNF_NO_RESOURCE_REQUIRED +
531 DNF_ADDED;
532
533 /* Create instance path */
534 RtlCreateUnicodeString(&IopRootDeviceNode->InstancePath,
535 REGSTR_VAL_ROOT_DEVNODE);
536
537 /* Call the add device routine */
538 IopRootDriverObject->DriverExtension->AddDevice(IopRootDriverObject,
539 IopRootDeviceNode->PhysicalDeviceObject);
540
541 /* Initialize PnP-Event notification support */
542 Status = IopInitPlugPlayEvents();
543 if (!NT_SUCCESS(Status)) return Status;
544
545 /* Report the device to the user-mode pnp manager */
546 IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
547 &IopRootDeviceNode->InstancePath);
548
549 /* Initialize the Bus Type GUID List */
550 PnpBusTypeGuidList = ExAllocatePool(PagedPool, sizeof(IO_BUS_TYPE_GUID_LIST));
551 RtlZeroMemory(PnpBusTypeGuidList, sizeof(IO_BUS_TYPE_GUID_LIST));
552 ExInitializeFastMutex(&PnpBusTypeGuidList->Lock);
553
554 /* Launch the firmware mapper */
555 Status = IopUpdateRootKey();
556 if (!NT_SUCCESS(Status)) return Status;
557
558 /* Close the handle to the control set */
559 NtClose(KeyHandle);
560
561 /* We made it */
562 return STATUS_SUCCESS;
563 }
564
565 /* EOF */