ntoskrnl/io/pnpmgr/pnpreport.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * COPYRIGHT:       GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/io/pnpmgr/pnpreport.c
   5  * PURPOSE:         Device Changes Reporting Functions
   6  * PROGRAMMERS:     Cameron Gutman (cameron.gutman@reactos.org)
   7  *                  Pierre Schweitzer
   8  */
   9
  10 /* INCLUDES ******************************************************************/
  11
  12 #include <ntoskrnl.h>
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 /* TYPES *******************************************************************/
  17
  18 typedef struct _INTERNAL_WORK_QUEUE_ITEM
  19 {
  20   WORK_QUEUE_ITEM WorkItem;
  21   PDEVICE_OBJECT PhysicalDeviceObject;
  22   PDEVICE_CHANGE_COMPLETE_CALLBACK Callback;
  23   PVOID Context;
  24   PTARGET_DEVICE_CUSTOM_NOTIFICATION NotificationStructure;
  25 } INTERNAL_WORK_QUEUE_ITEM, *PINTERNAL_WORK_QUEUE_ITEM;
  26
  27 NTSTATUS
  28 NTAPI
  29 IopCreateDeviceKeyPath(IN PCUNICODE_STRING RegistryPath,
  30                        IN ULONG CreateOptions,
  31                        OUT PHANDLE Handle);
  32
  33 NTSTATUS
  34 IopSetDeviceInstanceData(HANDLE InstanceKey,
  35                          PDEVICE_NODE DeviceNode);
  36
  37 NTSTATUS
  38 IopActionInterrogateDeviceStack(PDEVICE_NODE DeviceNode,
  39                                 PVOID Context);
  40
  41 NTSTATUS
  42 PpSetCustomTargetEvent(IN PDEVICE_OBJECT DeviceObject,
  43                        IN OUT PKEVENT SyncEvent OPTIONAL,
  44                        IN OUT PNTSTATUS SyncStatus OPTIONAL,
  45                        IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
  46                        IN PVOID Context OPTIONAL,
  47                        IN PTARGET_DEVICE_CUSTOM_NOTIFICATION NotificationStructure);
  48
  49 /* PRIVATE FUNCTIONS *********************************************************/
  50
  51 PWCHAR
  52 IopGetInterfaceTypeString(INTERFACE_TYPE IfType)
  53 {
  54     switch (IfType)
  55     {
  56        case Internal:
  57          return L"Internal";
  58
  59        case Isa:
  60          return L"Isa";
  61
  62        case Eisa:
  63          return L"Eisa";
  64
  65        case MicroChannel:
  66          return L"MicroChannel";
  67
  68        case TurboChannel:
  69          return L"TurboChannel";
  70
  71        case PCIBus:
  72          return L"PCIBus";
  73
  74        case VMEBus:
  75          return L"VMEBus";
  76
  77        case NuBus:
  78          return L"NuBus";
  79
  80        case PCMCIABus:
  81          return L"PCMCIABus";
  82
  83        case CBus:
  84          return L"CBus";
  85
  86        case MPIBus:
  87          return L"MPIBus";
  88
  89        case MPSABus:
  90          return L"MPSABus";
  91
  92        case ProcessorInternal:
  93          return L"ProcessorInternal";
  94
  95        case PNPISABus:
  96          return L"PNPISABus";
  97
  98        case PNPBus:
  99          return L"PNPBus";
 100
 101        case Vmcs:
 102          return L"Vmcs";
 103
 104        default:
 105          DPRINT1("Invalid bus type: %d\n", IfType);
 106          return NULL;
 107     }
 108 }
 109
 110 VOID
 111 IopReportTargetDeviceChangeAsyncWorker(PVOID Context)
 112 {
 113   PINTERNAL_WORK_QUEUE_ITEM Item;
 114
 115   Item = (PINTERNAL_WORK_QUEUE_ITEM)Context;
 116   PpSetCustomTargetEvent(Item->PhysicalDeviceObject, NULL, NULL, Item->Callback, Item->Context, Item->NotificationStructure);
 117   ObDereferenceObject(Item->PhysicalDeviceObject);
 118   ExFreePoolWithTag(Context, '  pP');
 119 }
 120
 121 NTSTATUS
 122 PpSetCustomTargetEvent(IN PDEVICE_OBJECT DeviceObject,
 123                        IN OUT PKEVENT SyncEvent OPTIONAL,
 124                        IN OUT PNTSTATUS SyncStatus OPTIONAL,
 125                        IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
 126                        IN PVOID Context OPTIONAL,
 127                        IN PTARGET_DEVICE_CUSTOM_NOTIFICATION NotificationStructure)
 128 {
 129     ASSERT(NotificationStructure != NULL);
 130     ASSERT(DeviceObject != NULL);
 131
 132     if (SyncEvent)
 133     {
 134         ASSERT(SyncStatus);
 135         *SyncStatus = STATUS_PENDING;
 136     }
 137
 138     /* That call is totally wrong but notifications handler must be fixed first */
 139     IopNotifyPlugPlayNotification(DeviceObject,
 140                                   EventCategoryTargetDeviceChange,
 141                                   &GUID_PNP_CUSTOM_NOTIFICATION,
 142                                   NotificationStructure,
 143                                   NULL);
 144
 145     if (SyncEvent)
 146     {
 147         KeSetEvent(SyncEvent, IO_NO_INCREMENT, FALSE);
 148         *SyncStatus = STATUS_SUCCESS;
 149     }
 150
 151     return STATUS_SUCCESS;
 152 }
 153
 154 /* PUBLIC FUNCTIONS **********************************************************/
 155
 156 /*
 157  * @implemented
 158  */
 159 NTSTATUS
 160 NTAPI
 161 IoReportDetectedDevice(IN PDRIVER_OBJECT DriverObject,
 162                        IN INTERFACE_TYPE LegacyBusType,
 163                        IN ULONG BusNumber,
 164                        IN ULONG SlotNumber,
 165                        IN PCM_RESOURCE_LIST ResourceList,
 166                        IN PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirements OPTIONAL,
 167                        IN BOOLEAN ResourceAssigned,
 168                        IN OUT PDEVICE_OBJECT *DeviceObject OPTIONAL)
 169 {
 170     PDEVICE_NODE DeviceNode;
 171     PDEVICE_OBJECT Pdo;
 172     NTSTATUS Status;
 173     HANDLE InstanceKey;
 174     ULONG RequiredLength;
 175     UNICODE_STRING ValueName, ServiceName;
 176     WCHAR HardwareId[256];
 177     PWCHAR IfString;
 178     ULONG IdLength;
 179
 180     DPRINT("IoReportDetectedDevice (DeviceObject %p, *DeviceObject %p)\n",
 181       DeviceObject, DeviceObject ? *DeviceObject : NULL);
 182
 183     /* Create the service name (eg. ACPI_HAL) */
 184     ServiceName.Buffer = DriverObject->DriverName.Buffer +
 185        sizeof(DRIVER_ROOT_NAME) / sizeof(WCHAR) - 1;
 186     ServiceName.Length = DriverObject->DriverName.Length -
 187        sizeof(DRIVER_ROOT_NAME) + sizeof(WCHAR);
 188     ServiceName.MaximumLength = ServiceName.Length;
 189
 190     /* If the interface type is unknown, treat it as internal */
 191     if (LegacyBusType == InterfaceTypeUndefined)
 192         LegacyBusType = Internal;
 193
 194     /* Get the string equivalent of the interface type */
 195     IfString = IopGetInterfaceTypeString(LegacyBusType);
 196
 197     /* If NULL is returned then it's a bad type */
 198     if (!IfString)
 199         return STATUS_INVALID_PARAMETER;
 200
 201     /* We use the caller's PDO if they supplied one */
 202     if (DeviceObject && *DeviceObject)
 203     {
 204         Pdo = *DeviceObject;
 205         DeviceNode = IopGetDeviceNode(*DeviceObject);
 206     }
 207     else
 208     {
 209         /* Create the PDO */
 210         Status = PnpRootCreateDevice(&ServiceName,
 211                                      &Pdo,
 212                                      NULL);
 213         if (!NT_SUCCESS(Status))
 214         {
 215             DPRINT("PnpRootCreateDevice() failed (Status 0x%08lx)\n", Status);
 216             return Status;
 217         }
 218
 219         /* Create the device node for the new PDO */
 220         Status = IopCreateDeviceNode(IopRootDeviceNode,
 221                                      Pdo,
 222                                      NULL,
 223                                      &DeviceNode);
 224
 225         if (!NT_SUCCESS(Status))
 226         {
 227             DPRINT("IopCreateDeviceNode() failed (Status 0x%08lx)\n", Status);
 228             return Status;
 229         }
 230     }
 231
 232     /* We don't call AddDevice for devices reported this way */
 233     IopDeviceNodeSetFlag(DeviceNode, DNF_ADDED);
 234
 235     /* We don't send IRP_MN_START_DEVICE */
 236     IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
 237
 238     /* We need to get device IDs */
 239 #if 0
 240     IopDeviceNodeSetFlag(DeviceNode, DNF_NEED_QUERY_IDS);
 241 #endif
 242
 243     /* This is a legacy driver for this device */
 244     IopDeviceNodeSetFlag(DeviceNode, DNF_LEGACY_DRIVER);
 245
 246     /* Perform a manual configuration of our device */
 247     IopActionInterrogateDeviceStack(DeviceNode, DeviceNode->Parent);
 248     IopActionConfigureChildServices(DeviceNode, DeviceNode->Parent);
 249
 250     /* Open a handle to the instance path key */
 251     Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, 0, &InstanceKey);
 252     if (!NT_SUCCESS(Status))
 253         return Status;
 254
 255     /* Add DETECTEDInterfaceType\DriverName */
 256     IdLength = 0;
 257     IdLength += swprintf(&HardwareId[IdLength],
 258                          L"DETECTED%ls\\%wZ",
 259                          IfString,
 260                          &ServiceName);
 261     HardwareId[IdLength++] = UNICODE_NULL;
 262
 263     /* Add DETECTED\DriverName */
 264     IdLength += swprintf(&HardwareId[IdLength],
 265                          L"DETECTED\\%wZ",
 266                          &ServiceName);
 267     HardwareId[IdLength++] = UNICODE_NULL;
 268
 269     /* Terminate the string with another null */
 270     HardwareId[IdLength] = UNICODE_NULL;
 271
 272     /* Store the value for CompatibleIDs */
 273     RtlInitUnicodeString(&ValueName, L"CompatibleIDs");
 274     Status = ZwSetValueKey(InstanceKey, &ValueName, 0, REG_MULTI_SZ, HardwareId, IdLength * sizeof(WCHAR));
 275     if (!NT_SUCCESS(Status))
 276     {
 277        DPRINT("Failed to write the compatible IDs: 0x%x\n", Status);
 278        ZwClose(InstanceKey);
 279        return Status;
 280     }
 281
 282     /* Add a hardware ID if the driver didn't report one */
 283     RtlInitUnicodeString(&ValueName, L"HardwareID");
 284     if (ZwQueryValueKey(InstanceKey, &ValueName, KeyValueBasicInformation, NULL, 0, &RequiredLength) == STATUS_OBJECT_NAME_NOT_FOUND)
 285     {
 286        /* Just use our most specific compatible ID */
 287        IdLength = 0;
 288        IdLength += swprintf(&HardwareId[IdLength],
 289                             L"DETECTED%ls\\%wZ",
 290                             IfString,
 291                             &ServiceName);
 292        HardwareId[++IdLength] = UNICODE_NULL;
 293
 294        /* Write the value to the registry */
 295        Status = ZwSetValueKey(InstanceKey, &ValueName, 0, REG_SZ, HardwareId, IdLength * sizeof(WCHAR));
 296        if (!NT_SUCCESS(Status))
 297        {
 298           DPRINT("Failed to write the hardware ID: 0x%x\n", Status);
 299           ZwClose(InstanceKey);
 300           return Status;
 301        }
 302     }
 303
 304     /* Assign the resources to the device node */
 305     DeviceNode->BootResources = ResourceList;
 306     DeviceNode->ResourceRequirements = ResourceRequirements;
 307
 308     /* Set appropriate flags */
 309     if (DeviceNode->BootResources)
 310        IopDeviceNodeSetFlag(DeviceNode, DNF_HAS_BOOT_CONFIG);
 311
 312     if (!DeviceNode->ResourceRequirements && !DeviceNode->BootResources)
 313        IopDeviceNodeSetFlag(DeviceNode, DNF_NO_RESOURCE_REQUIRED);
 314
 315     /* Write the resource information to the registry */
 316     IopSetDeviceInstanceData(InstanceKey, DeviceNode);
 317
 318     /* If the caller didn't get the resources assigned for us, do it now */
 319     if (!ResourceAssigned)
 320     {
 321        Status = IopAssignDeviceResources(DeviceNode);
 322
 323        /* See if we failed */
 324        if (!NT_SUCCESS(Status))
 325        {
 326            DPRINT("Assigning resources failed: 0x%x\n", Status);
 327            ZwClose(InstanceKey);
 328            return Status;
 329        }
 330     }
 331
 332     /* Close the instance key handle */
 333     ZwClose(InstanceKey);
 334
 335     /* Report the device's enumeration to umpnpmgr */
 336     IopQueueTargetDeviceEvent(&GUID_DEVICE_ENUMERATED,
 337                               &DeviceNode->InstancePath);
 338
 339     /* Report the device's arrival to umpnpmgr */
 340     IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
 341                               &DeviceNode->InstancePath);
 342
 343     DPRINT1("Reported device: %S (%wZ)\n", HardwareId, &DeviceNode->InstancePath);
 344
 345     /* Return the PDO */
 346     if (DeviceObject) *DeviceObject = Pdo;
 347
 348     return STATUS_SUCCESS;
 349 }
 350
 351 /*
 352  * @halfplemented
 353  */
 354 NTSTATUS
 355 NTAPI
 356 IoReportResourceForDetection(IN PDRIVER_OBJECT DriverObject,
 357                              IN PCM_RESOURCE_LIST DriverList OPTIONAL,
 358                              IN ULONG DriverListSize OPTIONAL,
 359                              IN PDEVICE_OBJECT DeviceObject OPTIONAL,
 360                              IN PCM_RESOURCE_LIST DeviceList OPTIONAL,
 361                              IN ULONG DeviceListSize OPTIONAL,
 362                              OUT PBOOLEAN ConflictDetected)
 363 {
 364     PCM_RESOURCE_LIST ResourceList;
 365     NTSTATUS Status;
 366
 367     *ConflictDetected = FALSE;
 368
 369     if (!DriverList && !DeviceList)
 370         return STATUS_INVALID_PARAMETER;
 371
 372     /* Find the real list */
 373     if (!DriverList)
 374         ResourceList = DeviceList;
 375     else
 376         ResourceList = DriverList;
 377
 378     /* Look for a resource conflict */
 379     Status = IopDetectResourceConflict(ResourceList, FALSE, NULL);
 380     if (Status == STATUS_CONFLICTING_ADDRESSES)
 381     {
 382         /* Oh noes */
 383         *ConflictDetected = TRUE;
 384     }
 385     else if (NT_SUCCESS(Status))
 386     {
 387         /* Looks like we're good to go */
 388
 389         /* TODO: Claim the resources in the ResourceMap */
 390     }
 391
 392     return Status;
 393 }
 394
 395 VOID
 396 NTAPI
 397 IopSetEvent(IN PVOID Context)
 398 {
 399     PKEVENT Event = Context;
 400
 401     /* Set the event */
 402     KeSetEvent(Event, IO_NO_INCREMENT, FALSE);
 403 }
 404
 405 /*
 406  * @implemented
 407  */
 408 NTSTATUS
 409 NTAPI
 410 IoReportTargetDeviceChange(IN PDEVICE_OBJECT PhysicalDeviceObject,
 411                            IN PVOID NotificationStructure)
 412 {
 413     KEVENT NotifyEvent;
 414     NTSTATUS Status, NotifyStatus;
 415     PTARGET_DEVICE_CUSTOM_NOTIFICATION notifyStruct = (PTARGET_DEVICE_CUSTOM_NOTIFICATION)NotificationStructure;
 416
 417     ASSERT(notifyStruct);
 418
 419     /* Check for valid PDO */
 420     if (!IopIsValidPhysicalDeviceObject(PhysicalDeviceObject))
 421     {
 422         KeBugCheckEx(PNP_DETECTED_FATAL_ERROR, 0x2, (ULONG)PhysicalDeviceObject, 0, 0);
 423     }
 424
 425     /* FileObject must be null. PnP will fill in it */
 426     ASSERT(notifyStruct->FileObject == NULL);
 427
 428     /* Do not handle system PnP events */
 429     if ((RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_QUERY_REMOVE), sizeof(GUID)) != sizeof(GUID)) ||
 430         (RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_REMOVE_CANCELLED), sizeof(GUID)) != sizeof(GUID)) ||
 431         (RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_REMOVE_COMPLETE), sizeof(GUID)) != sizeof(GUID)))
 432     {
 433         return STATUS_INVALID_DEVICE_REQUEST;
 434     }
 435
 436     if (notifyStruct->Version != 1)
 437     {
 438         return STATUS_INVALID_DEVICE_REQUEST;
 439     }
 440
 441     /* Initialize even that will let us know when PnP will have finished notify */
 442     KeInitializeEvent(&NotifyEvent, NotificationEvent, FALSE);
 443
 444     Status = PpSetCustomTargetEvent(PhysicalDeviceObject, &NotifyEvent, &NotifyStatus, NULL, NULL, notifyStruct);
 445     /* If no error, wait for the notify to end and return the status of the notify and not of the event */
 446     if (NT_SUCCESS(Status))
 447     {
 448         KeWaitForSingleObject(&NotifyEvent, Executive, KernelMode, FALSE, NULL);
 449         Status = NotifyStatus;
 450     }
 451
 452     return Status;
 453 }
 454
 455 /*
 456  * @implemented
 457  */
 458 NTSTATUS
 459 NTAPI
 460 IoReportTargetDeviceChangeAsynchronous(IN PDEVICE_OBJECT PhysicalDeviceObject,
 461                                        IN PVOID NotificationStructure,
 462                                        IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
 463                                        IN PVOID Context OPTIONAL)
 464 {
 465     PINTERNAL_WORK_QUEUE_ITEM Item = NULL;
 466     PTARGET_DEVICE_CUSTOM_NOTIFICATION notifyStruct = (PTARGET_DEVICE_CUSTOM_NOTIFICATION)NotificationStructure;
 467
 468     ASSERT(notifyStruct);
 469
 470     /* Check for valid PDO */
 471     if (!IopIsValidPhysicalDeviceObject(PhysicalDeviceObject))
 472     {
 473         KeBugCheckEx(PNP_DETECTED_FATAL_ERROR, 0x2, (ULONG)PhysicalDeviceObject, 0, 0);
 474     }
 475
 476     /* FileObject must be null. PnP will fill in it */
 477     ASSERT(notifyStruct->FileObject == NULL);
 478
 479     /* Do not handle system PnP events */
 480     if ((RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_QUERY_REMOVE), sizeof(GUID)) != sizeof(GUID)) ||
 481         (RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_REMOVE_CANCELLED), sizeof(GUID)) != sizeof(GUID)) ||
 482         (RtlCompareMemory(&(notifyStruct->Event), &(GUID_TARGET_DEVICE_REMOVE_COMPLETE), sizeof(GUID)) != sizeof(GUID)))
 483     {
 484         return STATUS_INVALID_DEVICE_REQUEST;
 485     }
 486
 487     if (notifyStruct->Version != 1)
 488     {
 489         return STATUS_INVALID_DEVICE_REQUEST;
 490     }
 491
 492     /* We need to store all the data given by the caller with the WorkItem, so use our own struct */
 493     Item = ExAllocatePoolWithTag(NonPagedPool, sizeof(INTERNAL_WORK_QUEUE_ITEM), '  pP');
 494     if (!Item) return STATUS_INSUFFICIENT_RESOURCES;
 495
 496     /* Initialize all stuff */
 497     ObReferenceObject(PhysicalDeviceObject);
 498     Item->NotificationStructure = notifyStruct;
 499     Item->PhysicalDeviceObject = PhysicalDeviceObject;
 500     Item->Callback = Callback;
 501     Item->Context = Context;
 502     ExInitializeWorkItem(&(Item->WorkItem), (PWORKER_THREAD_ROUTINE)IopReportTargetDeviceChangeAsyncWorker, Item);
 503
 504     /* Finally, queue the item, our work here is done */
 505     ExQueueWorkItem(&(Item->WorkItem), DelayedWorkQueue);
 506
 507     return STATUS_PENDING;
 508 }