reactos/ntoskrnl/io/iomgr/iorsrce.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS kernel
   4  * FILE:            ntoskrnl/io/iorsrce.c
   5  * PURPOSE:         Hardware resource managment
   6  *
   7  * PROGRAMMERS:     David Welch (welch@mcmail.com)
   8  *                  Alex Ionescu (alex@relsoft.net)
   9  *                  Pierre Schweitzer (pierre.schweitzer@reactos.org)
  10  */
  11
  12 /* INCLUDES *****************************************************************/
  13
  14 #include <ntoskrnl.h>
  15 #include <debug.h>
  16
  17 /* GLOBALS *******************************************************************/
  18
  19 static CONFIGURATION_INFORMATION
  20 _SystemConfigurationInformation = { 0, 0, 0, 0, 0, 0, 0, FALSE, FALSE, 0, 0 };
  21
  22 /* API Parameters to Pass in IopQueryBusDescription */
  23 typedef struct IO_QUERY {
  24     PINTERFACE_TYPE  BusType;
  25     PULONG  BusNumber;
  26     PCONFIGURATION_TYPE  ControllerType;
  27     PULONG  ControllerNumber;
  28     PCONFIGURATION_TYPE  PeripheralType;
  29     PULONG  PeripheralNumber;
  30     PIO_QUERY_DEVICE_ROUTINE  CalloutRoutine;
  31     PVOID  Context;
  32 } IO_QUERY, *PIO_QUERY;
  33
  34 PWSTR ArcTypes[42] = {
  35     L"System",
  36     L"CentralProcessor",
  37     L"FloatingPointProcessor",
  38     L"PrimaryICache",
  39     L"PrimaryDCache",
  40     L"SecondaryICache",
  41     L"SecondaryDCache",
  42     L"SecondaryCache",
  43     L"EisaAdapter",
  44     L"TcAdapter",
  45     L"ScsiAdapter",
  46     L"DtiAdapter",
  47     L"MultifunctionAdapter",
  48     L"DiskController",
  49     L"TapeController",
  50     L"CdRomController",
  51     L"WormController",
  52     L"SerialController",
  53     L"NetworkController",
  54     L"DisplayController",
  55     L"ParallelController",
  56     L"PointerController",
  57     L"KeyboardController",
  58     L"AudioController",
  59     L"OtherController",
  60     L"DiskPeripheral",
  61     L"FloppyDiskPeripheral",
  62     L"TapePeripheral",
  63     L"ModemPeripheral",
  64     L"MonitorPeripheral",
  65     L"PrinterPeripheral",
  66     L"PointerPeripheral",
  67     L"KeyboardPeripheral",
  68     L"TerminalPeripheral",
  69     L"OtherPeripheral",
  70     L"LinePeripheral",
  71     L"NetworkPeripheral",
  72     L"SystemMemory",
  73     L"DockingInformation",
  74     L"RealModeIrqRoutingTable",
  75     L"RealModePCIEnumeration",
  76     L"Undefined"
  77 };
  78
  79 /* PRIVATE FUNCTIONS **********************************************************/
  80
  81 /*
  82  * IopQueryDeviceDescription
  83  *
  84  * FUNCTION:
  85  *     Reads and returns Hardware information from the appropriate hardware
  86  *     registry key. Helper sub of IopQueryBusDescription.
  87  *
  88  * ARGUMENTS:
  89  *     Query          - What the parent function wants.
  90  *     RootKey        - Which key to look in
  91  *     RootKeyHandle  - Handle to the key
  92  *     Bus            - Bus Number.
  93  *     BusInformation - The Configuration Information Sent
  94  *
  95  * RETURNS:
  96  *      Status
  97  */
  98
  99 NTSTATUS NTAPI
 100 IopQueryDeviceDescription(
 101    PIO_QUERY Query,
 102    UNICODE_STRING RootKey,
 103    HANDLE RootKeyHandle,
 104    ULONG Bus,
 105    PKEY_VALUE_FULL_INFORMATION *BusInformation)
 106 {
 107    NTSTATUS Status = STATUS_SUCCESS;
 108
 109    /* Controller Stuff */
 110    UNICODE_STRING ControllerString;
 111    UNICODE_STRING ControllerRootRegName = RootKey;
 112    UNICODE_STRING ControllerRegName;
 113    HANDLE ControllerKeyHandle;
 114    PKEY_FULL_INFORMATION ControllerFullInformation = NULL;
 115    PKEY_VALUE_FULL_INFORMATION ControllerInformation[3] = {NULL, NULL, NULL};
 116    ULONG ControllerNumber;
 117    ULONG ControllerLoop;
 118    ULONG MaximumControllerNumber;
 119
 120    /* Peripheral Stuff */
 121    UNICODE_STRING PeripheralString;
 122    HANDLE PeripheralKeyHandle;
 123    PKEY_FULL_INFORMATION PeripheralFullInformation;
 124    PKEY_VALUE_FULL_INFORMATION PeripheralInformation[3] = {NULL, NULL, NULL};
 125    ULONG PeripheralNumber;
 126    ULONG PeripheralLoop;
 127    ULONG MaximumPeripheralNumber;
 128
 129    /* Global Registry Stuff */
 130    OBJECT_ATTRIBUTES ObjectAttributes;
 131    ULONG LenFullInformation;
 132    ULONG LenKeyFullInformation;
 133    UNICODE_STRING TempString;
 134    WCHAR TempBuffer[14];
 135    PWSTR Strings[3] = {
 136       L"Identifier",
 137       L"Configuration Data",
 138       L"Component Information"
 139    };
 140
 141    /* Temporary String */
 142    TempString.MaximumLength = sizeof(TempBuffer);
 143    TempString.Length = 0;
 144    TempString.Buffer = TempBuffer;
 145
 146    /* Add Controller Name to String */
 147    RtlAppendUnicodeToString(&ControllerRootRegName, L"\\");
 148    RtlAppendUnicodeToString(&ControllerRootRegName, ArcTypes[*Query->ControllerType]);
 149
 150    /* Set the Controller Number if specified */
 151    if (Query->ControllerNumber && *(Query->ControllerNumber))
 152    {
 153       ControllerNumber = *Query->ControllerNumber;
 154       MaximumControllerNumber = ControllerNumber + 1;
 155    } else {
 156       /* Find out how many Controller Numbers there are */
 157       InitializeObjectAttributes(
 158          &ObjectAttributes,
 159          &ControllerRootRegName,
 160          OBJ_CASE_INSENSITIVE,
 161          NULL,
 162          NULL);
 163
 164       Status = ZwOpenKey(&ControllerKeyHandle, KEY_READ, &ObjectAttributes);
 165       if (NT_SUCCESS(Status))
 166       {
 167          /* How much buffer space */
 168          ZwQueryKey(ControllerKeyHandle, KeyFullInformation, NULL, 0, &LenFullInformation);
 169
 170          /* Allocate it */
 171          ControllerFullInformation = ExAllocatePoolWithTag(PagedPool, LenFullInformation, TAG_IO_RESOURCE);
 172
 173          /* Get the Information */
 174          Status = ZwQueryKey(ControllerKeyHandle, KeyFullInformation, ControllerFullInformation, LenFullInformation, &LenFullInformation);
 175          ZwClose(ControllerKeyHandle);
 176          ControllerKeyHandle = NULL;
 177       }
 178
 179       /* No controller was found, go back to function. */
 180       if (!NT_SUCCESS(Status))
 181       {
 182          if (ControllerFullInformation != NULL)
 183             ExFreePoolWithTag(ControllerFullInformation, TAG_IO_RESOURCE);
 184          return Status;
 185       }
 186
 187       /* Find out Controller Numbers */
 188       ControllerNumber = 0;
 189       MaximumControllerNumber = ControllerFullInformation->SubKeys;
 190
 191       /* Free Memory */
 192       ExFreePoolWithTag(ControllerFullInformation, TAG_IO_RESOURCE);
 193       ControllerFullInformation = NULL;
 194    }
 195
 196    /* Save String */
 197    ControllerRegName = ControllerRootRegName;
 198
 199    /* Loop through controllers */
 200    for (; ControllerNumber < MaximumControllerNumber; ControllerNumber++)
 201    {
 202       /* Load String */
 203       ControllerRootRegName = ControllerRegName;
 204
 205       /* Controller Number to Registry String */
 206       Status = RtlIntegerToUnicodeString(ControllerNumber, 10, &TempString);
 207
 208       /* Create String */
 209       Status |= RtlAppendUnicodeToString(&ControllerRootRegName, L"\\");
 210       Status |= RtlAppendUnicodeStringToString(&ControllerRootRegName, &TempString);
 211
 212       /* Something messed up */
 213       if (!NT_SUCCESS(Status)) break;
 214
 215       /* Open the Registry Key */
 216       InitializeObjectAttributes(
 217          &ObjectAttributes,
 218          &ControllerRootRegName,
 219          OBJ_CASE_INSENSITIVE,
 220          NULL,
 221          NULL);
 222
 223       Status = ZwOpenKey(&ControllerKeyHandle, KEY_READ, &ObjectAttributes);
 224
 225       /* Read the Configuration Data... */
 226       if (NT_SUCCESS(Status))
 227       {
 228          for (ControllerLoop = 0; ControllerLoop < 3; ControllerLoop++)
 229          {
 230             /* Identifier String First */
 231             RtlInitUnicodeString(&ControllerString, Strings[ControllerLoop]);
 232
 233             /* How much buffer space */
 234             Status = ZwQueryValueKey(ControllerKeyHandle, &ControllerString, KeyValueFullInformation, NULL, 0, &LenKeyFullInformation);
 235
 236             if(!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL && Status != STATUS_BUFFER_OVERFLOW)
 237               continue;
 238
 239             /* Allocate it */
 240             ControllerInformation[ControllerLoop] = ExAllocatePoolWithTag(PagedPool, LenKeyFullInformation, TAG_IO_RESOURCE);
 241
 242             /* Get the Information */
 243             Status = ZwQueryValueKey(ControllerKeyHandle, &ControllerString, KeyValueFullInformation, ControllerInformation[ControllerLoop], LenKeyFullInformation, &LenKeyFullInformation);
 244          }
 245
 246          /* Clean Up */
 247          ZwClose(ControllerKeyHandle);
 248          ControllerKeyHandle = NULL;
 249       }
 250
 251       /* Something messed up */
 252       if (!NT_SUCCESS(Status))
 253          goto EndLoop;
 254
 255       /* We now have Bus *AND* Controller Information.. is it enough? */
 256       if (!Query->PeripheralType || !(*Query->PeripheralType))
 257       {
 258          Status = Query->CalloutRoutine(
 259             Query->Context,
 260             &ControllerRootRegName,
 261             *Query->BusType,
 262             Bus,
 263             BusInformation,
 264             *Query->ControllerType,
 265             ControllerNumber,
 266             ControllerInformation,
 267             0,
 268             0,
 269             NULL);
 270          goto EndLoop;
 271       }
 272
 273       /* Not enough...caller also wants peripheral name */
 274       Status = RtlAppendUnicodeToString(&ControllerRootRegName, L"\\");
 275       Status |= RtlAppendUnicodeToString(&ControllerRootRegName, ArcTypes[*Query->PeripheralType]);
 276
 277       /* Something messed up */
 278       if (!NT_SUCCESS(Status)) goto EndLoop;
 279
 280       /* Set the Peripheral Number if specified */
 281       if (Query->PeripheralNumber && *Query->PeripheralNumber)
 282       {
 283          PeripheralNumber = *Query->PeripheralNumber;
 284          MaximumPeripheralNumber = PeripheralNumber + 1;
 285       } else {
 286          /* Find out how many Peripheral Numbers there are */
 287          InitializeObjectAttributes(
 288             &ObjectAttributes,
 289             &ControllerRootRegName,
 290             OBJ_CASE_INSENSITIVE,
 291             NULL,
 292             NULL);
 293
 294          Status = ZwOpenKey(&PeripheralKeyHandle, KEY_READ, &ObjectAttributes);
 295
 296          if (NT_SUCCESS(Status))
 297          {
 298             /* How much buffer space */
 299             ZwQueryKey(PeripheralKeyHandle, KeyFullInformation, NULL, 0, &LenFullInformation);
 300
 301             /* Allocate it */
 302             PeripheralFullInformation = ExAllocatePoolWithTag(PagedPool, LenFullInformation, TAG_IO_RESOURCE);
 303
 304             /* Get the Information */
 305             Status = ZwQueryKey(PeripheralKeyHandle, KeyFullInformation, PeripheralFullInformation, LenFullInformation, &LenFullInformation);
 306             ZwClose(PeripheralKeyHandle);
 307             PeripheralKeyHandle = NULL;
 308          }
 309
 310          /* No controller was found, go back to function but clean up first */
 311          if (!NT_SUCCESS(Status))
 312          {
 313             Status = STATUS_SUCCESS;
 314             goto EndLoop;
 315          }
 316
 317          /* Find out Peripheral Number */
 318          PeripheralNumber = 0;
 319          MaximumPeripheralNumber = PeripheralFullInformation->SubKeys;
 320
 321          /* Free Memory */
 322          ExFreePoolWithTag(PeripheralFullInformation, TAG_IO_RESOURCE);
 323          PeripheralFullInformation = NULL;
 324       }
 325
 326       /* Save Name */
 327       ControllerRegName = ControllerRootRegName;
 328
 329       /* Loop through Peripherals */
 330       for (; PeripheralNumber < MaximumPeripheralNumber; PeripheralNumber++)
 331       {
 332          /* Restore Name */
 333          ControllerRootRegName = ControllerRegName;
 334
 335          /* Peripheral Number to Registry String */
 336          Status = RtlIntegerToUnicodeString(PeripheralNumber, 10, &TempString);
 337
 338          /* Create String */
 339          Status |= RtlAppendUnicodeToString(&ControllerRootRegName, L"\\");
 340          Status |= RtlAppendUnicodeStringToString(&ControllerRootRegName, &TempString);
 341
 342          /* Something messed up */
 343          if (!NT_SUCCESS(Status)) break;
 344
 345          /* Open the Registry Key */
 346          InitializeObjectAttributes(
 347             &ObjectAttributes,
 348             &ControllerRootRegName,
 349             OBJ_CASE_INSENSITIVE,
 350             NULL,
 351             NULL);
 352
 353          Status = ZwOpenKey(&PeripheralKeyHandle, KEY_READ, &ObjectAttributes);
 354
 355          if (NT_SUCCESS(Status))
 356          {
 357             for (PeripheralLoop = 0; PeripheralLoop < 3; PeripheralLoop++)
 358             {
 359                /* Identifier String First */
 360                RtlInitUnicodeString(&PeripheralString, Strings[PeripheralLoop]);
 361
 362                /* How much buffer space */
 363                Status = ZwQueryValueKey(PeripheralKeyHandle, &PeripheralString, KeyValueFullInformation, NULL, 0, &LenKeyFullInformation);
 364
 365                if(!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL && Status != STATUS_BUFFER_OVERFLOW)
 366                {
 367                  PeripheralInformation[PeripheralLoop] = NULL;
 368                  continue;
 369                }
 370
 371                /* Allocate it */
 372                PeripheralInformation[PeripheralLoop] = ExAllocatePoolWithTag(PagedPool, LenKeyFullInformation, TAG_IO_RESOURCE);
 373
 374                /* Get the Information */
 375                Status = ZwQueryValueKey(PeripheralKeyHandle, &PeripheralString, KeyValueFullInformation, PeripheralInformation[PeripheralLoop], LenKeyFullInformation, &LenKeyFullInformation);
 376             }
 377
 378             /* Clean Up */
 379             ZwClose(PeripheralKeyHandle);
 380             PeripheralKeyHandle = NULL;
 381
 382             /* We now have everything the caller could possibly want */
 383             if (NT_SUCCESS(Status))
 384             {
 385                Status = Query->CalloutRoutine(
 386                   Query->Context,
 387                   &ControllerRootRegName,
 388                   *Query->BusType,
 389                   Bus,
 390                   BusInformation,
 391                   *Query->ControllerType,
 392                   ControllerNumber,
 393                   ControllerInformation,
 394                   *Query->PeripheralType,
 395                   PeripheralNumber,
 396                   PeripheralInformation);
 397             }
 398
 399             /* Free the allocated memory */
 400             for (PeripheralLoop = 0; PeripheralLoop < 3; PeripheralLoop++)
 401             {
 402                if (PeripheralInformation[PeripheralLoop])
 403                {
 404                   ExFreePoolWithTag(PeripheralInformation[PeripheralLoop], TAG_IO_RESOURCE);
 405                   PeripheralInformation[PeripheralLoop] = NULL;
 406                }
 407             }
 408
 409             /* Something Messed up */
 410             if (!NT_SUCCESS(Status)) break;
 411          }
 412       }
 413
 414 EndLoop:
 415       /* Free the allocated memory */
 416       for (ControllerLoop = 0; ControllerLoop < 3; ControllerLoop++)
 417       {
 418          if (ControllerInformation[ControllerLoop])
 419          {
 420             ExFreePoolWithTag(ControllerInformation[ControllerLoop], TAG_IO_RESOURCE);
 421             ControllerInformation[ControllerLoop] = NULL;
 422          }
 423       }
 424
 425       /* Something Messed up */
 426       if (!NT_SUCCESS(Status)) break;
 427    }
 428
 429    return Status;
 430 }
 431
 432 /*
 433  * IopQueryBusDescription
 434  *
 435  * FUNCTION:
 436  *      Reads and returns Hardware information from the appropriate hardware
 437  *      registry key. Helper sub of IoQueryDeviceDescription. Has two modes
 438  *      of operation, either looking for Root Bus Types or for sub-Bus
 439  *      information.
 440  *
 441  * ARGUMENTS:
 442  *      Query         - What the parent function wants.
 443  *      RootKey       - Which key to look in
 444  *      RootKeyHandle - Handle to the key
 445  *      Bus           - Bus Number.
 446  *      KeyIsRoot     - Whether we are looking for Root Bus Types or
 447  *                      information under them.
 448  *
 449  * RETURNS:
 450  *      Status
 451  */
 452
 453 NTSTATUS NTAPI
 454 IopQueryBusDescription(
 455    PIO_QUERY Query,
 456    UNICODE_STRING RootKey,
 457    HANDLE RootKeyHandle,
 458    PULONG Bus,
 459    BOOLEAN KeyIsRoot)
 460 {
 461    NTSTATUS Status;
 462    ULONG BusLoop;
 463    UNICODE_STRING SubRootRegName;
 464    UNICODE_STRING BusString;
 465    UNICODE_STRING SubBusString;
 466    ULONG LenBasicInformation = 0;
 467    ULONG LenFullInformation;
 468    ULONG LenKeyFullInformation;
 469    ULONG LenKey;
 470    HANDLE SubRootKeyHandle;
 471    PKEY_FULL_INFORMATION FullInformation;
 472    PKEY_BASIC_INFORMATION BasicInformation = NULL;
 473    OBJECT_ATTRIBUTES ObjectAttributes;
 474    PKEY_VALUE_FULL_INFORMATION BusInformation[3] = {NULL, NULL, NULL};
 475
 476    /* How much buffer space */
 477    Status = ZwQueryKey(RootKeyHandle, KeyFullInformation, NULL, 0, &LenFullInformation);
 478
 479    if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_TOO_SMALL && Status != STATUS_BUFFER_OVERFLOW)
 480       return Status;
 481
 482    /* Allocate it */
 483    FullInformation = ExAllocatePoolWithTag(PagedPool, LenFullInformation, TAG_IO_RESOURCE);
 484
 485    if(!FullInformation)
 486      return STATUS_NO_MEMORY;
 487
 488    /* Get the Information */
 489    Status = ZwQueryKey(RootKeyHandle, KeyFullInformation, FullInformation, LenFullInformation, &LenFullInformation);
 490
 491    /* Everything was fine */
 492    if (NT_SUCCESS(Status))
 493    {
 494       /* Buffer needed for all the keys under this one */
 495       LenBasicInformation = FullInformation->MaxNameLen + sizeof(KEY_BASIC_INFORMATION);
 496
 497       /* Allocate it */
 498       BasicInformation = ExAllocatePoolWithTag(PagedPool, LenBasicInformation, TAG_IO_RESOURCE);
 499    }
 500
 501    /* Deallocate the old Buffer */
 502    ExFreePoolWithTag(FullInformation, TAG_IO_RESOURCE);
 503
 504    /* Try to find a Bus */
 505    for (BusLoop = 0; NT_SUCCESS(Status); BusLoop++)
 506    {
 507       /* Bus parameter was passed and number was matched */
 508       if ((Query->BusNumber) && (*(Query->BusNumber)) == *Bus) break;
 509
 510       /* Enumerate the Key */
 511       Status = ZwEnumerateKey(
 512          RootKeyHandle,
 513          BusLoop,
 514          KeyBasicInformation,
 515          BasicInformation,
 516          LenBasicInformation,
 517          &LenKey);
 518
 519       /* Everything enumerated */
 520       if (!NT_SUCCESS(Status)) break;
 521
 522       /* What Bus are we going to go down? (only check if this is a Root Key) */
 523       if (KeyIsRoot)
 524       {
 525          if (wcsncmp(BasicInformation->Name, L"MultifunctionAdapter", BasicInformation->NameLength / 2) &&
 526              wcsncmp(BasicInformation->Name, L"EisaAdapter", BasicInformation->NameLength / 2) &&
 527              wcsncmp(BasicInformation->Name, L"TcAdapter", BasicInformation->NameLength / 2))
 528          {
 529             /* Nothing found, check next */
 530             continue;
 531          }
 532       }
 533
 534       /* Enumerate the Bus. */
 535       BusString.Buffer = BasicInformation->Name;
 536       BusString.Length = (USHORT)BasicInformation->NameLength;
 537       BusString.MaximumLength = (USHORT)BasicInformation->NameLength;
 538
 539       /* Open a handle to the Root Registry Key */
 540       InitializeObjectAttributes(
 541          &ObjectAttributes,
 542          &BusString,
 543          OBJ_CASE_INSENSITIVE,
 544          RootKeyHandle,
 545          NULL);
 546
 547       Status = ZwOpenKey(&SubRootKeyHandle, KEY_READ, &ObjectAttributes);
 548
 549       /* Go on if we can't */
 550       if (!NT_SUCCESS(Status)) continue;
 551
 552       /* Key opened. Create the path */
 553       SubRootRegName = RootKey;
 554       RtlAppendUnicodeToString(&SubRootRegName, L"\\");
 555       RtlAppendUnicodeStringToString(&SubRootRegName, &BusString);
 556
 557       if (!KeyIsRoot)
 558       {
 559          /* Parsing a SubBus-key */
 560          int SubBusLoop;
 561          PWSTR Strings[3] = {
 562             L"Identifier",
 563             L"Configuration Data",
 564             L"Component Information"};
 565
 566          for (SubBusLoop = 0; SubBusLoop < 3; SubBusLoop++)
 567          {
 568             /* Identifier String First */
 569             RtlInitUnicodeString(&SubBusString, Strings[SubBusLoop]);
 570
 571             /* How much buffer space */
 572             ZwQueryValueKey(SubRootKeyHandle, &SubBusString, KeyValueFullInformation, NULL, 0, &LenKeyFullInformation);
 573
 574             /* Allocate it */
 575             BusInformation[SubBusLoop] = ExAllocatePoolWithTag(PagedPool, LenKeyFullInformation, TAG_IO_RESOURCE);
 576
 577             /* Get the Information */
 578             Status = ZwQueryValueKey(SubRootKeyHandle, &SubBusString, KeyValueFullInformation, BusInformation[SubBusLoop], LenKeyFullInformation, &LenKeyFullInformation);
 579          }
 580
 581          if (NT_SUCCESS(Status))
 582          {
 583             /* Do we have something */
 584             if (BusInformation[1] != NULL &&
 585                 BusInformation[1]->DataLength != 0 &&
 586                 /* Does it match what we want? */
 587                 (((PCM_FULL_RESOURCE_DESCRIPTOR)((ULONG_PTR)BusInformation[1] + BusInformation[1]->DataOffset))->InterfaceType == *(Query->BusType)))
 588             {
 589                /* Found a bus */
 590                (*Bus)++;
 591
 592                /* Is it the bus we wanted */
 593                if (Query->BusNumber == NULL || *(Query->BusNumber) == *Bus)
 594                {
 595                   /* If we don't want Controller Information, we're done... call the callback */
 596                   if (Query->ControllerType == NULL)
 597                   {
 598                      Status = Query->CalloutRoutine(
 599                         Query->Context,
 600                         &SubRootRegName,
 601                         *(Query->BusType),
 602                         *Bus,
 603                         BusInformation,
 604                         0,
 605                         0,
 606                         NULL,
 607                         0,
 608                         0,
 609                         NULL);
 610                   } else {
 611                      /* We want Controller Info...get it */
 612                      Status = IopQueryDeviceDescription(Query, SubRootRegName, RootKeyHandle, *Bus, (PKEY_VALUE_FULL_INFORMATION*)BusInformation);
 613                   }
 614                }
 615             }
 616          }
 617
 618          /* Free the allocated memory */
 619          for (SubBusLoop = 0; SubBusLoop < 3; SubBusLoop++)
 620          {
 621             if (BusInformation[SubBusLoop])
 622             {
 623                ExFreePoolWithTag(BusInformation[SubBusLoop], TAG_IO_RESOURCE);
 624                BusInformation[SubBusLoop] = NULL;
 625             }
 626          }
 627
 628          /* Exit the Loop if we found the bus */
 629          if (Query->BusNumber != NULL && *(Query->BusNumber) == *Bus)
 630          {
 631             ZwClose(SubRootKeyHandle);
 632             SubRootKeyHandle = NULL;
 633             continue;
 634          }
 635       }
 636
 637       /* Enumerate the buses below us recursively if we haven't found the bus yet */
 638       Status = IopQueryBusDescription(Query, SubRootRegName, SubRootKeyHandle, Bus, !KeyIsRoot);
 639
 640       /* Everything enumerated */
 641       if (Status == STATUS_NO_MORE_ENTRIES) Status = STATUS_SUCCESS;
 642
 643       ZwClose(SubRootKeyHandle);
 644       SubRootKeyHandle = NULL;
 645    }
 646
 647    /* Free the last remaining Allocated Memory */
 648    if (BasicInformation)
 649       ExFreePoolWithTag(BasicInformation, TAG_IO_RESOURCE);
 650
 651    return Status;
 652 }
 653
 654 NTSTATUS
 655 NTAPI
 656 IopFetchConfigurationInformation(OUT PWSTR * SymbolicLinkList,
 657                                  IN GUID Guid,
 658                                  IN ULONG ExpectedInterfaces,
 659                                  IN PULONG Interfaces)
 660 {
 661     NTSTATUS Status;
 662     ULONG IntInterfaces = 0;
 663     PWSTR IntSymbolicLinkList;
 664
 665     /* Get the associated enabled interfaces with the given GUID */
 666     Status = IoGetDeviceInterfaces(&Guid, NULL, 0, SymbolicLinkList);
 667     if (!NT_SUCCESS(Status))
 668     {
 669         /* Zero output and leave */
 670         if (SymbolicLinkList != 0)
 671         {
 672             *SymbolicLinkList = 0;
 673         }
 674
 675         return STATUS_UNSUCCESSFUL;
 676     }
 677
 678     IntSymbolicLinkList = *SymbolicLinkList;
 679
 680     /* Count the number of enabled interfaces by counting the number of symbolic links */
 681     while (*IntSymbolicLinkList != UNICODE_NULL)
 682     {
 683         IntInterfaces++;
 684         IntSymbolicLinkList += wcslen(IntSymbolicLinkList) + (sizeof(UNICODE_NULL) / sizeof(WCHAR));
 685     }
 686
 687     /* Matching result will define the result */
 688     Status = (IntInterfaces >= ExpectedInterfaces) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
 689     /* Finally, give back to the caller the number of found interfaces */
 690     *Interfaces = IntInterfaces;
 691
 692     return Status;
 693 }
 694
 695 VOID
 696 NTAPI
 697 IopStoreSystemPartitionInformation(IN PUNICODE_STRING NtSystemPartitionDeviceName,
 698                                    IN PUNICODE_STRING OsLoaderPathName)
 699 {
 700     NTSTATUS Status;
 701     UNICODE_STRING LinkTarget, KeyName;
 702     OBJECT_ATTRIBUTES ObjectAttributes;
 703     HANDLE LinkHandle, RegistryHandle, KeyHandle;
 704     WCHAR LinkTargetBuffer[256], KeyNameBuffer[sizeof(L"SystemPartition") / sizeof(WCHAR)];
 705     UNICODE_STRING CmRegistryMachineSystemName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM");
 706
 707     ASSERT(NtSystemPartitionDeviceName->MaximumLength >= NtSystemPartitionDeviceName->Length + sizeof(WCHAR));
 708     ASSERT(NtSystemPartitionDeviceName->Buffer[NtSystemPartitionDeviceName->Length / sizeof(WCHAR)] == UNICODE_NULL);
 709     ASSERT(OsLoaderPathName->MaximumLength >= OsLoaderPathName->Length + sizeof(WCHAR));
 710     ASSERT(OsLoaderPathName->Buffer[OsLoaderPathName->Length / sizeof(WCHAR)] == UNICODE_NULL);
 711
 712     /* First define needed stuff to open NtSystemPartitionDeviceName symbolic link */
 713     InitializeObjectAttributes(&ObjectAttributes,
 714                                NtSystemPartitionDeviceName,
 715                                OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
 716                                NULL,
 717                                NULL);
 718
 719     /* Open NtSystemPartitionDeviceName symbolic link */
 720     Status = ZwOpenSymbolicLinkObject(&LinkHandle,
 721                                       SYMBOLIC_LINK_QUERY,
 722                                       &ObjectAttributes);
 723     if (!NT_SUCCESS(Status))
 724     {
 725         DPRINT("Failed opening given symbolic link!\n");
 726         return;
 727     }
 728
 729     /* Prepare the string that will receive where symbolic link points to */
 730     LinkTarget.Length = 0;
 731     /* We will zero the end of the string after having received it */
 732     LinkTarget.MaximumLength = sizeof(LinkTargetBuffer) - sizeof(UNICODE_NULL);
 733     LinkTarget.Buffer = LinkTargetBuffer;
 734
 735     /* Query target */
 736     Status = ZwQuerySymbolicLinkObject(LinkHandle,
 737                                        &LinkTarget,
 738                                        NULL);
 739
 740     /* We are done with symbolic link */
 741     ObCloseHandle(LinkHandle, KernelMode);
 742
 743     if (!NT_SUCCESS(Status))
 744     {
 745         DPRINT("Failed querying given symbolic link!\n");
 746         return;
 747     }
 748
 749     /* As promised, we zero the end */
 750     LinkTarget.Buffer[LinkTarget.Length / sizeof(WCHAR)] = UNICODE_NULL;
 751
 752     /* Open registry to save data (HKLM\SYSTEM) */
 753     Status = IopOpenRegistryKeyEx(&RegistryHandle,
 754                                   NULL,
 755                                   &CmRegistryMachineSystemName,
 756                                   KEY_ALL_ACCESS);
 757     if (!NT_SUCCESS(Status))
 758     {
 759         DPRINT("Failed opening registry!\n");
 760         return;
 761     }
 762
 763     /* We'll store in Setup subkey, and as we love fun, we use only one buffer for three writings... */
 764     wcscpy(KeyNameBuffer, L"Setup");
 765     KeyName.Length = sizeof(L"Setup") - sizeof(UNICODE_NULL);
 766     KeyName.MaximumLength = sizeof(L"Setup");
 767     KeyName.Buffer = KeyNameBuffer;
 768
 769     /* So, open or create the subkey */
 770     Status = IopCreateRegistryKeyEx(&KeyHandle,
 771                                     RegistryHandle,
 772                                     &KeyName,
 773                                     KEY_ALL_ACCESS,
 774                                     REG_OPTION_NON_VOLATILE,
 775                                     NULL);
 776
 777     /* We're done with HKLM\SYSTEM */
 778     ObCloseHandle(RegistryHandle, KernelMode);
 779
 780     if (!NT_SUCCESS(Status))
 781     {
 782         DPRINT("Failed opening/creating Setup key!\n");
 783         return;
 784     }
 785
 786     /* Prepare first data writing... */
 787     wcscpy(KeyNameBuffer, L"SystemPartition");
 788     KeyName.Length = sizeof(L"SystemPartition") - sizeof(UNICODE_NULL);
 789     KeyName.MaximumLength = sizeof(L"SystemPartition");
 790
 791     /* Write SystemPartition value which is the target of the symbolic link */
 792     Status = ZwSetValueKey(KeyHandle,
 793                            &KeyName,
 794                            0,
 795                            REG_SZ,
 796                            LinkTarget.Buffer,
 797                            LinkTarget.Length + sizeof(WCHAR));
 798     if (!NT_SUCCESS(Status))
 799     {
 800         DPRINT("Failed writing SystemPartition value!\n");
 801     }
 802
 803     /* Prepare for second data writing... */
 804     wcscpy(KeyName.Buffer, L"OsLoaderPath");
 805     KeyName.Length = sizeof(L"OsLoaderPath") - sizeof(UNICODE_NULL);
 806     KeyName.MaximumLength = sizeof(L"OsLoaderPath");
 807
 808     /* Remove trailing slash if any (one slash only excepted) */
 809     if (OsLoaderPathName->Length > sizeof(WCHAR) &&
 810         OsLoaderPathName->Buffer[(OsLoaderPathName->Length / sizeof(WCHAR)) - 1] == OBJ_NAME_PATH_SEPARATOR)
 811     {
 812         OsLoaderPathName->Length -= sizeof(WCHAR);
 813         OsLoaderPathName->Buffer[OsLoaderPathName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 814     }
 815
 816     /* Then, write down data */
 817     Status = ZwSetValueKey(KeyHandle,
 818                            &KeyName,
 819                            0,
 820                            REG_SZ,
 821                            OsLoaderPathName->Buffer,
 822                            OsLoaderPathName->Length + sizeof(WCHAR));
 823     if (!NT_SUCCESS(Status))
 824     {
 825         DPRINT("Failed writing OsLoaderPath value!\n");
 826     }
 827
 828     /* We're finally done! */
 829     ObCloseHandle(KeyHandle, KernelMode);
 830 }
 831
 832 /* PUBLIC FUNCTIONS ***********************************************************/
 833
 834 /*
 835  * @implemented
 836  */
 837 PCONFIGURATION_INFORMATION NTAPI
 838 IoGetConfigurationInformation(VOID)
 839 {
 840   return(&_SystemConfigurationInformation);
 841 }
 842
 843 /*
 844  * @halfplemented
 845  */
 846 NTSTATUS NTAPI
 847 IoReportResourceUsage(PUNICODE_STRING DriverClassName,
 848                       PDRIVER_OBJECT DriverObject,
 849                       PCM_RESOURCE_LIST DriverList,
 850                       ULONG DriverListSize,
 851                       PDEVICE_OBJECT DeviceObject,
 852                       PCM_RESOURCE_LIST DeviceList,
 853                       ULONG DeviceListSize,
 854                       BOOLEAN OverrideConflict,
 855                       PBOOLEAN ConflictDetected)
 856      /*
 857       * FUNCTION: Reports hardware resources in the
 858       * \Registry\Machine\Hardware\ResourceMap tree, so that a subsequently
 859       * loaded driver cannot attempt to use the same resources.
 860       * ARGUMENTS:
 861       *       DriverClassName - The class of driver under which the resource
 862       *       information should be stored.
 863       *       DriverObject - The driver object that was input to the
 864       *       DriverEntry.
 865       *       DriverList - Resources that claimed for the driver rather than
 866       *       per-device.
 867       *       DriverListSize - Size in bytes of the DriverList.
 868       *       DeviceObject - The device object for which resources should be
 869       *       claimed.
 870       *       DeviceList - List of resources which should be claimed for the
 871       *       device.
 872       *       DeviceListSize - Size of the per-device resource list in bytes.
 873       *       OverrideConflict - True if the resources should be cliamed
 874       *       even if a conflict is found.
 875       *       ConflictDetected - Points to a variable that receives TRUE if
 876       *       a conflict is detected with another driver.
 877       */
 878 {
 879     NTSTATUS Status;
 880     PCM_RESOURCE_LIST ResourceList;
 881
 882     DPRINT1("IoReportResourceUsage is halfplemented!\n");
 883
 884     if (!DriverList && !DeviceList)
 885         return STATUS_INVALID_PARAMETER;
 886
 887     if (DeviceList)
 888         ResourceList = DeviceList;
 889     else
 890         ResourceList = DriverList;
 891
 892     Status = IopDetectResourceConflict(ResourceList, FALSE, NULL);
 893     if (Status == STATUS_CONFLICTING_ADDRESSES)
 894     {
 895         *ConflictDetected = TRUE;
 896
 897         if (!OverrideConflict)
 898         {
 899             DPRINT1("Denying an attempt to claim resources currently in use by another device!\n");
 900             return STATUS_CONFLICTING_ADDRESSES;
 901         }
 902         else
 903         {
 904             DPRINT1("Proceeding with conflicting resources\n");
 905         }
 906     }
 907     else if (!NT_SUCCESS(Status))
 908     {
 909         return Status;
 910     }
 911
 912     /* TODO: Claim resources in registry */
 913
 914     *ConflictDetected = FALSE;
 915
 916     return STATUS_SUCCESS;
 917 }
 918
 919 /*
 920  * @halfplemented
 921  */
 922 NTSTATUS NTAPI
 923 IoAssignResources(PUNICODE_STRING RegistryPath,
 924                   PUNICODE_STRING DriverClassName,
 925                   PDRIVER_OBJECT DriverObject,
 926                   PDEVICE_OBJECT DeviceObject,
 927                   PIO_RESOURCE_REQUIREMENTS_LIST RequestedResources,
 928                   PCM_RESOURCE_LIST* AllocatedResources)
 929 {
 930     NTSTATUS Status;
 931
 932     DPRINT1("IoAssignResources is halfplemented!\n");
 933
 934     *AllocatedResources = NULL;
 935     Status = IopFixupResourceListWithRequirements(RequestedResources,
 936                                                   AllocatedResources);
 937     if (!NT_SUCCESS(Status))
 938     {
 939         if (Status == STATUS_CONFLICTING_ADDRESSES)
 940             DPRINT1("Denying an attempt to claim resources currently in use by another device!\n");
 941
 942         return Status;
 943     }
 944
 945     /* TODO: Claim resources in registry */
 946
 947     return STATUS_SUCCESS;
 948 }
 949
 950 /*
 951  * FUNCTION:
 952  *     Reads and returns Hardware information from the appropriate hardware registry key.
 953  *
 954  * ARGUMENTS:
 955  *     BusType          - MCA, ISA, EISA...specifies the Bus Type
 956  *     BusNumber        - Which bus of above should be queried
 957  *     ControllerType   - Specifices the Controller Type
 958  *     ControllerNumber - Which of the controllers to query.
 959  *     CalloutRoutine   - Which function to call for each valid query.
 960  *     Context          - Value to pass to the callback.
 961  *
 962  * RETURNS:
 963  *     Status
 964  *
 965  * STATUS:
 966  *     @implemented
 967  */
 968
 969 NTSTATUS NTAPI
 970 IoQueryDeviceDescription(PINTERFACE_TYPE BusType OPTIONAL,
 971                          PULONG BusNumber OPTIONAL,
 972                          PCONFIGURATION_TYPE ControllerType OPTIONAL,
 973                          PULONG ControllerNumber OPTIONAL,
 974                          PCONFIGURATION_TYPE PeripheralType OPTIONAL,
 975                          PULONG PeripheralNumber OPTIONAL,
 976                          PIO_QUERY_DEVICE_ROUTINE CalloutRoutine,
 977                          PVOID Context)
 978 {
 979    NTSTATUS Status;
 980    ULONG BusLoopNumber = -1; /* Root Bus */
 981    OBJECT_ATTRIBUTES ObjectAttributes;
 982    UNICODE_STRING RootRegKey;
 983    HANDLE RootRegHandle;
 984    IO_QUERY Query;
 985
 986    /* Set up the String */
 987    RootRegKey.Length = 0;
 988    RootRegKey.MaximumLength = 2048;
 989    RootRegKey.Buffer = ExAllocatePoolWithTag(PagedPool, RootRegKey.MaximumLength, TAG_IO_RESOURCE);
 990    RtlAppendUnicodeToString(&RootRegKey, L"\\REGISTRY\\MACHINE\\HARDWARE\\DESCRIPTION\\SYSTEM");
 991
 992    /* Open a handle to the Root Registry Key */
 993    InitializeObjectAttributes(
 994       &ObjectAttributes,
 995       &RootRegKey,
 996       OBJ_CASE_INSENSITIVE,
 997       NULL,
 998       NULL);
 999
1000    Status = ZwOpenKey(&RootRegHandle, KEY_READ, &ObjectAttributes);
1001
1002    if (NT_SUCCESS(Status))
1003    {
1004       /* Use a helper function to loop though this key and get the info */
1005       Query.BusType = BusType;
1006       Query.BusNumber = BusNumber;
1007       Query.ControllerType = ControllerType;
1008       Query.ControllerNumber = ControllerNumber;
1009       Query.PeripheralType = PeripheralType;
1010       Query.PeripheralNumber = PeripheralNumber;
1011       Query.CalloutRoutine = CalloutRoutine;
1012       Query.Context = Context;
1013       Status = IopQueryBusDescription(&Query, RootRegKey, RootRegHandle, &BusLoopNumber, TRUE);
1014
1015       /* Close registry */
1016       ZwClose(RootRegHandle);
1017    }
1018
1019    /* Free Memory */
1020    ExFreePoolWithTag(RootRegKey.Buffer, TAG_IO_RESOURCE);
1021
1022    return Status;
1023 }
1024
1025 /*
1026  * @implemented
1027  */
1028 NTSTATUS NTAPI
1029 IoReportHalResourceUsage(PUNICODE_STRING HalDescription,
1030                          PCM_RESOURCE_LIST RawList,
1031                          PCM_RESOURCE_LIST TranslatedList,
1032                          ULONG ListSize)
1033 /*
1034  * FUNCTION:
1035  *      Reports hardware resources of the HAL in the
1036  *      \Registry\Machine\Hardware\ResourceMap tree.
1037  * ARGUMENTS:
1038  *      HalDescription: Descriptive name of the HAL.
1039  *      RawList: List of raw (bus specific) resources which should be
1040  *               claimed for the HAL.
1041  *      TranslatedList: List of translated (system wide) resources which
1042  *                      should be claimed for the HAL.
1043  *      ListSize: Size in bytes of the raw and translated resource lists.
1044  *                Both lists have the same size.
1045  * RETURNS:
1046  *      Status.
1047  */
1048 {
1049   OBJECT_ATTRIBUTES ObjectAttributes;
1050   UNICODE_STRING Name;
1051   ULONG Disposition;
1052   NTSTATUS Status;
1053   HANDLE ResourcemapKey;
1054   HANDLE HalKey;
1055   HANDLE DescriptionKey;
1056
1057   /* Open/Create 'RESOURCEMAP' key. */
1058   RtlInitUnicodeString(&Name,
1059                        L"\\Registry\\Machine\\HARDWARE\\RESOURCEMAP");
1060   InitializeObjectAttributes(&ObjectAttributes,
1061                              &Name,
1062                              OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
1063                              0,
1064                              NULL);
1065   Status = ZwCreateKey(&ResourcemapKey,
1066                        KEY_ALL_ACCESS,
1067                        &ObjectAttributes,
1068                        0,
1069                        NULL,
1070                        REG_OPTION_VOLATILE,
1071                        &Disposition);
1072   if (!NT_SUCCESS(Status))
1073     return(Status);
1074
1075   /* Open/Create 'Hardware Abstraction Layer' key */
1076   RtlInitUnicodeString(&Name,
1077                        L"Hardware Abstraction Layer");
1078   InitializeObjectAttributes(&ObjectAttributes,
1079                              &Name,
1080                              OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
1081                              ResourcemapKey,
1082                              NULL);
1083   Status = ZwCreateKey(&HalKey,
1084                        KEY_ALL_ACCESS,
1085                        &ObjectAttributes,
1086                        0,
1087                        NULL,
1088                        REG_OPTION_VOLATILE,
1089                        &Disposition);
1090   ZwClose(ResourcemapKey);
1091   if (!NT_SUCCESS(Status))
1092       return(Status);
1093
1094   /* Create 'HalDescription' key */
1095   InitializeObjectAttributes(&ObjectAttributes,
1096                              HalDescription,
1097                              OBJ_CASE_INSENSITIVE,
1098                              HalKey,
1099                              NULL);
1100   Status = ZwCreateKey(&DescriptionKey,
1101                        KEY_ALL_ACCESS,
1102                        &ObjectAttributes,
1103                        0,
1104                        NULL,
1105                        REG_OPTION_VOLATILE,
1106                        &Disposition);
1107   ZwClose(HalKey);
1108   if (!NT_SUCCESS(Status))
1109     return(Status);
1110
1111   /* Add '.Raw' value. */
1112   RtlInitUnicodeString(&Name,
1113                        L".Raw");
1114   Status = ZwSetValueKey(DescriptionKey,
1115                          &Name,
1116                          0,
1117                          REG_RESOURCE_LIST,
1118                          RawList,
1119                          ListSize);
1120   if (!NT_SUCCESS(Status))
1121     {
1122       ZwClose(DescriptionKey);
1123       return(Status);
1124     }
1125
1126   /* Add '.Translated' value. */
1127   RtlInitUnicodeString(&Name,
1128                        L".Translated");
1129   Status = ZwSetValueKey(DescriptionKey,
1130                          &Name,
1131                          0,
1132                          REG_RESOURCE_LIST,
1133                          TranslatedList,
1134                          ListSize);
1135   ZwClose(DescriptionKey);
1136
1137   return(Status);
1138 }
1139
1140 /* EOF */