drivers/ksfilter/ks/swenum.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel Streaming
   4  * FILE:            drivers/ksfilter/ks/swenum.c
   5  * PURPOSE:         KS Software BUS functions
   6  * PROGRAMMER:      Johannes Anderwald
   7  */
   8
   9
  10 #include "priv.h"
  11
  12 LONG KsDeviceCount = 0;
  13
  14 typedef NTSTATUS (NTAPI *PKSP_BUS_ENUM_CALLBACK)(
  15     IN PHANDLE hKey,
  16     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
  17     IN PBUS_DEVICE_ENTRY DummyEntry,
  18     IN LPWSTR RootName,
  19     IN LPWSTR DirectoryName);
  20
  21 NTSTATUS
  22 KspCreatePDO(
  23     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
  24     IN PBUS_DEVICE_ENTRY DeviceEntry,
  25     OUT PDEVICE_OBJECT * OutDeviceObject)
  26 {
  27     PDEVICE_OBJECT DeviceObject;
  28     WCHAR Buffer[50];
  29     ULONG CurDeviceId;
  30     UNICODE_STRING DeviceName;
  31     NTSTATUS Status;
  32     PCOMMON_DEVICE_EXTENSION DeviceExtension;
  33
  34     /* increment device count */
  35     CurDeviceId = InterlockedIncrement(&KsDeviceCount);
  36
  37     /* generate new device id */
  38     swprintf(Buffer, L"\\Device\\KSENUM%08x", CurDeviceId);
  39
  40     /* initialize new device name */
  41     RtlInitUnicodeString(&DeviceName, Buffer);
  42
  43     /* create new device object */
  44     Status = IoCreateDevice(BusDeviceExtension->BusDeviceObject->DriverObject, sizeof(PVOID), &DeviceName, FILE_DEVICE_UNKNOWN, 0, FALSE, &DeviceObject);
  45
  46     /* check for success */
  47     if (!NT_SUCCESS(Status))
  48     {
  49         /* failed to create pdo */
  50         return Status;
  51     }
  52
  53     /* now allocate device extension */
  54     DeviceExtension = (PCOMMON_DEVICE_EXTENSION)AllocateItem(NonPagedPool, sizeof(COMMON_DEVICE_EXTENSION));
  55     if (!DeviceExtension)
  56     {
  57         /* no memory */
  58         IoDeleteDevice(DeviceObject);
  59         return STATUS_INSUFFICIENT_RESOURCES;
  60     }
  61
  62     /* store device extension */
  63     *((PVOID*)DeviceObject->DeviceExtension) = DeviceExtension;
  64
  65     /* initialize device extension */
  66     DeviceExtension->IsBus = FALSE;
  67     DeviceExtension->DeviceObject = DeviceObject;
  68     DeviceExtension->DeviceEntry = DeviceEntry;
  69     DeviceExtension->BusDeviceExtension = BusDeviceExtension;
  70
  71     /* TODO: update last creation time in bus device extension */
  72
  73     /* setup flags */
  74     DeviceObject->Flags |= DO_POWER_PAGABLE;
  75     DeviceObject->Flags &= ~ DO_DEVICE_INITIALIZING;
  76     /* TODO: fire time when expired */
  77
  78     *OutDeviceObject = DeviceObject;
  79
  80     return STATUS_SUCCESS;
  81 }
  82
  83 NTSTATUS
  84 KspRegisterDeviceAssociation(
  85     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
  86     IN PBUS_DEVICE_ENTRY DeviceEntry,
  87     IN OUT PBUS_INSTANCE_ENTRY BusInstanceEntry)
  88 {
  89     NTSTATUS Status;
  90     UNICODE_STRING ReferenceString;
  91
  92     /* initialize reference string */
  93     RtlInitUnicodeString(&ReferenceString, DeviceEntry->DeviceName);
  94
  95     /* register device interface */
  96     Status = IoRegisterDeviceInterface(BusDeviceExtension->PhysicalDeviceObject, &BusInstanceEntry->InterfaceGuid, &ReferenceString, &BusInstanceEntry->SymbolicLink);
  97
  98     /* check for success */
  99     if (!NT_SUCCESS(Status))
 100     {
 101         /* failed */
 102         return Status;
 103     }
 104
 105     /* now enable the interface */
 106     Status = IoSetDeviceInterfaceState(&BusInstanceEntry->SymbolicLink, TRUE);
 107
 108     /* check for success */
 109     if (!NT_SUCCESS(Status))
 110     {
 111         /* failed, free memory */
 112         FreeItem(BusInstanceEntry->SymbolicLink.Buffer);
 113         return Status;
 114     }
 115
 116     DPRINT1("Registered DeviceInterface %wZ\n", &BusInstanceEntry->SymbolicLink);
 117
 118
 119     /* done */
 120     return Status;
 121 }
 122
 123 VOID
 124 KspRemoveDeviceAssociations(
 125     IN PBUS_DEVICE_ENTRY DeviceEntry)
 126 {
 127     PLIST_ENTRY Entry;
 128     PBUS_INSTANCE_ENTRY CurEntry;
 129
 130     /* remove all entries */
 131     Entry = DeviceEntry->DeviceInterfaceList.Flink;
 132
 133     while(Entry != &DeviceEntry->DeviceInterfaceList)
 134     {
 135          /* get offset */
 136          CurEntry = (PBUS_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BUS_INSTANCE_ENTRY, Entry);
 137
 138          /* sanity check */
 139          ASSERT(CurEntry->SymbolicLink.Buffer);
 140
 141          /* de-register interface */
 142          IoSetDeviceInterfaceState(&CurEntry->SymbolicLink, FALSE);
 143
 144          /* free symbolic link buffer */
 145          FreeItem(CurEntry->SymbolicLink.Buffer);
 146
 147          /* remove entry from list */
 148          RemoveEntryList(Entry);
 149
 150          /* move to next entry */
 151          Entry = Entry->Flink;
 152
 153          /* free entry */
 154          FreeItem(CurEntry);
 155     }
 156 }
 157
 158 NTSTATUS
 159 KspEnumerateBusRegistryKeys(
 160     IN HANDLE hKey,
 161     IN LPWSTR ReferenceString,
 162     IN PKSP_BUS_ENUM_CALLBACK Callback,
 163     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
 164     IN PBUS_DEVICE_ENTRY DeviceEntry)
 165 {
 166     UNICODE_STRING String;
 167     OBJECT_ATTRIBUTES ObjectAttributes;
 168     HANDLE hNewKey;
 169     NTSTATUS Status;
 170     ULONG ResultLength, Index, KeyInfoLength;
 171     KEY_FULL_INFORMATION KeyInformation;
 172     PKEY_BASIC_INFORMATION KeyInfo;
 173
 174     /* initialize key name */
 175     RtlInitUnicodeString(&String, ReferenceString);
 176
 177     /* initialize object attributes */
 178     InitializeObjectAttributes(&ObjectAttributes, &String, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hKey, NULL);
 179
 180     /* open new key */
 181     Status = ZwOpenKey(&hNewKey, GENERIC_READ, &ObjectAttributes);
 182
 183     /* check for success */
 184     if (!NT_SUCCESS(Status))
 185     {
 186         /* failed to open key */
 187
 188         return Status;
 189     }
 190
 191     /* query key stats */
 192     Status = ZwQueryKey(hNewKey, KeyFullInformation, &KeyInformation, sizeof(KeyInformation), &ResultLength);
 193
 194     if (!NT_SUCCESS(Status))
 195     {
 196         /* close key */
 197         ZwClose(hNewKey);
 198
 199         /* done */
 200         return Status;
 201     }
 202
 203     /* calculate key info length */
 204     KeyInfoLength = KeyInformation.MaxNameLen + sizeof(KEY_BASIC_INFORMATION) + 1 * sizeof(WCHAR);
 205
 206     /* allocate buffer */
 207     KeyInfo = (PKEY_BASIC_INFORMATION)AllocateItem(NonPagedPool, KeyInfoLength);
 208     if (!KeyInfo)
 209     {
 210
 211         /* no memory */
 212         ZwClose(hNewKey);
 213
 214         /* done */
 215         return STATUS_INSUFFICIENT_RESOURCES;
 216     }
 217
 218     /* enumerate all keys */
 219     for(Index = 0; Index < KeyInformation.SubKeys; Index++)
 220     {
 221
 222         /* query sub key */
 223         Status = ZwEnumerateKey(hNewKey, Index, KeyBasicInformation, (PVOID)KeyInfo, KeyInfoLength, &ResultLength);
 224
 225         /* check for success */
 226         if (NT_SUCCESS(Status))
 227         {
 228             /* perform callback */
 229             Status = Callback(hNewKey, BusDeviceExtension, DeviceEntry, ReferenceString, KeyInfo->Name);
 230
 231             /* should enumeration stop */
 232             if (!NT_SUCCESS(Status))
 233                 break;
 234         }
 235     }
 236
 237     /* free info buffer */
 238     FreeItem(KeyInfo);
 239
 240     /* close key */
 241     ZwClose(hNewKey);
 242
 243     /* done */
 244     return Status;
 245 }
 246
 247 NTSTATUS
 248 NTAPI
 249 KspCreateDeviceAssociation(
 250     IN PHANDLE hKey,
 251     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
 252     IN PBUS_DEVICE_ENTRY DeviceEntry,
 253     IN LPWSTR ReferenceString,
 254     IN LPWSTR InterfaceString)
 255 {
 256     GUID DeviceGuid;
 257     NTSTATUS Status;
 258     PLIST_ENTRY Entry;
 259     PBUS_INSTANCE_ENTRY CurEntry;
 260     UNICODE_STRING DeviceName;
 261
 262     /* initialize interface string */
 263     RtlInitUnicodeString(&DeviceName, InterfaceString);
 264
 265     /* first convert device name to guid */
 266     RtlGUIDFromString(&DeviceName, &DeviceGuid);
 267
 268     /* check if the device is already present */
 269     Entry = DeviceEntry->DeviceInterfaceList.Flink;
 270
 271     while(Entry != &DeviceEntry->DeviceInterfaceList)
 272     {
 273          /* get offset */
 274          CurEntry = (PBUS_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BUS_INSTANCE_ENTRY, Entry);
 275
 276          if (IsEqualGUIDAligned(&CurEntry->InterfaceGuid, &DeviceGuid))
 277          {
 278              /* entry already exists */
 279              return STATUS_SUCCESS;
 280          }
 281
 282          /* move to next entry */
 283          Entry = Entry->Flink;
 284     }
 285
 286     /* time to allocate new entry */
 287     CurEntry = (PBUS_INSTANCE_ENTRY)AllocateItem(NonPagedPool, sizeof(BUS_INSTANCE_ENTRY));
 288
 289     if (!CurEntry)
 290     {
 291         /* no memory */
 292         return STATUS_INSUFFICIENT_RESOURCES;
 293     }
 294
 295     /* store guid */
 296     RtlMoveMemory(&CurEntry->InterfaceGuid, &DeviceGuid, sizeof(GUID));
 297
 298     /* now register the association */
 299     Status = KspRegisterDeviceAssociation(BusDeviceExtension, DeviceEntry, CurEntry);
 300
 301     /* check for success */
 302     if (NT_SUCCESS(Status))
 303     {
 304         /* store entry */
 305         InsertTailList(&DeviceEntry->DeviceInterfaceList, &CurEntry->Entry);
 306     }
 307     else
 308     {
 309         /* failed to associated device */
 310         FreeItem(CurEntry);
 311     }
 312
 313      /* done */
 314      return Status;
 315 }
 316
 317 NTSTATUS
 318 NTAPI
 319 KspCreateDeviceReference(
 320     IN PHANDLE hKey,
 321     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
 322     IN PBUS_DEVICE_ENTRY DummyEntry,
 323     IN LPWSTR DeviceCategory,
 324     IN LPWSTR ReferenceString)
 325 {
 326     LPWSTR DeviceName;
 327     ULONG Length;
 328     PLIST_ENTRY Entry;
 329     PBUS_DEVICE_ENTRY DeviceEntry = NULL; /* GCC warning */
 330     BOOLEAN ItemExists = FALSE;
 331     UNICODE_STRING String;
 332     NTSTATUS Status;
 333     KIRQL OldLevel;
 334
 335     /* first construct device name & reference guid */
 336     Length = wcslen(DeviceCategory) + wcslen(ReferenceString);
 337
 338     /* append '&' and null byte */
 339     Length += 2;
 340
 341     /* allocate device name */
 342     DeviceName = AllocateItem(NonPagedPool, Length * sizeof(WCHAR));
 343
 344     if (!DeviceName)
 345     {
 346         /* not enough memory */
 347         return STATUS_INSUFFICIENT_RESOURCES;
 348     }
 349
 350     /* construct device name */
 351     swprintf(DeviceName, L"%s&%s", DeviceCategory, ReferenceString);
 352
 353     /* scan list and check if it is already present */
 354     Entry = BusDeviceExtension->Common.Entry.Flink;
 355
 356     while(Entry != &BusDeviceExtension->Common.Entry)
 357     {
 358         /* get real offset */
 359         DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
 360
 361         /* check if name matches */
 362         if (!wcsicmp(DeviceEntry->DeviceName, DeviceName))
 363         {
 364             /* item already exists */
 365             ItemExists = TRUE;
 366             break;
 367         }
 368
 369         /* move to next entry */
 370         Entry = Entry->Flink;
 371     }
 372
 373     if (!ItemExists)
 374     {
 375         /* allocate new device entry */
 376         DeviceEntry = AllocateItem(NonPagedPool, sizeof(BUS_DEVICE_ENTRY));
 377         if (!DeviceEntry)
 378         {
 379             /* no memory */
 380             FreeItem(DeviceName);
 381             return STATUS_INSUFFICIENT_RESOURCES;
 382         }
 383
 384         /* initialize device entry */
 385         InitializeListHead(&DeviceEntry->DeviceInterfaceList);
 386         InitializeListHead(&DeviceEntry->IrpPendingList);
 387
 388         /* copy device guid */
 389         RtlInitUnicodeString(&String, ReferenceString);
 390         RtlGUIDFromString(&String, &DeviceEntry->DeviceGuid);
 391
 392         /* copy device names */
 393         DeviceEntry->DeviceName = DeviceName;
 394         DeviceEntry->Instance = (DeviceName + wcslen(DeviceCategory) + 1);
 395
 396         /* copy name */
 397         DeviceEntry->BusId = AllocateItem(NonPagedPool, (wcslen(DeviceCategory) + 1) * sizeof(WCHAR));
 398         if (!DeviceEntry->BusId)
 399         {
 400             /* no memory */
 401             FreeItem(DeviceName);
 402             FreeItem(DeviceEntry);
 403             return STATUS_INSUFFICIENT_RESOURCES;
 404         }
 405         wcscpy(DeviceEntry->BusId, DeviceCategory);
 406     }
 407
 408     /* now enumerate the devices */
 409     Status = KspEnumerateBusRegistryKeys(hKey, ReferenceString, KspCreateDeviceAssociation, BusDeviceExtension, DeviceEntry);
 410
 411     /* check if list is empty */
 412     if (IsListEmpty(&DeviceEntry->DeviceInterfaceList))
 413     {
 414         /* invalid device settings */
 415         FreeItem(DeviceEntry->BusId);
 416         FreeItem(DeviceEntry->DeviceName);
 417         FreeItem(DeviceEntry);
 418
 419         ASSERT(ItemExists == FALSE);
 420
 421         return STATUS_INVALID_DEVICE_STATE;
 422     }
 423
 424     /* check if enumeration failed */
 425     if (!NT_SUCCESS(Status))
 426     {
 427         /* failed */
 428         KspRemoveDeviceAssociations(DeviceEntry);
 429         FreeItem(DeviceEntry->BusId);
 430         FreeItem(DeviceEntry->DeviceName);
 431         FreeItem(DeviceEntry);
 432
 433         ASSERT(ItemExists == FALSE);
 434
 435         /* done */
 436         return Status;
 437     }
 438
 439     if (!ItemExists)
 440     {
 441         /* acquire lock */
 442         KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
 443
 444         /* successfully initialized entry */
 445         InsertTailList(&BusDeviceExtension->Common.Entry, &DeviceEntry->Entry);
 446
 447         /* release lock */
 448         KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
 449     }
 450
 451     /* done */
 452     return Status;
 453 }
 454
 455 NTSTATUS
 456 NTAPI
 457 KspCreateDeviceReferenceTrampoline(
 458     IN PHANDLE hKey,
 459     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
 460     IN PBUS_DEVICE_ENTRY DummyEntry,
 461     IN LPWSTR DeviceCategory,
 462     IN LPWSTR ReferenceString)
 463 {
 464     return KspEnumerateBusRegistryKeys(hKey, ReferenceString, KspCreateDeviceReference, BusDeviceExtension, DummyEntry);
 465 }
 466
 467
 468 NTSTATUS
 469 KspOpenBusRegistryKey(
 470     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
 471     OUT PHANDLE hKey)
 472 {
 473     OBJECT_ATTRIBUTES ObjectAttributes;
 474
 475     /* initialize object attributes */
 476     InitializeObjectAttributes(&ObjectAttributes, &BusDeviceExtension->ServicePath, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
 477
 478     return ZwCreateKey(hKey, GENERIC_READ | GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
 479 }
 480
 481 NTSTATUS
 482 KspScanBus(
 483     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension)
 484 {
 485     HANDLE hKey;
 486     NTSTATUS Status;
 487
 488     /* first open key */
 489     Status = KspOpenBusRegistryKey(BusDeviceExtension, &hKey);
 490
 491     /* check for success */
 492     if (!NT_SUCCESS(Status))
 493     {
 494         /* no success */
 495
 496         return Status;
 497     }
 498
 499     /* TODO clear reference marks */
 500
 501     /* construct device entries */
 502     Status = KspEnumerateBusRegistryKeys(hKey, NULL, KspCreateDeviceReferenceTrampoline, BusDeviceExtension, NULL);
 503
 504     /* TODO: delete unreferenced devices */
 505
 506     /* close handle */
 507     ZwClose(hKey);
 508
 509     /* done */
 510     return Status;
 511 }
 512
 513
 514 NTSTATUS
 515 NTAPI
 516 KspBusQueryReferenceString(
 517     IN PVOID Context,
 518     IN OUT PWCHAR *String)
 519 {
 520     LPWSTR Name;
 521     ULONG Length;
 522     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)Context;
 523
 524     /* sanity checks */
 525     ASSERT(BusDeviceExtension);
 526     ASSERT(BusDeviceExtension->BusIdentifier);
 527
 528     /* calculate length */
 529     Length = wcslen(BusDeviceExtension->BusIdentifier) + 1;
 530
 531     /* allocate buffer */
 532     Name = AllocateItem(PagedPool, Length * sizeof(WCHAR));
 533
 534     if (!Name)
 535     {
 536         /* failed to allocate buffer */
 537         return STATUS_INSUFFICIENT_RESOURCES;
 538     }
 539
 540     /* copy buffer */
 541     wcscpy(Name, BusDeviceExtension->BusIdentifier);
 542
 543     /* store result */
 544     *String = Name;
 545
 546     /* done */
 547     return STATUS_SUCCESS;
 548 }
 549
 550 VOID
 551 NTAPI
 552 KspBusDeviceReference(
 553     IN PVOID Context)
 554 {
 555     PCOMMON_DEVICE_EXTENSION ChildDeviceExtension = (PCOMMON_DEVICE_EXTENSION)Context;
 556
 557     /* reference count */
 558     InterlockedIncrement((PLONG)&ChildDeviceExtension->DeviceReferenceCount);
 559 }
 560
 561 VOID
 562 NTAPI
 563 KspBusDeviceDereference(
 564     IN PVOID Context)
 565 {
 566     PCOMMON_DEVICE_EXTENSION ChildDeviceExtension = (PCOMMON_DEVICE_EXTENSION)Context;
 567
 568     /* reference count */
 569     InterlockedDecrement((PLONG)&ChildDeviceExtension->DeviceReferenceCount);
 570 }
 571
 572 VOID
 573 NTAPI
 574 KspBusReferenceDeviceObject(
 575     IN PVOID Context)
 576 {
 577     PCOMMON_DEVICE_EXTENSION ChildDeviceExtension = (PCOMMON_DEVICE_EXTENSION)Context;
 578
 579     /* reference count */
 580     InterlockedIncrement((PLONG)&ChildDeviceExtension->DeviceObjectReferenceCount);
 581 }
 582
 583 VOID
 584 NTAPI
 585 KspBusDereferenceDeviceObject(
 586     IN PVOID Context)
 587 {
 588     PCOMMON_DEVICE_EXTENSION ChildDeviceExtension = (PCOMMON_DEVICE_EXTENSION)Context;
 589
 590     /* reference count */
 591     InterlockedDecrement((PLONG)&ChildDeviceExtension->DeviceObjectReferenceCount);
 592 }
 593
 594 NTSTATUS
 595 KspQueryBusDeviceInterface(
 596     IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
 597     IN PIRP Irp)
 598 {
 599     PBUS_INTERFACE_SWENUM Interface;
 600     PIO_STACK_LOCATION IoStack;
 601
 602     /* get current irp stack location */
 603     IoStack = IoGetCurrentIrpStackLocation(Irp);
 604
 605     /* sanity checks */
 606     ASSERT(IoStack->Parameters.QueryInterface.Size == sizeof(BUS_INTERFACE_SWENUM));
 607     ASSERT(IoStack->Parameters.QueryInterface.Interface);
 608
 609     /* fill in interface */
 610     Interface = (PBUS_INTERFACE_SWENUM)IoStack->Parameters.QueryInterface.Interface;
 611     Interface->Interface.Size = sizeof(BUS_INTERFACE_SWENUM);
 612     Interface->Interface.Version = BUS_INTERFACE_SWENUM_VERSION;
 613     Interface->Interface.Context = ChildDeviceExtension;
 614     Interface->Interface.InterfaceReference = KspBusDeviceReference;
 615     Interface->Interface.InterfaceDereference = KspBusDeviceDereference;
 616     Interface->ReferenceDeviceObject = KspBusReferenceDeviceObject;
 617     Interface->DereferenceDeviceObject = KspBusDereferenceDeviceObject;
 618     Interface->QueryReferenceString = KspBusQueryReferenceString;
 619
 620     return STATUS_SUCCESS;
 621 }
 622
 623 NTSTATUS
 624 KspEnableBusDeviceInterface(
 625     PBUS_DEVICE_ENTRY DeviceEntry,
 626     BOOLEAN bEnable)
 627 {
 628     PLIST_ENTRY Entry;
 629     PBUS_INSTANCE_ENTRY InstanceEntry;
 630     NTSTATUS Status = STATUS_SUCCESS;
 631
 632     /* enable now all interfaces */
 633     Entry = DeviceEntry->DeviceInterfaceList.Flink;
 634
 635     while(Entry != &DeviceEntry->DeviceInterfaceList)
 636     {
 637         /* get bus instance entry */
 638         InstanceEntry = (PBUS_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BUS_INSTANCE_ENTRY, Entry);
 639         DPRINT1("Enabling %u %wZ Irql %u\n", bEnable, &InstanceEntry->SymbolicLink, KeGetCurrentIrql());
 640
 641         /* set interface state */
 642         Status = IoSetDeviceInterfaceState(&InstanceEntry->SymbolicLink, bEnable);
 643
 644         if (!NT_SUCCESS(Status))
 645         {
 646             /* failed to set interface */
 647             break;
 648         }
 649
 650         /* move to next entry */
 651         Entry = Entry->Flink;
 652     }
 653
 654     /* done */
 655     return Status;
 656 }
 657
 658 NTSTATUS
 659 KspDoReparseForIrp(
 660     PIRP Irp,
 661     PBUS_DEVICE_ENTRY DeviceEntry)
 662 {
 663     ULONG Length;
 664     LPWSTR Buffer;
 665     PIO_STACK_LOCATION IoStack;
 666
 667     /* get stack location */
 668     IoStack = IoGetCurrentIrpStackLocation(Irp);
 669
 670     /* sanity checks */
 671     ASSERT(DeviceEntry->PDODeviceName);
 672     ASSERT(DeviceEntry->Instance);
 673     ASSERT(IoStack->FileObject);
 674     ASSERT(IoStack->FileObject->FileName.Buffer);
 675
 676     /* calculate length */
 677     Length = wcslen(DeviceEntry->PDODeviceName);
 678     Length += wcslen(DeviceEntry->Instance);
 679
 680     /* zero byte and '\\' */
 681     Length += 2;
 682
 683     /* allocate buffer */
 684     Buffer = AllocateItem(NonPagedPool, Length * sizeof(WCHAR));
 685     if (!Buffer)
 686     {
 687         /* no resources */
 688         return STATUS_INSUFFICIENT_RESOURCES;
 689     }
 690
 691     /* construct buffer */
 692     swprintf(Buffer, L"%s\\%s", DeviceEntry->PDODeviceName, DeviceEntry->Instance);
 693
 694     ExFreePool(IoStack->FileObject->FileName.Buffer);
 695
 696     /* store new file name */
 697     RtlInitUnicodeString(&IoStack->FileObject->FileName, Buffer);
 698
 699     /* done */
 700     return STATUS_REPARSE;
 701 }
 702
 703 VOID
 704 KspCompletePendingIrps(
 705     IN PBUS_DEVICE_ENTRY DeviceEntry,
 706     IN OUT NTSTATUS ResultCode)
 707 {
 708     PLIST_ENTRY Entry;
 709     PIRP Irp;
 710     NTSTATUS Status;
 711
 712     /* go through list */
 713     while(!IsListEmpty(&DeviceEntry->IrpPendingList))
 714     {
 715         /* get first entry */
 716         Entry = RemoveHeadList(&DeviceEntry->IrpPendingList);
 717
 718         /* get irp */
 719         Irp = (PIRP)CONTAINING_RECORD(Entry, IRP, Tail.Overlay.ListEntry);
 720
 721         if (ResultCode == STATUS_REPARSE)
 722         {
 723             /* construct reparse information */
 724             Status = KspDoReparseForIrp(Irp, DeviceEntry);
 725         }
 726         else
 727         {
 728             /* use default code */
 729             Status = ResultCode;
 730         }
 731
 732         /* store result code */
 733         Irp->IoStatus.Status = Status;
 734
 735         DPRINT1("Completing IRP %p Status %x\n", Irp, Status);
 736
 737         /* complete the request */
 738         CompleteRequest(Irp, IO_NO_INCREMENT);
 739     }
 740
 741 }
 742
 743
 744
 745 NTSTATUS
 746 KspStartBusDevice(
 747     IN PDEVICE_OBJECT DeviceObject,
 748     IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
 749     IN PIRP Irp)
 750 {
 751     WCHAR PDOName[256];
 752     NTSTATUS Status;
 753     ULONG ResultLength;
 754     LPWSTR Name;
 755     PBUS_DEVICE_ENTRY DeviceEntry;
 756
 757     /* FIXME handle pending remove */
 758
 759     /* get full device name */
 760     Status = IoGetDeviceProperty(DeviceObject, DevicePropertyPhysicalDeviceObjectName, sizeof(PDOName), (PVOID)PDOName, &ResultLength);
 761
 762     if (!NT_SUCCESS(Status))
 763     {
 764         /* failed to get device name */
 765         return Status;
 766     }
 767
 768     /* allocate device name buffer */
 769     Name = AllocateItem(NonPagedPool, (ResultLength + 1) * sizeof(WCHAR));
 770     if (!Name)
 771     {
 772         /* no memory */
 773         return STATUS_INSUFFICIENT_RESOURCES;
 774     }
 775
 776     /* copy name */
 777     wcscpy(Name, PDOName);
 778
 779     /* TODO: time stamp creation time */
 780
 781     /* get device entry */
 782     DeviceEntry = (PBUS_DEVICE_ENTRY)ChildDeviceExtension->DeviceEntry;
 783
 784     /* sanity check */
 785     ASSERT(DeviceEntry);
 786
 787     /* store device name */
 788     DeviceEntry->PDODeviceName = Name;
 789
 790     /* mark device as started */
 791     DeviceEntry->DeviceState = Started;
 792
 793     /* reference start time */
 794     KeQuerySystemTime(&DeviceEntry->TimeCreated);
 795
 796     DPRINT1("KspStartBusDevice Name %S DeviceName %S Instance %S Started\n", Name, DeviceEntry->DeviceName, DeviceEntry->Instance);
 797
 798     /* enable device classes */
 799     //KspEnableBusDeviceInterface(DeviceEntry, TRUE);
 800
 801     /* done */
 802     return STATUS_SUCCESS;
 803 }
 804
 805 NTSTATUS
 806 KspQueryBusDeviceCapabilities(
 807     IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
 808     IN PIRP Irp)
 809 {
 810     PDEVICE_CAPABILITIES Capabilities;
 811     PIO_STACK_LOCATION IoStack;
 812
 813     /* get stack location */
 814     IoStack = IoGetCurrentIrpStackLocation(Irp);
 815
 816     /* get capabilities */
 817     Capabilities = IoStack->Parameters.DeviceCapabilities.Capabilities;
 818
 819     RtlZeroMemory(Capabilities, sizeof(DEVICE_CAPABILITIES));
 820
 821     /* setup capabilities */
 822     Capabilities->UniqueID = TRUE;
 823     Capabilities->SilentInstall = TRUE;
 824     Capabilities->SurpriseRemovalOK = TRUE;
 825     Capabilities->Address = 0;
 826     Capabilities->UINumber = 0;
 827     Capabilities->SystemWake = PowerSystemWorking; /* FIXME common device extension */
 828     Capabilities->DeviceWake = PowerDeviceD0;
 829
 830     /* done */
 831     return STATUS_SUCCESS;
 832 }
 833
 834 NTSTATUS
 835 KspQueryBusInformation(
 836     IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
 837     IN PIRP Irp)
 838 {
 839     PPNP_BUS_INFORMATION BusInformation;
 840
 841     /* allocate bus information */
 842     BusInformation = (PPNP_BUS_INFORMATION)AllocateItem(PagedPool, sizeof(PNP_BUS_INFORMATION));
 843
 844     if (!BusInformation)
 845     {
 846         /* no memory */
 847         return STATUS_INSUFFICIENT_RESOURCES;
 848     }
 849
 850     /* return info */
 851     BusInformation->BusNumber = 0;
 852     BusInformation->LegacyBusType = InterfaceTypeUndefined;
 853     RtlMoveMemory(&BusInformation->BusTypeGuid, &KSMEDIUMSETID_Standard, sizeof(GUID));
 854
 855     /* store result */
 856     Irp->IoStatus.Information = (ULONG_PTR)BusInformation;
 857
 858     /* done */
 859     return STATUS_SUCCESS;
 860 }
 861
 862 NTSTATUS
 863 KspQueryBusDevicePnpState(
 864     IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
 865     IN PIRP Irp)
 866 {
 867     /* set device flags */
 868     Irp->IoStatus.Information = PNP_DEVICE_DONT_DISPLAY_IN_UI | PNP_DEVICE_NOT_DISABLEABLE;
 869
 870     /* done */
 871     return STATUS_SUCCESS;
 872 }
 873
 874 NTSTATUS
 875 KspQueryId(
 876     IN PCOMMON_DEVICE_EXTENSION ChildDeviceExtension,
 877     IN PIRP Irp)
 878 {
 879     PIO_STACK_LOCATION IoStack;
 880     PBUS_DEVICE_ENTRY DeviceEntry;
 881     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
 882     LPWSTR Name;
 883     ULONG Length;
 884
 885     /* get current irp stack location */
 886     IoStack = IoGetCurrentIrpStackLocation(Irp);
 887
 888     if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
 889     {
 890         /* get device entry */
 891         DeviceEntry = (PBUS_DEVICE_ENTRY) ChildDeviceExtension->DeviceEntry;
 892
 893         /* sanity check */
 894         ASSERT(DeviceEntry);
 895         ASSERT(DeviceEntry->Instance);
 896
 897         /* calculate length */
 898         Length = wcslen(DeviceEntry->Instance) + 1;
 899
 900         /* allocate buffer */
 901         Name = AllocateItem(PagedPool, Length * sizeof(WCHAR));
 902
 903         if (!Name)
 904         {
 905             /* failed to allocate buffer */
 906             return STATUS_INSUFFICIENT_RESOURCES;
 907         }
 908
 909         /* copy buffer */
 910         wcscpy(Name, DeviceEntry->Instance);
 911
 912         /* store result */
 913         Irp->IoStatus.Information = (ULONG_PTR)Name;
 914
 915         /* done */
 916         return STATUS_SUCCESS;
 917     }
 918     else if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID ||
 919              IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
 920     {
 921         /* get device entry */
 922         DeviceEntry = (PBUS_DEVICE_ENTRY) ChildDeviceExtension->DeviceEntry;
 923
 924         /* get bus device extension */
 925         BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION) ChildDeviceExtension->BusDeviceExtension;
 926
 927         /* sanity check */
 928         ASSERT(DeviceEntry);
 929         ASSERT(DeviceEntry->BusId);
 930         ASSERT(BusDeviceExtension);
 931         ASSERT(BusDeviceExtension->BusIdentifier);
 932
 933         /* calculate length */
 934         Length = wcslen(BusDeviceExtension->BusIdentifier);
 935         Length += wcslen(DeviceEntry->BusId);
 936
 937         /* extra length for '\\' and zero byte */
 938         Length += 2;
 939
 940         /* allocate buffer */
 941         Name = ExAllocatePool(PagedPool, Length * sizeof(WCHAR));
 942         if (!Name)
 943         {
 944             /* failed to allocate buffer */
 945             return STATUS_INSUFFICIENT_RESOURCES;
 946         }
 947
 948         /* construct id */
 949         swprintf(Name, L"%s\\%s", BusDeviceExtension->BusIdentifier, DeviceEntry->BusId);
 950
 951         /* store result */
 952         Irp->IoStatus.Information = (ULONG_PTR)Name;
 953
 954         /* done */
 955         return STATUS_SUCCESS;
 956     }
 957     else
 958     {
 959         /* other ids are not supported */
 960         //DPRINT1("Not Supported ID Type %x\n", IoStack->Parameters.QueryId.IdType);
 961         return Irp->IoStatus.Status;
 962     }
 963 }
 964
 965 NTSTATUS
 966 KspInstallInterface(
 967     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
 968     IN PSWENUM_INSTALL_INTERFACE InstallInterface)
 969 {
 970     ULONG Length, Index;
 971     UNICODE_STRING DeviceString, InterfaceString, ReferenceString;
 972     HANDLE hKey, hDeviceKey, hInterfaceKey, hReferenceKey;
 973     NTSTATUS Status;
 974     OBJECT_ATTRIBUTES ObjectAttributes;
 975
 976     /* sanity check */
 977     ASSERT(InstallInterface);
 978
 979     /* calculate length */
 980     Length = wcslen(InstallInterface->ReferenceString);
 981
 982     /* check for invalid characters */
 983     for(Index = 0; Index < Length; Index++)
 984     {
 985         if (InstallInterface->ReferenceString[Index] <= L' ' ||
 986             InstallInterface->ReferenceString[Index] > L'~' ||
 987             InstallInterface->ReferenceString[Index] == L',' ||
 988             InstallInterface->ReferenceString[Index] == L'\\' ||
 989             InstallInterface->ReferenceString[Index] == L'/')
 990         {
 991             /* invalid character */
 992             return STATUS_INVALID_PARAMETER;
 993         }
 994     }
 995
 996     /* open bus key */
 997     Status = KspOpenBusRegistryKey(BusDeviceExtension, &hKey);
 998     if (NT_SUCCESS(Status))
 999     {
1000         /* convert device guid to string */
1001         Status = RtlStringFromGUID(&InstallInterface->DeviceId, &DeviceString);
1002         if (NT_SUCCESS(Status))
1003         {
1004             /* initialize object attributes */
1005             InitializeObjectAttributes(&ObjectAttributes, &DeviceString, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hKey, NULL);
1006
1007             /* construct device key */
1008             Status = ZwCreateKey(&hDeviceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
1009             if (NT_SUCCESS(Status))
1010             {
1011                 /* initialize reference string */
1012                 RtlInitUnicodeString(&ReferenceString, InstallInterface->ReferenceString);
1013
1014                 /* initialize object attributes */
1015                 InitializeObjectAttributes(&ObjectAttributes, &ReferenceString, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hDeviceKey, NULL);
1016
1017                 /* construct device key */
1018                 Status = ZwCreateKey(&hReferenceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
1019                 if (NT_SUCCESS(Status))
1020                 {
1021                     /* convert interface guid to string */
1022                     Status = RtlStringFromGUID(&InstallInterface->InterfaceId, &InterfaceString);
1023                     if (NT_SUCCESS(Status))
1024                     {
1025                         /* initialize object attributes */
1026                         InitializeObjectAttributes(&ObjectAttributes, &InterfaceString, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hReferenceKey, NULL);
1027
1028                         /* construct device key */
1029                         Status = ZwCreateKey(&hInterfaceKey, GENERIC_WRITE, &ObjectAttributes, 0, NULL, 0, NULL);
1030                         if (NT_SUCCESS(Status))
1031                         {
1032                             /* close key */
1033                             ZwClose(hInterfaceKey);
1034                         }
1035                         /* free interface string */
1036                         RtlFreeUnicodeString(&InterfaceString);
1037                     }
1038                     /* close reference key */
1039                     ZwClose(hReferenceKey);
1040                 }
1041                 /* close device key */
1042                 ZwClose(hDeviceKey);
1043             }
1044             /* free device string */
1045             RtlFreeUnicodeString(&DeviceString);
1046         }
1047         /* close bus key */
1048         ZwClose(hKey);
1049     }
1050
1051     /* done */
1052     return Status;
1053  }
1054
1055 VOID
1056 NTAPI
1057 KspInstallBusEnumInterface(
1058     IN PVOID Ctx)
1059 {
1060     PIO_STACK_LOCATION IoStack;
1061     NTSTATUS Status;
1062     PLIST_ENTRY Entry;
1063     PBUS_DEVICE_ENTRY DeviceEntry;
1064     PSWENUM_INSTALL_INTERFACE InstallInterface;
1065     KIRQL OldLevel;
1066     PBUS_INSTALL_ENUM_CONTEXT Context = (PBUS_INSTALL_ENUM_CONTEXT)Ctx;
1067
1068     /* get current irp stack location */
1069     IoStack = IoGetCurrentIrpStackLocation(Context->Irp);
1070
1071     /* get install request */
1072     InstallInterface = (PSWENUM_INSTALL_INTERFACE)Context->Irp->AssociatedIrp.SystemBuffer;
1073
1074     /* sanity check */
1075     ASSERT(InstallInterface);
1076     ASSERT(Context->BusDeviceExtension);
1077
1078     if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SWENUM_INSTALL_INTERFACE))
1079     {
1080         /* buffer too small */
1081         Context->Status = STATUS_INVALID_PARAMETER;
1082
1083         /* signal completion */
1084         KeSetEvent(&Context->Event, 0, FALSE);
1085
1086         /* done */
1087         return;
1088     }
1089
1090     /* FIXME locks */
1091
1092     /* now install the interface */
1093     Status = KspInstallInterface(Context->BusDeviceExtension, InstallInterface);
1094     if (!NT_SUCCESS(Status))
1095     {
1096         /* failed to install interface */
1097         Context->Status = Status;
1098
1099         /* signal completion */
1100         KeSetEvent(&Context->Event, 0, FALSE);
1101
1102         /* done */
1103         return;
1104     }
1105
1106     /* acquire device entry lock */
1107     KeAcquireSpinLock(&Context->BusDeviceExtension->Lock, &OldLevel);
1108
1109     /* now iterate all device entries */
1110     Entry = Context->BusDeviceExtension->Common.Entry.Flink;
1111     while(Entry != &Context->BusDeviceExtension->Common.Entry)
1112     {
1113         /* get device entry */
1114         DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
1115
1116         if (IsEqualGUIDAligned(&DeviceEntry->DeviceGuid, &InstallInterface->DeviceId) &&
1117             !wcsicmp(DeviceEntry->Instance, InstallInterface->ReferenceString))
1118         {
1119             if (!DeviceEntry->PDO)
1120             {
1121                 /* create pdo */
1122                 Status = KspCreatePDO(Context->BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
1123
1124                 /* done */
1125                 break;
1126             }
1127         }
1128
1129         /* move to next entry */
1130         Entry = Entry->Flink;
1131     }
1132
1133     /* release device entry lock */
1134     KeReleaseSpinLock(&Context->BusDeviceExtension->Lock, OldLevel);
1135
1136     /* signal that bus driver relations has changed */
1137     IoInvalidateDeviceRelations(Context->BusDeviceExtension->PhysicalDeviceObject, BusRelations);
1138
1139     /* update status */
1140     Context->Status = Status;
1141
1142     /* signal completion */
1143     KeSetEvent(&Context->Event, 0, FALSE);
1144 }
1145
1146
1147 VOID
1148 NTAPI
1149 KspBusWorkerRoutine(
1150   IN PVOID Parameter)
1151 {
1152     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1153     PBUS_DEVICE_ENTRY DeviceEntry;
1154     PLIST_ENTRY Entry;
1155     LARGE_INTEGER Time, Diff;
1156     BOOLEAN DoInvalidate = FALSE;
1157     KIRQL OldLevel;
1158
1159     /* get device extension */
1160     BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)Parameter;
1161
1162     /* acquire lock */
1163     KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1164
1165     /* get current time */
1166     KeQuerySystemTime(&Time);
1167
1168     /* enumerate all device entries */
1169     Entry = BusDeviceExtension->Common.Entry.Flink;
1170     while(Entry != &BusDeviceExtension->Common.Entry)
1171     {
1172         /* get offset to device entry */
1173         DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
1174
1175         /* sanity check */
1176         ASSERT(DeviceEntry);
1177
1178         //DPRINT1("DeviceEntry %p PDO %p State %x\n", DeviceEntry, DeviceEntry->PDO, DeviceEntry->DeviceState);
1179
1180         if (DeviceEntry->PDO)
1181         {
1182             if (DeviceEntry->DeviceState == NotStarted)
1183             {
1184                 Diff.QuadPart = Time.QuadPart - DeviceEntry->TimeCreated.QuadPart;
1185
1186                 if (Diff.QuadPart > Int32x32To64(15000, 10000))
1187                 {
1188                      DPRINT1("DeviceID %S  Instance %S TimeCreated %I64u Now %I64u Diff %I64u hung\n", DeviceEntry->DeviceName, DeviceEntry->Instance, DeviceEntry->TimeCreated.QuadPart, Time.QuadPart, Diff.QuadPart);
1189
1190                      /* release spin lock */
1191                      KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1192
1193                      /* deactivate interfaces */
1194                      //KspEnableBusDeviceInterface(DeviceEntry, FALSE);
1195
1196                      /* re-acquire lock */
1197                      KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1198
1199                      /* pending remove device object */
1200                      DeviceEntry->DeviceState = StopPending;
1201
1202                      /* perform invalidation */
1203                      DoInvalidate = TRUE;
1204                 }
1205             }
1206             else if (DeviceEntry->DeviceState == Started)
1207             {
1208                 /* found pending irps */
1209                 KspCompletePendingIrps(DeviceEntry, STATUS_REPARSE);
1210             }
1211         }
1212
1213
1214         /* move to next */
1215         Entry = Entry->Flink;
1216     }
1217
1218    /* release lock */
1219     KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1220
1221     if (DoInvalidate)
1222     {
1223         /* invalidate device relations */
1224         IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
1225     }
1226
1227     Time.QuadPart = Int32x32To64(5000, -10000);
1228     KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
1229 }
1230
1231 VOID
1232 NTAPI
1233 KspBusDpcRoutine(
1234     IN PKDPC Dpc,
1235     IN PVOID DeferredContext OPTIONAL,
1236     IN PVOID SystemArgument1 OPTIONAL,
1237     IN PVOID SystemArgument2 OPTIONAL)
1238 {
1239     /* get device extension */
1240     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeferredContext;
1241
1242     /* queue the item */
1243     ExQueueWorkItem(&BusDeviceExtension->WorkItem, DelayedWorkQueue);
1244 }
1245
1246 VOID
1247 NTAPI
1248 KspRemoveBusInterface(
1249     PVOID Ctx)
1250 {
1251     PBUS_INSTALL_ENUM_CONTEXT Context =(PBUS_INSTALL_ENUM_CONTEXT)Ctx;
1252
1253     /* TODO
1254      * get SWENUM_INSTALL_INTERFACE struct
1255      * open device key and delete the keys
1256      */
1257
1258     UNIMPLEMENTED
1259
1260     /* set status */
1261     Context->Status = STATUS_NOT_IMPLEMENTED;
1262
1263
1264     /* signal completion */
1265     KeSetEvent(&Context->Event, IO_NO_INCREMENT, FALSE);
1266 }
1267
1268 NTSTATUS
1269 KspQueryBusRelations(
1270     IN PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension,
1271     IN PIRP Irp)
1272 {
1273     PDEVICE_RELATIONS DeviceRelations;
1274     PLIST_ENTRY Entry;
1275     PBUS_DEVICE_ENTRY DeviceEntry;
1276     ULONG Count = 0, Length;
1277     KIRQL OldLevel;
1278
1279     /* acquire lock */
1280     KeAcquireSpinLock(&BusDeviceExtension->Lock, &OldLevel);
1281
1282     /* first scan all device entries */
1283     Entry = BusDeviceExtension->Common.Entry.Flink;
1284
1285     while(Entry != &BusDeviceExtension->Common.Entry)
1286     {
1287         /* get offset to device entry */
1288         DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
1289
1290         /* is there a pdo yet */
1291         if (DeviceEntry->PDO && (DeviceEntry->DeviceState == NotStarted || DeviceEntry->DeviceState == Started))
1292         {
1293             /* increment count */
1294             Count++;
1295         }
1296
1297         /* move to next entry */
1298         Entry = Entry->Flink;
1299     }
1300
1301     /* calculate length */
1302     Length = sizeof(DEVICE_RELATIONS) + (Count > 1 ? sizeof(PDEVICE_OBJECT) * (Count-1) : 0);
1303
1304     /* allocate device relations */
1305     DeviceRelations = (PDEVICE_RELATIONS)AllocateItem(NonPagedPool, Length);
1306
1307     if (!DeviceRelations)
1308     {
1309         /* not enough memory */
1310         KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1311         return STATUS_INSUFFICIENT_RESOURCES;
1312     }
1313
1314     /* rescan device entries */
1315     Entry = BusDeviceExtension->Common.Entry.Flink;
1316
1317     while(Entry != &BusDeviceExtension->Common.Entry)
1318     {
1319         /* get offset to device entry */
1320         DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
1321
1322         /* is there a pdo yet */
1323         if (DeviceEntry->PDO && (DeviceEntry->DeviceState == NotStarted || DeviceEntry->DeviceState == Started))
1324         {
1325             /* store pdo */
1326             DeviceRelations->Objects[DeviceRelations->Count] = DeviceEntry->PDO;
1327
1328             /* reference device object */
1329             ObReferenceObject(DeviceEntry->PDO);
1330
1331             /* increment pdo count */
1332             DeviceRelations->Count++;
1333         }
1334
1335         /* move to next entry */
1336         Entry = Entry->Flink;
1337     }
1338
1339     /* release lock */
1340     KeReleaseSpinLock(&BusDeviceExtension->Lock, OldLevel);
1341
1342     /* FIXME handle existing device relations */
1343     ASSERT(Irp->IoStatus.Information == 0);
1344
1345     /* store device relations */
1346     Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
1347
1348     /* done */
1349     return STATUS_SUCCESS;
1350 }
1351
1352 //------------------------------------------------------------------------------------
1353
1354 /*
1355     @implemented
1356 */
1357
1358 KSDDKAPI
1359 NTSTATUS
1360 NTAPI
1361 KsGetBusEnumIdentifier(
1362     IN PIRP Irp)
1363 {
1364     PDEV_EXTENSION DeviceExtension;
1365     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1366     PIO_STACK_LOCATION IoStack;
1367     ULONG Length;
1368     NTSTATUS Status;
1369     LPWSTR Buffer;
1370
1371     DPRINT1("KsGetBusEnumIdentifier\n");
1372
1373     /* get stack location */
1374     IoStack = IoGetCurrentIrpStackLocation(Irp);
1375
1376     /* sanity checks */
1377     ASSERT(IoStack->DeviceObject);
1378     ASSERT(IoStack->DeviceObject->DeviceExtension);
1379
1380     /* get device extension */
1381     DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
1382
1383     /* get bus device extension */
1384     BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1385
1386     /* sanity checks */
1387     ASSERT(BusDeviceExtension);
1388     ASSERT(BusDeviceExtension->Common.IsBus);
1389
1390     if (!BusDeviceExtension)
1391     {
1392         /* invalid parameter */
1393         return STATUS_INVALID_PARAMETER;
1394     }
1395
1396     /* get length */
1397     Length = (wcslen(BusDeviceExtension->BusIdentifier)+1) * sizeof(WCHAR);
1398
1399     /* is there an output buffer provided */
1400     if (IoStack->Parameters.DeviceIoControl.InputBufferLength)
1401     {
1402         if (Length > IoStack->Parameters.DeviceIoControl.InputBufferLength)
1403         {
1404             /* buffer is too small */
1405             return STATUS_BUFFER_TOO_SMALL;
1406         }
1407
1408         /* now allocate buffer */
1409         Buffer = AllocateItem(NonPagedPool, Length);
1410         if (!Buffer)
1411         {
1412             /* no memory */
1413             Status = STATUS_INSUFFICIENT_RESOURCES;
1414         }
1415         else
1416         {
1417             /* copy bus identifier */
1418             wcscpy(Buffer, BusDeviceExtension->BusIdentifier);
1419
1420             /* store buffer */
1421             Irp->AssociatedIrp.SystemBuffer = Buffer;
1422
1423             /* set flag that buffer gets copied back */
1424             Irp->Flags |= IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER | IRP_INPUT_OPERATION;
1425
1426             /* done */
1427             Status = STATUS_SUCCESS;
1428         }
1429     }
1430     else
1431     {
1432         /* no buffer provided */
1433         Status = STATUS_BUFFER_OVERFLOW;
1434     }
1435
1436     /* done */
1437     Irp->IoStatus.Status = Status;
1438     return Status;
1439 }
1440
1441 /*
1442     @implemented
1443 */
1444 KSDDKAPI
1445 NTSTATUS
1446 NTAPI
1447 KsGetBusEnumParentFDOFromChildPDO(
1448     IN PDEVICE_OBJECT DeviceObject,
1449     OUT PDEVICE_OBJECT *FunctionalDeviceObject)
1450 {
1451     PDEV_EXTENSION DeviceExtension;
1452
1453     DPRINT1("KsGetBusEnumParentFDOFromChildPDO\n");
1454
1455     /* get device extension */
1456     DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1457
1458     /* check if this is child pdo */
1459     if (DeviceExtension->Ext->IsBus == FALSE)
1460     {
1461         /* return bus device object */
1462         *FunctionalDeviceObject = DeviceExtension->Ext->BusDeviceExtension->BusDeviceObject;
1463
1464         /* done */
1465         return STATUS_SUCCESS;
1466     }
1467
1468     /* invalid parameter */
1469     return STATUS_INVALID_PARAMETER;
1470 }
1471
1472
1473 /*
1474     @implemented
1475 */
1476 KSDDKAPI
1477 NTSTATUS
1478 NTAPI
1479 KsCreateBusEnumObject(
1480     IN PWCHAR BusIdentifier,
1481     IN PDEVICE_OBJECT BusDeviceObject,
1482     IN PDEVICE_OBJECT PhysicalDeviceObject,
1483     IN PDEVICE_OBJECT PnpDeviceObject OPTIONAL,
1484     IN REFGUID InterfaceGuid OPTIONAL,
1485     IN PWCHAR ServiceRelativePath OPTIONAL)
1486 {
1487     ULONG Length;
1488     NTSTATUS Status = STATUS_SUCCESS;
1489     UNICODE_STRING ServiceKeyPath = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Services\\");
1490     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1491     PDEV_EXTENSION DeviceExtension;
1492
1493     DPRINT1("KsCreateBusEnumObject %S BusDeviceObject %p\n", ServiceRelativePath, BusDeviceObject);
1494
1495     /* calculate sizeof bus enum device extension */
1496     Length = wcslen(BusIdentifier) * sizeof(WCHAR);
1497     Length += sizeof(BUS_ENUM_DEVICE_EXTENSION);
1498
1499     BusDeviceExtension = AllocateItem(NonPagedPool, Length);
1500     if (!BusDeviceExtension)
1501     {
1502         /* not enough memory */
1503
1504         return STATUS_INSUFFICIENT_RESOURCES;
1505     }
1506
1507     /* get device extension */
1508     DeviceExtension = (PDEV_EXTENSION)BusDeviceObject->DeviceExtension;
1509
1510     DPRINT1("DeviceExtension %p BusDeviceExtension %p\n", DeviceExtension, DeviceExtension->Ext);
1511
1512     /* store bus device extension */
1513     DeviceExtension->Ext = (PCOMMON_DEVICE_EXTENSION)BusDeviceExtension;
1514
1515     DPRINT1("DeviceExtension %p BusDeviceExtension %p\n", DeviceExtension, DeviceExtension->Ext);
1516
1517
1518     /* zero device extension */
1519     RtlZeroMemory(BusDeviceExtension, sizeof(BUS_ENUM_DEVICE_EXTENSION));
1520
1521     /* initialize bus device extension */
1522     wcscpy(BusDeviceExtension->BusIdentifier, BusIdentifier);
1523
1524     /* allocate service path string */
1525     Length = ServiceKeyPath.MaximumLength;
1526     Length += BusDeviceObject->DriverObject->DriverExtension->ServiceKeyName.MaximumLength;
1527
1528     if (ServiceRelativePath)
1529     {
1530         /* relative path for devices */
1531         Length += (wcslen(ServiceRelativePath) + 2) * sizeof(WCHAR);
1532     }
1533
1534     BusDeviceExtension->ServicePath.Length = 0;
1535     BusDeviceExtension->ServicePath.MaximumLength = (USHORT)Length;
1536     BusDeviceExtension->ServicePath.Buffer = AllocateItem(NonPagedPool, Length);
1537
1538     if (!BusDeviceExtension->ServicePath.Buffer)
1539     {
1540         /* not enough memory */
1541         FreeItem(BusDeviceExtension);
1542
1543         return STATUS_INSUFFICIENT_RESOURCES;
1544     }
1545
1546     RtlAppendUnicodeStringToString(&BusDeviceExtension->ServicePath, &ServiceKeyPath);
1547     RtlAppendUnicodeStringToString(&BusDeviceExtension->ServicePath, &BusDeviceObject->DriverObject->DriverExtension->ServiceKeyName);
1548
1549     if (ServiceRelativePath)
1550     {
1551         RtlAppendUnicodeToString(&BusDeviceExtension->ServicePath, L"\\");
1552         RtlAppendUnicodeToString(&BusDeviceExtension->ServicePath, ServiceRelativePath);
1553     }
1554
1555     if (InterfaceGuid)
1556     {
1557         /* register an device interface */
1558         Status = IoRegisterDeviceInterface(PhysicalDeviceObject, InterfaceGuid, NULL, &BusDeviceExtension->DeviceInterfaceLink);
1559
1560         /* check for success */
1561         if (!NT_SUCCESS(Status))
1562         {
1563
1564             FreeItem(BusDeviceExtension->ServicePath.Buffer);
1565             FreeItem(BusDeviceExtension);
1566             return Status;
1567         }
1568
1569         /* now enable device interface */
1570         Status = IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, TRUE);
1571
1572         if (!NT_SUCCESS(Status))
1573         {
1574             FreeItem(BusDeviceExtension->ServicePath.Buffer);
1575             FreeItem(BusDeviceExtension);
1576             return Status;
1577         }
1578     }
1579
1580     /* initialize common device extension */
1581     BusDeviceExtension->Common.BusDeviceExtension = NULL;
1582     BusDeviceExtension->Common.DeviceObjectReferenceCount = 1;
1583     BusDeviceExtension->Common.DeviceReferenceCount = 1;
1584     BusDeviceExtension->Common.IsBus = TRUE;
1585     InitializeListHead(&BusDeviceExtension->Common.Entry);
1586
1587     /* store device objects */
1588     BusDeviceExtension->BusDeviceObject = BusDeviceObject;
1589     BusDeviceExtension->PhysicalDeviceObject = PhysicalDeviceObject;
1590
1591     /* initialize lock */
1592     KeInitializeSpinLock(&BusDeviceExtension->Lock);
1593
1594     /* initialize timer */
1595     KeInitializeTimer(&BusDeviceExtension->Timer);
1596
1597     /* initialize dpc */
1598     KeInitializeDpc(&BusDeviceExtension->Dpc, KspBusDpcRoutine, (PVOID)BusDeviceExtension);
1599
1600     /* initialize event */
1601     KeInitializeEvent(&BusDeviceExtension->Event, SynchronizationEvent, FALSE);
1602
1603     /* initialize work item */
1604     ExInitializeWorkItem(&BusDeviceExtension->WorkItem, KspBusWorkerRoutine, (PVOID)BusDeviceExtension);
1605
1606     if (!PnpDeviceObject)
1607     {
1608         /* attach device */
1609         BusDeviceExtension->PnpDeviceObject = IoAttachDeviceToDeviceStack(BusDeviceObject, PhysicalDeviceObject);
1610
1611         if (!BusDeviceExtension->PnpDeviceObject)
1612         {
1613             /* failed to attach device */
1614             if (BusDeviceExtension->DeviceInterfaceLink.Buffer)
1615             {
1616                 IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, FALSE);
1617                 RtlFreeUnicodeString(&BusDeviceExtension->DeviceInterfaceLink);
1618             }
1619
1620             /* free device extension */
1621             FreeItem(BusDeviceExtension->ServicePath.Buffer);
1622             FreeItem(BusDeviceExtension);
1623
1624             return STATUS_DEVICE_REMOVED;
1625         }
1626
1627         /* mark device as attached */
1628         BusDeviceExtension->DeviceAttached = TRUE;
1629     }
1630     else
1631     {
1632         /* directly attach */
1633         BusDeviceExtension->PnpDeviceObject = PnpDeviceObject;
1634     }
1635
1636     /* now scan the bus */
1637     Status = KspScanBus(BusDeviceExtension);
1638
1639     /* check for success */
1640     if (!NT_SUCCESS(Status))
1641     {
1642         /* failed to scan bus */
1643         if (BusDeviceExtension->DeviceInterfaceLink.Buffer)
1644         {
1645             IoSetDeviceInterfaceState(&BusDeviceExtension->DeviceInterfaceLink, FALSE);
1646             RtlFreeUnicodeString(&BusDeviceExtension->DeviceInterfaceLink);
1647         }
1648
1649         if (BusDeviceExtension->DeviceAttached)
1650         {
1651             /* detach device */
1652             IoDetachDevice(BusDeviceExtension->PnpDeviceObject);
1653         }
1654
1655         /* free device extension */
1656         FreeItem(BusDeviceExtension->ServicePath.Buffer);
1657         FreeItem(BusDeviceExtension);
1658     }
1659
1660     DPRINT("KsCreateBusEnumObject Status %x\n", Status);
1661     /* done */
1662     return Status;
1663 }
1664
1665 /*
1666     @implemented
1667 */
1668 KSDDKAPI
1669 NTSTATUS
1670 NTAPI
1671 KsGetBusEnumPnpDeviceObject(
1672     IN PDEVICE_OBJECT DeviceObject,
1673     IN PDEVICE_OBJECT *PnpDeviceObject)
1674 {
1675     PDEV_EXTENSION DeviceExtension;
1676     PCOMMON_DEVICE_EXTENSION CommonDeviceExtension;
1677     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1678
1679     DPRINT("KsGetBusEnumPnpDeviceObject\n");
1680
1681     if (!DeviceObject->DeviceExtension)
1682     {
1683         /* invalid parameter */
1684         return STATUS_INVALID_PARAMETER;
1685     }
1686
1687     /* get device extension */
1688     DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1689
1690     /* get common device extension */
1691     CommonDeviceExtension = DeviceExtension->Ext;
1692
1693     if (!CommonDeviceExtension)
1694     {
1695         /* invalid parameter */
1696         return STATUS_INVALID_PARAMETER;
1697     }
1698
1699     if (!CommonDeviceExtension->IsBus)
1700     {
1701         /* getting pnp device object is only supported for software bus device object */
1702        return STATUS_INVALID_PARAMETER;
1703     }
1704
1705     /* sanity checks */
1706     ASSERT(CommonDeviceExtension);
1707     ASSERT(CommonDeviceExtension->IsBus);
1708
1709     /* cast to bus device extension */
1710     BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)CommonDeviceExtension;
1711
1712     /* store result */
1713     *PnpDeviceObject = BusDeviceExtension->PnpDeviceObject;
1714
1715     /* done */
1716     return STATUS_SUCCESS;
1717 }
1718
1719 /*
1720     @implemented
1721 */
1722 KSDDKAPI
1723 NTSTATUS
1724 NTAPI
1725 KsInstallBusEnumInterface(
1726     PIRP Irp)
1727 {
1728     BUS_INSTALL_ENUM_CONTEXT Context;
1729     KPROCESSOR_MODE Mode;
1730     LUID luid;
1731     PIO_STACK_LOCATION IoStack;
1732     PDEV_EXTENSION DeviceExtension;
1733     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1734
1735     DPRINT1("KsInstallBusEnumInterface\n");
1736
1737     /* get current irp stack location */
1738     IoStack = IoGetCurrentIrpStackLocation(Irp);
1739
1740     /* get previous mode */
1741     Mode = ExGetPreviousMode();
1742
1743     /* convert to luid */
1744     luid = RtlConvertUlongToLuid(SE_LOAD_DRIVER_PRIVILEGE);
1745
1746     /* perform access check */
1747     if (!SeSinglePrivilegeCheck(luid, Mode))
1748     {
1749         /* insufficient privileges */
1750         return STATUS_PRIVILEGE_NOT_HELD;
1751     }
1752
1753     /* get device extension */
1754     DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
1755
1756     /* get bus device extension */
1757     BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1758
1759
1760     /* initialize context */
1761     Context.Irp = Irp;
1762     KeInitializeEvent(&Context.Event, NotificationEvent, FALSE);
1763     Context.BusDeviceExtension = BusDeviceExtension;
1764     ExInitializeWorkItem(&Context.WorkItem, KspInstallBusEnumInterface, (PVOID)&Context);
1765
1766     /* queue the work item */
1767     ExQueueWorkItem(&Context.WorkItem, DelayedWorkQueue);
1768     /* wait for completion */
1769     KeWaitForSingleObject(&Context.Event, Executive, KernelMode, FALSE, NULL);
1770
1771     /* store result */
1772     Irp->IoStatus.Status = Context.Status;
1773
1774     /* done */
1775     return Context.Status;
1776 }
1777
1778 /*
1779     @implemented
1780 */
1781 KSDDKAPI
1782 NTSTATUS
1783 NTAPI
1784 KsIsBusEnumChildDevice(
1785     IN PDEVICE_OBJECT DeviceObject,
1786     OUT PBOOLEAN ChildDevice)
1787 {
1788     PDEV_EXTENSION DeviceExtension;
1789     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1790
1791     DPRINT("KsIsBusEnumChildDevice %p\n", DeviceObject);
1792
1793     /* get device extension */
1794     DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1795
1796     /* get bus device extension */
1797     BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1798
1799     if (!BusDeviceExtension)
1800     {
1801         /* not a bus device */
1802         return STATUS_INVALID_PARAMETER;
1803     }
1804
1805     /* store result */
1806     *ChildDevice = (BusDeviceExtension->Common.IsBus == FALSE);
1807
1808     return STATUS_SUCCESS;
1809 }
1810
1811 /*
1812     @implemented
1813 */
1814 KSDDKAPI
1815 NTSTATUS
1816 NTAPI
1817 KsServiceBusEnumCreateRequest(
1818     IN PDEVICE_OBJECT DeviceObject,
1819     IN OUT PIRP Irp)
1820 {
1821     PLIST_ENTRY Entry;
1822     PBUS_DEVICE_ENTRY DeviceEntry = NULL; /* fix gcc */
1823     PIO_STACK_LOCATION IoStack;
1824     BOOLEAN ItemExists = FALSE;
1825     PDEV_EXTENSION DeviceExtension;
1826     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1827     //PCOMMON_DEVICE_EXTENSION ChildDeviceExtension;
1828     NTSTATUS Status;
1829     LARGE_INTEGER Time;
1830
1831     /* FIXME: locks */
1832
1833     /* get device extension */
1834     DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1835
1836     /* get bus device extension */
1837     BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1838
1839     /* get current irp stack location */
1840     IoStack = IoGetCurrentIrpStackLocation(Irp);
1841
1842     /* sanity checks */
1843     ASSERT(IoStack->FileObject);
1844     ASSERT(IoStack->FileObject->FileName.Buffer);
1845
1846     DPRINT1("KsServiceBusEnumCreateRequest IRP %p Name %wZ\n", Irp, &IoStack->FileObject->FileName);
1847
1848     /* scan list and check if it is already present */
1849     Entry = BusDeviceExtension->Common.Entry.Flink;
1850
1851     while(Entry != &BusDeviceExtension->Common.Entry)
1852     {
1853         /* get real offset */
1854         DeviceEntry = (PBUS_DEVICE_ENTRY)CONTAINING_RECORD(Entry, BUS_DEVICE_ENTRY, Entry);
1855
1856         /* check if name matches */
1857         if (!wcsicmp(DeviceEntry->DeviceName, IoStack->FileObject->FileName.Buffer + 1))
1858         {
1859             /* item already exists */
1860             ItemExists = TRUE;
1861             break;
1862         }
1863
1864         /* move to next entry */
1865         Entry = Entry->Flink;
1866     }
1867
1868     if (!ItemExists)
1869     {
1870         /* interface not registered */
1871         DPRINT1("Interface %wZ not registered\n", &IoStack->FileObject->FileName);
1872         return STATUS_OBJECT_NAME_NOT_FOUND;
1873     }
1874
1875     /*  is there a pdo yet */
1876     if (DeviceEntry->PDO)
1877     {
1878         if (DeviceEntry->DeviceState == Started)
1879         {
1880             /* issue reparse */
1881             Status =  KspDoReparseForIrp(Irp, DeviceEntry);
1882             DPRINT("REPARSE Irp %p '%wZ'\n", Irp, &IoStack->FileObject->FileName);
1883
1884             Irp->IoStatus.Status = Status;
1885             return Status;
1886         }
1887
1888         /* delay processing until pnp is finished with enumeration */
1889         IoMarkIrpPending(Irp);
1890
1891         /* insert into irp pending list */
1892         InsertTailList(&DeviceEntry->IrpPendingList, &Irp->Tail.Overlay.ListEntry);
1893
1894         Time.QuadPart = Int32x32To64(1500, -10000);
1895         DbgPrint("PENDING Irp %p %wZ\n", Irp, &IoStack->FileObject->FileName);
1896
1897         /* query current time */
1898         KeQuerySystemTime(&DeviceEntry->TimeCreated);
1899
1900         /* set timer */
1901         KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
1902
1903         /* done for now */
1904         return STATUS_PENDING;
1905
1906     }
1907     else
1908     {
1909         /* time to create PDO */
1910         Status = KspCreatePDO(BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
1911
1912         if (!NT_SUCCESS(Status))
1913         {
1914             /* failed to create PDO */
1915             DPRINT1("KsServiceBusEnumCreateRequest failed to create PDO with %x\n", Status);
1916             return Status;
1917         }
1918         DPRINT1("PENDING CREATE Irp %p %wZ\n", Irp, &IoStack->FileObject->FileName);
1919
1920         /* delay processing until pnp is finished with enumeration */
1921         IoMarkIrpPending(Irp);
1922
1923         /* insert into irp pending list */
1924         InsertTailList(&DeviceEntry->IrpPendingList, &Irp->Tail.Overlay.ListEntry);
1925
1926         /* get current time */
1927         KeQuerySystemTime(&DeviceEntry->TimeCreated);
1928
1929         /* invalidate device relations */
1930         IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
1931
1932         /* done for now */
1933         return STATUS_PENDING;
1934     }
1935 }
1936
1937 /*
1938     @implemented
1939 */
1940 KSDDKAPI
1941 NTSTATUS
1942 NTAPI
1943 KsServiceBusEnumPnpRequest(
1944     IN PDEVICE_OBJECT DeviceObject,
1945     IN OUT PIRP Irp)
1946 {
1947     PDEV_EXTENSION DeviceExtension;
1948     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
1949     PCOMMON_DEVICE_EXTENSION ChildDeviceExtension;
1950     PIO_STACK_LOCATION IoStack;
1951     NTSTATUS Status;
1952     LARGE_INTEGER Time;
1953     PDEVICE_RELATIONS DeviceRelation;
1954     PBUS_DEVICE_ENTRY DeviceEntry;
1955
1956     /* get device extension */
1957     DeviceExtension = (PDEV_EXTENSION)DeviceObject->DeviceExtension;
1958
1959     /* get bus device extension */
1960     BusDeviceExtension = (PBUS_ENUM_DEVICE_EXTENSION)DeviceExtension->Ext;
1961
1962     /* get current irp stack location */
1963     IoStack = IoGetCurrentIrpStackLocation(Irp);
1964
1965     if (BusDeviceExtension->Common.IsBus)
1966     {
1967         if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
1968         {
1969             /* no op for bus driver */
1970             Status = STATUS_SUCCESS;
1971         }
1972         else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS)
1973         {
1974             /* handle bus device relations */
1975             ASSERT(IoStack->Parameters.QueryDeviceRelations.Type == BusRelations);
1976
1977             Status = KspQueryBusRelations(BusDeviceExtension, Irp);
1978         }
1979         else
1980         {
1981             /* get default status */
1982             Status = Irp->IoStatus.Status;
1983         }
1984     }
1985     else
1986     {
1987         /* get child device extension */
1988         ChildDeviceExtension = DeviceExtension->Ext;
1989
1990         /* get bus device extension */
1991         BusDeviceExtension = ChildDeviceExtension->BusDeviceExtension;
1992
1993         if (IoStack->MinorFunction == IRP_MN_QUERY_ID)
1994         {
1995             /* query id */
1996             Status = KspQueryId(ChildDeviceExtension, Irp);
1997         }
1998         else if (IoStack->MinorFunction == IRP_MN_REMOVE_DEVICE)
1999         {
2000             ASSERT(ChildDeviceExtension->DeviceEntry->DeviceState != Started || ChildDeviceExtension->DeviceEntry->DeviceState == NotStarted);
2001             ASSERT(ChildDeviceExtension->DeviceEntry->PDO == DeviceObject);
2002
2003             /* backup device entry */
2004             DeviceEntry = ChildDeviceExtension->DeviceEntry;
2005
2006             /* free device extension */
2007             FreeItem(ChildDeviceExtension);
2008
2009             /* clear PDO reference */
2010             DeviceEntry->PDO = NULL;
2011
2012             /* delete the device */
2013             IoDeleteDevice(DeviceObject);
2014
2015             if (DeviceEntry->PDODeviceName)
2016             {
2017                 /* delete pdo device name */
2018                 FreeItem(DeviceEntry->PDODeviceName);
2019
2020                 /* set to null */
2021                 DeviceEntry->PDODeviceName = NULL;
2022             }
2023
2024             /* set state no notstarted */
2025             DeviceEntry->DeviceState = NotStarted;
2026
2027         /* time to create PDO */
2028         KspCreatePDO(BusDeviceExtension, DeviceEntry, &DeviceEntry->PDO);
2029
2030         /* invalidate device relations */
2031         IoInvalidateDeviceRelations(BusDeviceExtension->PhysicalDeviceObject, BusRelations);
2032
2033             /* done */
2034             Status = STATUS_SUCCESS;
2035         }
2036         else if (IoStack->MinorFunction == IRP_MN_QUERY_BUS_INFORMATION)
2037         {
2038             /* query bus information */
2039             Status = KspQueryBusInformation(ChildDeviceExtension, Irp);
2040         }
2041         else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCES)
2042         {
2043             /* no op */
2044             Status = STATUS_SUCCESS;
2045         }
2046         else if (IoStack->MinorFunction == IRP_MN_QUERY_RESOURCE_REQUIREMENTS)
2047         {
2048             /* no op */
2049             Status = STATUS_SUCCESS;
2050         }
2051         else if (IoStack->MinorFunction == IRP_MN_START_DEVICE)
2052         {
2053             /* start bus */
2054             Status = KspStartBusDevice(DeviceObject, ChildDeviceExtension, Irp);
2055
2056             /* set time out */
2057             Time.QuadPart = Int32x32To64(1500, -10000);
2058
2059             /* sanity check */
2060             ASSERT(BusDeviceExtension);
2061
2062             /* set timer */
2063             KeSetTimer(&BusDeviceExtension->Timer, Time, &BusDeviceExtension->Dpc);
2064         }
2065         else if (IoStack->MinorFunction == IRP_MN_QUERY_CAPABILITIES)
2066         {
2067             /* query capabilities */
2068             Status = KspQueryBusDeviceCapabilities(ChildDeviceExtension, Irp);
2069         }
2070         else if (IoStack->MinorFunction == IRP_MN_QUERY_PNP_DEVICE_STATE)
2071         {
2072             /* query pnp state */
2073             Status = KspQueryBusDevicePnpState(ChildDeviceExtension, Irp);
2074         }
2075         else if (IoStack->MinorFunction == IRP_MN_QUERY_INTERFACE)
2076         {
2077             /* query interface */
2078             Status = KspQueryBusDeviceInterface(ChildDeviceExtension, Irp);
2079         }
2080         else if (IoStack->MinorFunction == IRP_MN_QUERY_DEVICE_RELATIONS && IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
2081         {
2082             /* handle target device relations */
2083             ASSERT(IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation);
2084             ASSERT(Irp->IoStatus.Information == 0);
2085
2086             /* allocate device relation */
2087             DeviceRelation = AllocateItem(PagedPool, sizeof(DEVICE_RELATIONS));
2088             if (DeviceRelation)
2089             {
2090                 DeviceRelation->Count = 1;
2091                 DeviceRelation->Objects[0] = DeviceObject;
2092
2093                 /* reference self */
2094                 ObReferenceObject(DeviceObject);
2095
2096                 /* store result */
2097                 Irp->IoStatus.Information = (ULONG_PTR)DeviceRelation;
2098
2099                 /* done */
2100                 Status = STATUS_SUCCESS;
2101             }
2102             else
2103             {
2104                 /* no memory */
2105                 Status = STATUS_INSUFFICIENT_RESOURCES;
2106             }
2107         }
2108         else
2109         {
2110             /* get default status */
2111             Status = Irp->IoStatus.Status;
2112         }
2113     }
2114
2115     DPRINT("KsServiceBusEnumPnpRequest %p Bus %u Function %x Status %x\n", DeviceObject, BusDeviceExtension->Common.IsBus, IoStack->MinorFunction, Status);
2116     Irp->IoStatus.Status = Status;
2117     return Status;
2118 }
2119
2120 /*
2121     @implemented
2122 */
2123 KSDDKAPI
2124 NTSTATUS
2125 NTAPI
2126 KsRemoveBusEnumInterface(
2127     IN PIRP Irp)
2128 {
2129     KPROCESSOR_MODE Mode;
2130     LUID luid;
2131     BUS_INSTALL_ENUM_CONTEXT Ctx;
2132     PDEV_EXTENSION DeviceExtension;
2133     PBUS_ENUM_DEVICE_EXTENSION BusDeviceExtension;
2134     PIO_STACK_LOCATION IoStack;
2135
2136     DPRINT1("KsRemoveBusEnumInterface\n");
2137
2138     /* get io stack location */
2139     IoStack = IoGetCurrentIrpStackLocation(Irp);
2140
2141     /* get device extension */
2142     DeviceExtension = (PDEV_EXTENSION)IoStack->DeviceObject->DeviceExtension;
2143
2144     /* get bus device extension */
2145     BusDeviceExtension = DeviceExtension->Ext->BusDeviceExtension;
2146
2147     /* get previous mode */
2148     Mode = ExGetPreviousMode();
2149
2150     /* convert to luid */
2151     luid = RtlConvertUlongToLuid(SE_LOAD_DRIVER_PRIVILEGE);
2152
2153     /* perform access check */
2154     if (!SeSinglePrivilegeCheck(luid, Mode))
2155     {
2156         /* insufficient privileges */
2157         return STATUS_PRIVILEGE_NOT_HELD;
2158     }
2159
2160     /* initialize context */
2161     KeInitializeEvent(&Ctx.Event, NotificationEvent, FALSE);
2162     Ctx.Irp = Irp;
2163     Ctx.BusDeviceExtension = BusDeviceExtension;
2164     ExInitializeWorkItem(&Ctx.WorkItem, KspRemoveBusInterface, (PVOID)&Ctx);
2165
2166     /* now queue the work item */
2167     ExQueueWorkItem(&Ctx.WorkItem, DelayedWorkQueue);
2168
2169     /* wait for completion */
2170     KeWaitForSingleObject(&Ctx.Event, Executive, KernelMode, FALSE, NULL);
2171
2172     /* return result */
2173     return Ctx.Status;
2174 }