OvmfPkg/Library/PlatformBdsLib/QemuBootOrder.c

   1 /** @file
   2   Rewrite the BootOrder NvVar based on QEMU's "bootorder" fw_cfg file.
   3
   4   Copyright (C) 2012 - 2013, Red Hat, Inc.
   5   Copyright (c) 2013, Intel Corporation. All rights reserved.<BR>
   6
   7   This program and the accompanying materials are licensed and made available
   8   under the terms and conditions of the BSD License which accompanies this
   9   distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
  13   WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14 **/
  15
  16 #include <Library/QemuFwCfgLib.h>
  17 #include <Library/DebugLib.h>
  18 #include <Library/MemoryAllocationLib.h>
  19 #include <Library/GenericBdsLib.h>
  20 #include <Library/UefiBootServicesTableLib.h>
  21 #include <Library/UefiRuntimeServicesTableLib.h>
  22 #include <Library/BaseLib.h>
  23 #include <Library/PrintLib.h>
  24 #include <Library/DevicePathLib.h>
  25 #include <Guid/GlobalVariable.h>
  26
  27
  28 /**
  29   OpenFirmware to UEFI device path translation output buffer size in CHAR16's.
  30 **/
  31 #define TRANSLATION_OUTPUT_SIZE 0x100
  32
  33
  34 /**
  35   Numbers of nodes in OpenFirmware device paths that are required and examined.
  36 **/
  37 #define REQUIRED_OFW_NODES 2
  38 #define EXAMINED_OFW_NODES 4
  39
  40
  41 /**
  42   Simple character classification routines, corresponding to POSIX class names
  43   and ASCII encoding.
  44 **/
  45 STATIC
  46 BOOLEAN
  47 IsAlnum (
  48   IN  CHAR8 Chr
  49   )
  50 {
  51   return (('0' <= Chr && Chr <= '9') ||
  52           ('A' <= Chr && Chr <= 'Z') ||
  53           ('a' <= Chr && Chr <= 'z')
  54           );
  55 }
  56
  57
  58 STATIC
  59 BOOLEAN
  60 IsDriverNamePunct (
  61   IN  CHAR8 Chr
  62   )
  63 {
  64   return (Chr == ',' ||  Chr == '.' || Chr == '_' ||
  65           Chr == '+' || Chr == '-'
  66           );
  67 }
  68
  69
  70 STATIC
  71 BOOLEAN
  72 IsPrintNotDelim (
  73   IN  CHAR8 Chr
  74   )
  75 {
  76   return (32 <= Chr && Chr <= 126 &&
  77           Chr != '/' && Chr != '@' && Chr != ':');
  78 }
  79
  80
  81 /**
  82   Utility types and functions.
  83 **/
  84 typedef struct {
  85   CONST CHAR8 *Ptr; // not necessarily NUL-terminated
  86   UINTN       Len;  // number of non-NUL characters
  87 } SUBSTRING;
  88
  89
  90 /**
  91
  92   Check if Substring and String have identical contents.
  93
  94   The function relies on the restriction that a SUBSTRING cannot have embedded
  95   NULs either.
  96
  97   @param[in] Substring  The SUBSTRING input to the comparison.
  98
  99   @param[in] String     The ASCII string input to the comparison.
 100
 101
 102   @return  Whether the inputs have identical contents.
 103
 104 **/
 105 STATIC
 106 BOOLEAN
 107 SubstringEq (
 108   IN  SUBSTRING   Substring,
 109   IN  CONST CHAR8 *String
 110   )
 111 {
 112   UINTN       Pos;
 113   CONST CHAR8 *Chr;
 114
 115   Pos = 0;
 116   Chr = String;
 117
 118   while (Pos < Substring.Len && Substring.Ptr[Pos] == *Chr) {
 119     ++Pos;
 120     ++Chr;
 121   }
 122
 123   return (BOOLEAN)(Pos == Substring.Len && *Chr == '\0');
 124 }
 125
 126
 127 /**
 128
 129   Parse a comma-separated list of hexadecimal integers into the elements of an
 130   UINT32 array.
 131
 132   Whitespace, "0x" prefixes, leading or trailing commas, sequences of commas,
 133   or an empty string are not allowed; they are rejected.
 134
 135   The function relies on ASCII encoding.
 136
 137   @param[in]     UnitAddress  The substring to parse.
 138
 139   @param[out]    Result       The array, allocated by the caller, to receive
 140                               the parsed values. This parameter may be NULL if
 141                               NumResults is zero on input.
 142
 143   @param[in out] NumResults   On input, the number of elements allocated for
 144                               Result. On output, the number of elements it has
 145                               taken (or would have taken) to parse the string
 146                               fully.
 147
 148
 149   @retval RETURN_SUCCESS            UnitAddress has been fully parsed.
 150                                     NumResults is set to the number of parsed
 151                                     values; the corresponding elements have
 152                                     been set in Result. The rest of Result's
 153                                     elements are unchanged.
 154
 155   @retval RETURN_BUFFER_TOO_SMALL   UnitAddress has been fully parsed.
 156                                     NumResults is set to the number of parsed
 157                                     values, but elements have been stored only
 158                                     up to the input value of NumResults, which
 159                                     is less than what has been parsed.
 160
 161   @retval RETURN_INVALID_PARAMETER  Parse error. The contents of Results is
 162                                     indeterminate. NumResults has not been
 163                                     changed.
 164
 165 **/
 166 STATIC
 167 RETURN_STATUS
 168 ParseUnitAddressHexList (
 169   IN      SUBSTRING  UnitAddress,
 170   OUT     UINT32     *Result,
 171   IN OUT  UINTN      *NumResults
 172   )
 173 {
 174   UINTN         Entry;    // number of entry currently being parsed
 175   UINT32        EntryVal; // value being constructed for current entry
 176   CHAR8         PrevChr;  // UnitAddress character previously checked
 177   UINTN         Pos;      // current position within UnitAddress
 178   RETURN_STATUS Status;
 179
 180   Entry    = 0;
 181   EntryVal = 0;
 182   PrevChr  = ',';
 183
 184   for (Pos = 0; Pos < UnitAddress.Len; ++Pos) {
 185     CHAR8 Chr;
 186     INT8  Val;
 187
 188     Chr = UnitAddress.Ptr[Pos];
 189     Val = ('a' <= Chr && Chr <= 'f') ? (Chr - 'a' + 10) :
 190           ('A' <= Chr && Chr <= 'F') ? (Chr - 'A' + 10) :
 191           ('0' <= Chr && Chr <= '9') ? (Chr - '0'     ) :
 192           -1;
 193
 194     if (Val >= 0) {
 195       if (EntryVal > 0xFFFFFFF) {
 196         return RETURN_INVALID_PARAMETER;
 197       }
 198       EntryVal = (EntryVal << 4) | Val;
 199     } else if (Chr == ',') {
 200       if (PrevChr == ',') {
 201         return RETURN_INVALID_PARAMETER;
 202       }
 203       if (Entry < *NumResults) {
 204         Result[Entry] = EntryVal;
 205       }
 206       ++Entry;
 207       EntryVal = 0;
 208     } else {
 209       return RETURN_INVALID_PARAMETER;
 210     }
 211
 212     PrevChr = Chr;
 213   }
 214
 215   if (PrevChr == ',') {
 216     return RETURN_INVALID_PARAMETER;
 217   }
 218   if (Entry < *NumResults) {
 219     Result[Entry] = EntryVal;
 220     Status = RETURN_SUCCESS;
 221   } else {
 222     Status = RETURN_BUFFER_TOO_SMALL;
 223   }
 224   ++Entry;
 225
 226   *NumResults = Entry;
 227   return Status;
 228 }
 229
 230
 231 /**
 232   A simple array of Boot Option ID's.
 233 **/
 234 typedef struct {
 235   UINT16 *Data;
 236   UINTN  Allocated;
 237   UINTN  Produced;
 238 } BOOT_ORDER;
 239
 240
 241 /**
 242   Array element tracking an enumerated boot option that has the
 243   LOAD_OPTION_ACTIVE attribute.
 244 **/
 245 typedef struct {
 246   CONST BDS_COMMON_OPTION *BootOption; // reference only, no ownership
 247   BOOLEAN                 Appended;    // has been added to a BOOT_ORDER?
 248 } ACTIVE_OPTION;
 249
 250
 251 /**
 252
 253   Append an active boot option to BootOrder, reallocating the latter if needed.
 254
 255   @param[in out] BootOrder     The structure pointing to the array and holding
 256                                allocation and usage counters.
 257
 258   @param[in]     ActiveOption  The active boot option whose ID should be
 259                                appended to the array.
 260
 261
 262   @retval RETURN_SUCCESS           ID of ActiveOption appended.
 263
 264   @retval RETURN_OUT_OF_RESOURCES  Memory reallocation failed.
 265
 266 **/
 267 STATIC
 268 RETURN_STATUS
 269 BootOrderAppend (
 270   IN OUT  BOOT_ORDER    *BootOrder,
 271   IN OUT  ACTIVE_OPTION *ActiveOption
 272   )
 273 {
 274   if (BootOrder->Produced == BootOrder->Allocated) {
 275     UINTN  AllocatedNew;
 276     UINT16 *DataNew;
 277
 278     ASSERT (BootOrder->Allocated > 0);
 279     AllocatedNew = BootOrder->Allocated * 2;
 280     DataNew = ReallocatePool (
 281                 BootOrder->Allocated * sizeof (*BootOrder->Data),
 282                 AllocatedNew         * sizeof (*DataNew),
 283                 BootOrder->Data
 284                 );
 285     if (DataNew == NULL) {
 286       return RETURN_OUT_OF_RESOURCES;
 287     }
 288     BootOrder->Allocated = AllocatedNew;
 289     BootOrder->Data      = DataNew;
 290   }
 291
 292   BootOrder->Data[BootOrder->Produced++] =
 293                                          ActiveOption->BootOption->BootCurrent;
 294   ActiveOption->Appended = TRUE;
 295   return RETURN_SUCCESS;
 296 }
 297
 298
 299 /**
 300
 301   Create an array of ACTIVE_OPTION elements for a boot option list.
 302
 303   @param[in]  BootOptionList  A boot option list, created with
 304                               BdsLibEnumerateAllBootOption().
 305
 306   @param[out] ActiveOption    Pointer to the first element in the new array.
 307                               The caller is responsible for freeing the array
 308                               with FreePool() after use.
 309
 310   @param[out] Count           Number of elements in the new array.
 311
 312
 313   @retval RETURN_SUCCESS           The ActiveOption array has been created.
 314
 315   @retval RETURN_NOT_FOUND         No active entry has been found in
 316                                    BootOptionList.
 317
 318   @retval RETURN_OUT_OF_RESOURCES  Memory allocation failed.
 319
 320 **/
 321 STATIC
 322 RETURN_STATUS
 323 CollectActiveOptions (
 324   IN   CONST LIST_ENTRY *BootOptionList,
 325   OUT  ACTIVE_OPTION    **ActiveOption,
 326   OUT  UINTN            *Count
 327   )
 328 {
 329   UINTN ScanMode;
 330
 331   *ActiveOption = NULL;
 332
 333   //
 334   // Scan the list twice:
 335   // - count active entries,
 336   // - store links to active entries.
 337   //
 338   for (ScanMode = 0; ScanMode < 2; ++ScanMode) {
 339     CONST LIST_ENTRY *Link;
 340
 341     Link = BootOptionList->ForwardLink;
 342     *Count = 0;
 343     while (Link != BootOptionList) {
 344       CONST BDS_COMMON_OPTION *Current;
 345
 346       Current = CR (Link, BDS_COMMON_OPTION, Link, BDS_LOAD_OPTION_SIGNATURE);
 347       if (IS_LOAD_OPTION_TYPE (Current->Attribute, LOAD_OPTION_ACTIVE)) {
 348         if (ScanMode == 1) {
 349           (*ActiveOption)[*Count].BootOption = Current;
 350           (*ActiveOption)[*Count].Appended   = FALSE;
 351         }
 352         ++*Count;
 353       }
 354       Link = Link->ForwardLink;
 355     }
 356
 357     if (ScanMode == 0) {
 358       if (*Count == 0) {
 359         return RETURN_NOT_FOUND;
 360       }
 361       *ActiveOption = AllocatePool (*Count * sizeof **ActiveOption);
 362       if (*ActiveOption == NULL) {
 363         return RETURN_OUT_OF_RESOURCES;
 364       }
 365     }
 366   }
 367   return RETURN_SUCCESS;
 368 }
 369
 370
 371 /**
 372   OpenFirmware device path node
 373 **/
 374 typedef struct {
 375   SUBSTRING DriverName;
 376   SUBSTRING UnitAddress;
 377   SUBSTRING DeviceArguments;
 378 } OFW_NODE;
 379
 380
 381 /**
 382
 383   Parse an OpenFirmware device path node into the caller-allocated OFW_NODE
 384   structure, and advance in the input string.
 385
 386   The node format is mostly parsed after IEEE 1275-1994, 3.2.1.1 "Node names"
 387   (a leading slash is expected and not returned):
 388
 389     /driver-name@unit-address[:device-arguments][<LF>]
 390
 391   A single trailing <LF> character is consumed but not returned. A trailing
 392   <LF> or NUL character terminates the device path.
 393
 394   The function relies on ASCII encoding.
 395
 396   @param[in out] Ptr      Address of the pointer pointing to the start of the
 397                           node string. After successful parsing *Ptr is set to
 398                           the byte immediately following the consumed
 399                           characters. On error it points to the byte that
 400                           caused the error. The input string is never modified.
 401
 402   @param[out]    OfwNode  The members of this structure point into the input
 403                           string, designating components of the node.
 404                           Separators are never included. If "device-arguments"
 405                           is missing, then DeviceArguments.Ptr is set to NULL.
 406                           All components that are present have nonzero length.
 407
 408                           If the call doesn't succeed, the contents of this
 409                           structure is indeterminate.
 410
 411   @param[out]    IsFinal  In case of successul parsing, this parameter signals
 412                           whether the node just parsed is the final node in the
 413                           device path. The call after a final node will attempt
 414                           to start parsing the next path. If the call doesn't
 415                           succeed, then this parameter is not changed.
 416
 417
 418   @retval RETURN_SUCCESS            Parsing successful.
 419
 420   @retval RETURN_NOT_FOUND          Parsing terminated. *Ptr was (and is)
 421                                     pointing to an empty string.
 422
 423   @retval RETURN_INVALID_PARAMETER  Parse error.
 424
 425 **/
 426 STATIC
 427 RETURN_STATUS
 428 ParseOfwNode (
 429   IN OUT  CONST CHAR8 **Ptr,
 430   OUT     OFW_NODE    *OfwNode,
 431   OUT     BOOLEAN     *IsFinal
 432   )
 433 {
 434   //
 435   // A leading slash is expected. End of string is tolerated.
 436   //
 437   switch (**Ptr) {
 438   case '\0':
 439     return RETURN_NOT_FOUND;
 440
 441   case '/':
 442     ++*Ptr;
 443     break;
 444
 445   default:
 446     return RETURN_INVALID_PARAMETER;
 447   }
 448
 449   //
 450   // driver-name
 451   //
 452   OfwNode->DriverName.Ptr = *Ptr;
 453   OfwNode->DriverName.Len = 0;
 454   while (OfwNode->DriverName.Len < 32 &&
 455          (IsAlnum (**Ptr) || IsDriverNamePunct (**Ptr))
 456          ) {
 457     ++*Ptr;
 458     ++OfwNode->DriverName.Len;
 459   }
 460
 461   if (OfwNode->DriverName.Len == 0 || OfwNode->DriverName.Len == 32) {
 462     return RETURN_INVALID_PARAMETER;
 463   }
 464
 465
 466   //
 467   // unit-address
 468   //
 469   if (**Ptr != '@') {
 470     return RETURN_INVALID_PARAMETER;
 471   }
 472   ++*Ptr;
 473
 474   OfwNode->UnitAddress.Ptr = *Ptr;
 475   OfwNode->UnitAddress.Len = 0;
 476   while (IsPrintNotDelim (**Ptr)) {
 477     ++*Ptr;
 478     ++OfwNode->UnitAddress.Len;
 479   }
 480
 481   if (OfwNode->UnitAddress.Len == 0) {
 482     return RETURN_INVALID_PARAMETER;
 483   }
 484
 485
 486   //
 487   // device-arguments, may be omitted
 488   //
 489   OfwNode->DeviceArguments.Len = 0;
 490   if (**Ptr == ':') {
 491     ++*Ptr;
 492     OfwNode->DeviceArguments.Ptr = *Ptr;
 493
 494     while (IsPrintNotDelim (**Ptr)) {
 495       ++*Ptr;
 496       ++OfwNode->DeviceArguments.Len;
 497     }
 498
 499     if (OfwNode->DeviceArguments.Len == 0) {
 500       return RETURN_INVALID_PARAMETER;
 501     }
 502   }
 503   else {
 504     OfwNode->DeviceArguments.Ptr = NULL;
 505   }
 506
 507   switch (**Ptr) {
 508   case '\n':
 509     ++*Ptr;
 510     //
 511     // fall through
 512     //
 513
 514   case '\0':
 515     *IsFinal = TRUE;
 516     break;
 517
 518   case '/':
 519     *IsFinal = FALSE;
 520     break;
 521
 522   default:
 523     return RETURN_INVALID_PARAMETER;
 524   }
 525
 526   DEBUG ((
 527     DEBUG_VERBOSE,
 528     "%a: DriverName=\"%.*a\" UnitAddress=\"%.*a\" DeviceArguments=\"%.*a\"\n",
 529     __FUNCTION__,
 530     OfwNode->DriverName.Len, OfwNode->DriverName.Ptr,
 531     OfwNode->UnitAddress.Len, OfwNode->UnitAddress.Ptr,
 532     OfwNode->DeviceArguments.Len,
 533     OfwNode->DeviceArguments.Ptr == NULL ? "" : OfwNode->DeviceArguments.Ptr
 534     ));
 535   return RETURN_SUCCESS;
 536 }
 537
 538
 539 /**
 540
 541   Translate an array of OpenFirmware device nodes to a UEFI device path
 542   fragment.
 543
 544   @param[in]     OfwNode         Array of OpenFirmware device nodes to
 545                                  translate, constituting the beginning of an
 546                                  OpenFirmware device path.
 547
 548   @param[in]     NumNodes        Number of elements in OfwNode.
 549
 550   @param[out]    Translated      Destination array receiving the UEFI path
 551                                  fragment, allocated by the caller. If the
 552                                  return value differs from RETURN_SUCCESS, its
 553                                  contents is indeterminate.
 554
 555   @param[in out] TranslatedSize  On input, the number of CHAR16's in
 556                                  Translated. On RETURN_SUCCESS this parameter
 557                                  is assigned the number of non-NUL CHAR16's
 558                                  written to Translated. In case of other return
 559                                  values, TranslatedSize is indeterminate.
 560
 561
 562   @retval RETURN_SUCCESS           Translation successful.
 563
 564   @retval RETURN_BUFFER_TOO_SMALL  The translation does not fit into the number
 565                                    of bytes provided.
 566
 567   @retval RETURN_UNSUPPORTED       The array of OpenFirmware device nodes can't
 568                                    be translated in the current implementation.
 569
 570 **/
 571 STATIC
 572 RETURN_STATUS
 573 TranslateOfwNodes (
 574   IN      CONST OFW_NODE *OfwNode,
 575   IN      UINTN          NumNodes,
 576   OUT     CHAR16         *Translated,
 577   IN OUT  UINTN          *TranslatedSize
 578   )
 579 {
 580   UINT32 PciDevFun[2];
 581   UINTN  NumEntries;
 582   UINTN  Written;
 583
 584   //
 585   // Get PCI device and optional PCI function. Assume a single PCI root.
 586   //
 587   if (NumNodes < REQUIRED_OFW_NODES ||
 588       !SubstringEq (OfwNode[0].DriverName, "pci")
 589       ) {
 590     return RETURN_UNSUPPORTED;
 591   }
 592   PciDevFun[1] = 0;
 593   NumEntries = sizeof (PciDevFun) / sizeof (PciDevFun[0]);
 594   if (ParseUnitAddressHexList (
 595         OfwNode[1].UnitAddress,
 596         PciDevFun,
 597         &NumEntries
 598         ) != RETURN_SUCCESS
 599       ) {
 600     return RETURN_UNSUPPORTED;
 601   }
 602
 603   if (NumNodes >= 4 &&
 604       SubstringEq (OfwNode[1].DriverName, "ide") &&
 605       SubstringEq (OfwNode[2].DriverName, "drive") &&
 606       SubstringEq (OfwNode[3].DriverName, "disk")
 607       ) {
 608     //
 609     // OpenFirmware device path (IDE disk, IDE CD-ROM):
 610     //
 611     //   /pci@i0cf8/ide@1,1/drive@0/disk@0
 612     //        ^         ^ ^       ^      ^
 613     //        |         | |       |      master or slave
 614     //        |         | |       primary or secondary
 615     //        |         PCI slot & function holding IDE controller
 616     //        PCI root at system bus port, PIO
 617     //
 618     // UEFI device path:
 619     //
 620     //   PciRoot(0x0)/Pci(0x1,0x1)/Ata(Primary,Master,0x0)
 621     //                                                ^
 622     //                                                fixed LUN
 623     //
 624     UINT32 Secondary;
 625     UINT32 Slave;
 626
 627     NumEntries = 1;
 628     if (ParseUnitAddressHexList (
 629           OfwNode[2].UnitAddress,
 630           &Secondary,
 631           &NumEntries
 632           ) != RETURN_SUCCESS ||
 633         Secondary > 1 ||
 634         ParseUnitAddressHexList (
 635           OfwNode[3].UnitAddress,
 636           &Slave,
 637           &NumEntries // reuse after previous single-element call
 638           ) != RETURN_SUCCESS ||
 639         Slave > 1
 640         ) {
 641       return RETURN_UNSUPPORTED;
 642     }
 643
 644     Written = UnicodeSPrintAsciiFormat (
 645       Translated,
 646       *TranslatedSize * sizeof (*Translated), // BufferSize in bytes
 647       "PciRoot(0x0)/Pci(0x%x,0x%x)/Ata(%a,%a,0x0)",
 648       PciDevFun[0],
 649       PciDevFun[1],
 650       Secondary ? "Secondary" : "Primary",
 651       Slave ? "Slave" : "Master"
 652       );
 653   } else if (NumNodes >= 4 &&
 654              SubstringEq (OfwNode[1].DriverName, "isa") &&
 655              SubstringEq (OfwNode[2].DriverName, "fdc") &&
 656              SubstringEq (OfwNode[3].DriverName, "floppy")
 657              ) {
 658     //
 659     // OpenFirmware device path (floppy disk):
 660     //
 661     //   /pci@i0cf8/isa@1/fdc@03f0/floppy@0
 662     //        ^         ^     ^           ^
 663     //        |         |     |           A: or B:
 664     //        |         |     ISA controller io-port (hex)
 665     //        |         PCI slot holding ISA controller
 666     //        PCI root at system bus port, PIO
 667     //
 668     // UEFI device path:
 669     //
 670     //   PciRoot(0x0)/Pci(0x1,0x0)/Floppy(0x0)
 671     //                                    ^
 672     //                                    ACPI UID
 673     //
 674     UINT32 AcpiUid;
 675
 676     NumEntries = 1;
 677     if (ParseUnitAddressHexList (
 678           OfwNode[3].UnitAddress,
 679           &AcpiUid,
 680           &NumEntries
 681           ) != RETURN_SUCCESS ||
 682         AcpiUid > 1
 683         ) {
 684       return RETURN_UNSUPPORTED;
 685     }
 686
 687     Written = UnicodeSPrintAsciiFormat (
 688       Translated,
 689       *TranslatedSize * sizeof (*Translated), // BufferSize in bytes
 690       "PciRoot(0x0)/Pci(0x%x,0x%x)/Floppy(0x%x)",
 691       PciDevFun[0],
 692       PciDevFun[1],
 693       AcpiUid
 694       );
 695   } else if (NumNodes >= 3 &&
 696              SubstringEq (OfwNode[1].DriverName, "scsi") &&
 697              SubstringEq (OfwNode[2].DriverName, "disk")
 698              ) {
 699     //
 700     // OpenFirmware device path (virtio-blk disk):
 701     //
 702     //   /pci@i0cf8/scsi@6[,3]/disk@0,0
 703     //        ^          ^  ^       ^ ^
 704     //        |          |  |       fixed
 705     //        |          |  PCI function corresponding to disk (optional)
 706     //        |          PCI slot holding disk
 707     //        PCI root at system bus port, PIO
 708     //
 709     // UEFI device path prefix:
 710     //
 711     //   PciRoot(0x0)/Pci(0x6,0x0)/HD( -- if PCI function is 0 or absent
 712     //   PciRoot(0x0)/Pci(0x6,0x3)/HD( -- if PCI function is present and nonzero
 713     //
 714     Written = UnicodeSPrintAsciiFormat (
 715       Translated,
 716       *TranslatedSize * sizeof (*Translated), // BufferSize in bytes
 717       "PciRoot(0x0)/Pci(0x%x,0x%x)/HD(",
 718       PciDevFun[0],
 719       PciDevFun[1]
 720       );
 721   } else if (NumNodes >= 4 &&
 722              SubstringEq (OfwNode[1].DriverName, "scsi") &&
 723              SubstringEq (OfwNode[2].DriverName, "channel") &&
 724              SubstringEq (OfwNode[3].DriverName, "disk")
 725              ) {
 726     //
 727     // OpenFirmware device path (virtio-scsi disk):
 728     //
 729     //   /pci@i0cf8/scsi@7[,3]/channel@0/disk@2,3
 730     //        ^          ^             ^      ^ ^
 731     //        |          |             |      | LUN
 732     //        |          |             |      target
 733     //        |          |             channel (unused, fixed 0)
 734     //        |          PCI slot[, function] holding SCSI controller
 735     //        PCI root at system bus port, PIO
 736     //
 737     // UEFI device path prefix:
 738     //
 739     //   PciRoot(0x0)/Pci(0x7,0x0)/Scsi(0x2,0x3)
 740     //                                        -- if PCI function is 0 or absent
 741     //   PciRoot(0x0)/Pci(0x7,0x3)/Scsi(0x2,0x3)
 742     //                                -- if PCI function is present and nonzero
 743     //
 744     UINT32 TargetLun[2];
 745
 746     TargetLun[1] = 0;
 747     NumEntries = sizeof (TargetLun) / sizeof (TargetLun[0]);
 748     if (ParseUnitAddressHexList (
 749           OfwNode[3].UnitAddress,
 750           TargetLun,
 751           &NumEntries
 752           ) != RETURN_SUCCESS
 753         ) {
 754       return RETURN_UNSUPPORTED;
 755     }
 756
 757     Written = UnicodeSPrintAsciiFormat (
 758       Translated,
 759       *TranslatedSize * sizeof (*Translated), // BufferSize in bytes
 760       "PciRoot(0x0)/Pci(0x%x,0x%x)/Scsi(0x%x,0x%x)",
 761       PciDevFun[0],
 762       PciDevFun[1],
 763       TargetLun[0],
 764       TargetLun[1]
 765       );
 766   } else if (NumNodes >= 3 &&
 767              SubstringEq (OfwNode[1].DriverName, "ethernet") &&
 768              SubstringEq (OfwNode[2].DriverName, "ethernet-phy")
 769              ) {
 770     //
 771     // OpenFirmware device path (Ethernet NIC):
 772     //
 773     //   /pci@i0cf8/ethernet@3[,2]/ethernet-phy@0
 774     //        ^              ^                  ^
 775     //        |              |                  fixed
 776     //        |              PCI slot[, function] holding Ethernet card
 777     //        PCI root at system bus port, PIO
 778     //
 779     // UEFI device path prefix (dependent on presence of nonzero PCI function):
 780     //
 781     //   PciRoot(0x0)/Pci(0x3,0x0)/MAC(525400E15EEF,0x1)
 782     //   PciRoot(0x0)/Pci(0x3,0x2)/MAC(525400E15EEF,0x1)
 783     //                                 ^            ^
 784     //                                 MAC address  IfType (1 == Ethernet)
 785     //
 786     // (Some UEFI NIC drivers don't set 0x1 for IfType.)
 787     //
 788     Written = UnicodeSPrintAsciiFormat (
 789       Translated,
 790       *TranslatedSize * sizeof (*Translated), // BufferSize in bytes
 791       "PciRoot(0x0)/Pci(0x%x,0x%x)/MAC",
 792       PciDevFun[0],
 793       PciDevFun[1]
 794       );
 795   } else {
 796     return RETURN_UNSUPPORTED;
 797   }
 798
 799   //
 800   // There's no way to differentiate between "completely used up without
 801   // truncation" and "truncated", so treat the former as the latter, and return
 802   // success only for "some room left unused".
 803   //
 804   if (Written + 1 < *TranslatedSize) {
 805     *TranslatedSize = Written;
 806     return RETURN_SUCCESS;
 807   }
 808
 809   return RETURN_BUFFER_TOO_SMALL;
 810 }
 811
 812
 813 /**
 814
 815   Translate an OpenFirmware device path fragment to a UEFI device path
 816   fragment, and advance in the input string.
 817
 818   @param[in out] Ptr             Address of the pointer pointing to the start
 819                                  of the path string. After successful
 820                                  translation (RETURN_SUCCESS) or at least
 821                                  successful parsing (RETURN_UNSUPPORTED,
 822                                  RETURN_BUFFER_TOO_SMALL), *Ptr is set to the
 823                                  byte immediately following the consumed
 824                                  characters. In other error cases, it points to
 825                                  the byte that caused the error.
 826
 827   @param[out]    Translated      Destination array receiving the UEFI path
 828                                  fragment, allocated by the caller. If the
 829                                  return value differs from RETURN_SUCCESS, its
 830                                  contents is indeterminate.
 831
 832   @param[in out] TranslatedSize  On input, the number of CHAR16's in
 833                                  Translated. On RETURN_SUCCESS this parameter
 834                                  is assigned the number of non-NUL CHAR16's
 835                                  written to Translated. In case of other return
 836                                  values, TranslatedSize is indeterminate.
 837
 838
 839   @retval RETURN_SUCCESS            Translation successful.
 840
 841   @retval RETURN_BUFFER_TOO_SMALL   The OpenFirmware device path was parsed
 842                                     successfully, but its translation did not
 843                                     fit into the number of bytes provided.
 844                                     Further calls to this function are
 845                                     possible.
 846
 847   @retval RETURN_UNSUPPORTED        The OpenFirmware device path was parsed
 848                                     successfully, but it can't be translated in
 849                                     the current implementation. Further calls
 850                                     to this function are possible.
 851
 852   @retval RETURN_NOT_FOUND          Translation terminated. On input, *Ptr was
 853                                     pointing to the empty string or "HALT". On
 854                                     output, *Ptr points to the empty string
 855                                     (ie. "HALT" is consumed transparently when
 856                                     present).
 857
 858   @retval RETURN_INVALID_PARAMETER  Parse error. This is a permanent error.
 859
 860 **/
 861 STATIC
 862 RETURN_STATUS
 863 TranslateOfwPath (
 864   IN OUT  CONST CHAR8 **Ptr,
 865   OUT     CHAR16      *Translated,
 866   IN OUT  UINTN       *TranslatedSize
 867   )
 868 {
 869   UINTN         NumNodes;
 870   RETURN_STATUS Status;
 871   OFW_NODE      Node[EXAMINED_OFW_NODES];
 872   BOOLEAN       IsFinal;
 873   OFW_NODE      Skip;
 874
 875   NumNodes = 0;
 876   if (AsciiStrCmp (*Ptr, "HALT") == 0) {
 877     *Ptr += 4;
 878     Status = RETURN_NOT_FOUND;
 879   } else {
 880     Status = ParseOfwNode (Ptr, &Node[NumNodes], &IsFinal);
 881   }
 882
 883   if (Status == RETURN_NOT_FOUND) {
 884     DEBUG ((DEBUG_VERBOSE, "%a: no more nodes\n", __FUNCTION__));
 885     return RETURN_NOT_FOUND;
 886   }
 887
 888   while (Status == RETURN_SUCCESS && !IsFinal) {
 889     ++NumNodes;
 890     Status = ParseOfwNode (
 891                Ptr,
 892                (NumNodes < EXAMINED_OFW_NODES) ? &Node[NumNodes] : &Skip,
 893                &IsFinal
 894                );
 895   }
 896
 897   switch (Status) {
 898   case RETURN_SUCCESS:
 899     ++NumNodes;
 900     break;
 901
 902   case RETURN_INVALID_PARAMETER:
 903     DEBUG ((DEBUG_VERBOSE, "%a: parse error\n", __FUNCTION__));
 904     return RETURN_INVALID_PARAMETER;
 905
 906   default:
 907     ASSERT (0);
 908   }
 909
 910   Status = TranslateOfwNodes (
 911              Node,
 912              NumNodes < EXAMINED_OFW_NODES ? NumNodes : EXAMINED_OFW_NODES,
 913              Translated,
 914              TranslatedSize);
 915   switch (Status) {
 916   case RETURN_SUCCESS:
 917     DEBUG ((DEBUG_VERBOSE, "%a: success: \"%s\"\n", __FUNCTION__, Translated));
 918     break;
 919
 920   case RETURN_BUFFER_TOO_SMALL:
 921     DEBUG ((DEBUG_VERBOSE, "%a: buffer too small\n", __FUNCTION__));
 922     break;
 923
 924   case RETURN_UNSUPPORTED:
 925     DEBUG ((DEBUG_VERBOSE, "%a: unsupported\n", __FUNCTION__));
 926     break;
 927
 928   default:
 929     ASSERT (0);
 930   }
 931   return Status;
 932 }
 933
 934
 935 /**
 936
 937   Convert the UEFI DevicePath to full text representation with DevPathToText,
 938   then match the UEFI device path fragment in Translated against it.
 939
 940   @param[in] Translated        UEFI device path fragment, translated from
 941                                OpenFirmware format, to search for.
 942
 943   @param[in] TranslatedLength  The length of Translated in CHAR16's.
 944
 945   @param[in] DevicePath        Boot option device path whose textual rendering
 946                                to search in.
 947
 948   @param[in] DevPathToText  Binary-to-text conversion protocol for DevicePath.
 949
 950
 951   @retval TRUE   If Translated was found at the beginning of DevicePath after
 952                  converting the latter to text.
 953
 954   @retval FALSE  If DevicePath was NULL, or it could not be converted, or there
 955                  was no match.
 956
 957 **/
 958 STATIC
 959 BOOLEAN
 960 Match (
 961   IN  CONST CHAR16                           *Translated,
 962   IN  UINTN                                  TranslatedLength,
 963   IN  CONST EFI_DEVICE_PATH_PROTOCOL         *DevicePath
 964   )
 965 {
 966   CHAR16  *Converted;
 967   BOOLEAN Result;
 968
 969   Converted = ConvertDevicePathToText (
 970                 DevicePath,
 971                 FALSE, // DisplayOnly
 972                 FALSE  // AllowShortcuts
 973                 );
 974   if (Converted == NULL) {
 975     return FALSE;
 976   }
 977
 978   //
 979   // Attempt to expand any relative UEFI device path starting with HD() to an
 980   // absolute device path first. The logic imitates BdsLibBootViaBootOption().
 981   // We don't have to free the absolute device path,
 982   // BdsExpandPartitionPartialDevicePathToFull() has internal caching.
 983   //
 984   Result = FALSE;
 985   if (DevicePathType (DevicePath) == MEDIA_DEVICE_PATH &&
 986       DevicePathSubType (DevicePath) == MEDIA_HARDDRIVE_DP) {
 987     EFI_DEVICE_PATH_PROTOCOL *AbsDevicePath;
 988     CHAR16                   *AbsConverted;
 989
 990     AbsDevicePath = BdsExpandPartitionPartialDevicePathToFull (
 991                       (HARDDRIVE_DEVICE_PATH *) DevicePath);
 992     if (AbsDevicePath == NULL) {
 993       goto Exit;
 994     }
 995     AbsConverted = ConvertDevicePathToText (AbsDevicePath, FALSE, FALSE);
 996     if (AbsConverted == NULL) {
 997       goto Exit;
 998     }
 999     DEBUG ((DEBUG_VERBOSE,
1000       "%a: expanded relative device path \"%s\" for prefix matching\n",
1001       __FUNCTION__, Converted));
1002     FreePool (Converted);
1003     Converted = AbsConverted;
1004   }
1005
1006   //
1007   // Is Translated a prefix of Converted?
1008   //
1009   Result = (BOOLEAN)(StrnCmp (Converted, Translated, TranslatedLength) == 0);
1010   DEBUG ((
1011     DEBUG_VERBOSE,
1012     "%a: against \"%s\": %a\n",
1013     __FUNCTION__,
1014     Converted,
1015     Result ? "match" : "no match"
1016     ));
1017 Exit:
1018   FreePool (Converted);
1019   return Result;
1020 }
1021
1022
1023 /**
1024   Append some of the unselected active boot options to the boot order.
1025
1026   This function should accommodate any further policy changes in "boot option
1027   survival". Currently we're adding back everything that starts with neither
1028   PciRoot() nor HD().
1029
1030   @param[in,out] BootOrder     The structure holding the boot order to
1031                                complete. The caller is responsible for
1032                                initializing (and potentially populating) it
1033                                before calling this function.
1034
1035   @param[in,out] ActiveOption  The array of active boot options to scan.
1036                                Entries marked as Appended will be skipped.
1037                                Those of the rest that satisfy the survival
1038                                policy will be added to BootOrder with
1039                                BootOrderAppend().
1040
1041   @param[in]     ActiveCount   Number of elements in ActiveOption.
1042
1043
1044   @retval RETURN_SUCCESS  BootOrder has been extended with any eligible boot
1045                           options.
1046
1047   @return                 Error codes returned by BootOrderAppend().
1048 **/
1049 STATIC
1050 RETURN_STATUS
1051 BootOrderComplete (
1052   IN OUT  BOOT_ORDER    *BootOrder,
1053   IN OUT  ACTIVE_OPTION *ActiveOption,
1054   IN      UINTN         ActiveCount
1055   )
1056 {
1057   RETURN_STATUS Status;
1058   UINTN         Idx;
1059
1060   Status = RETURN_SUCCESS;
1061   Idx = 0;
1062   while (!RETURN_ERROR (Status) && Idx < ActiveCount) {
1063     if (!ActiveOption[Idx].Appended) {
1064       CONST BDS_COMMON_OPTION        *Current;
1065       CONST EFI_DEVICE_PATH_PROTOCOL *FirstNode;
1066
1067       Current = ActiveOption[Idx].BootOption;
1068       FirstNode = Current->DevicePath;
1069       if (FirstNode != NULL) {
1070         CHAR16        *Converted;
1071         STATIC CHAR16 ConvFallBack[] = L"<unable to convert>";
1072         BOOLEAN       Keep;
1073
1074         Converted = ConvertDevicePathToText (FirstNode, FALSE, FALSE);
1075         if (Converted == NULL) {
1076           Converted = ConvFallBack;
1077         }
1078
1079         Keep = TRUE;
1080         if (DevicePathType(FirstNode) == MEDIA_DEVICE_PATH &&
1081             DevicePathSubType(FirstNode) == MEDIA_HARDDRIVE_DP) {
1082           //
1083           // drop HD()
1084           //
1085           Keep = FALSE;
1086         } else if (DevicePathType(FirstNode) == ACPI_DEVICE_PATH &&
1087                    DevicePathSubType(FirstNode) == ACPI_DP) {
1088           ACPI_HID_DEVICE_PATH *Acpi;
1089
1090           Acpi = (ACPI_HID_DEVICE_PATH *) FirstNode;
1091           if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST &&
1092               EISA_ID_TO_NUM (Acpi->HID) == 0x0a03) {
1093             //
1094             // drop PciRoot()
1095             //
1096             Keep = FALSE;
1097           }
1098         }
1099
1100         if (Keep) {
1101           Status = BootOrderAppend (BootOrder, &ActiveOption[Idx]);
1102           if (!RETURN_ERROR (Status)) {
1103             DEBUG ((DEBUG_VERBOSE, "%a: keeping \"%s\"\n", __FUNCTION__,
1104               Converted));
1105           }
1106         } else {
1107           DEBUG ((DEBUG_VERBOSE, "%a: dropping \"%s\"\n", __FUNCTION__,
1108             Converted));
1109         }
1110
1111         if (Converted != ConvFallBack) {
1112           FreePool (Converted);
1113         }
1114       }
1115     }
1116     ++Idx;
1117   }
1118   return Status;
1119 }
1120
1121
1122 /**
1123
1124   Set the boot order based on configuration retrieved from QEMU.
1125
1126   Attempt to retrieve the "bootorder" fw_cfg file from QEMU. Translate the
1127   OpenFirmware device paths therein to UEFI device path fragments. Match the
1128   translated fragments against BootOptionList, and rewrite the BootOrder NvVar
1129   so that it corresponds to the order described in fw_cfg.
1130
1131   @param[in] BootOptionList  A boot option list, created with
1132                              BdsLibEnumerateAllBootOption ().
1133
1134
1135   @retval RETURN_SUCCESS            BootOrder NvVar rewritten.
1136
1137   @retval RETURN_UNSUPPORTED        QEMU's fw_cfg is not supported.
1138
1139   @retval RETURN_NOT_FOUND          Empty or nonexistent "bootorder" fw_cfg
1140                                     file, or no match found between the
1141                                     "bootorder" fw_cfg file and BootOptionList.
1142
1143   @retval RETURN_INVALID_PARAMETER  Parse error in the "bootorder" fw_cfg file.
1144
1145   @retval RETURN_OUT_OF_RESOURCES   Memory allocation failed.
1146
1147   @return                           Values returned by gBS->LocateProtocol ()
1148                                     or gRT->SetVariable ().
1149
1150 **/
1151 RETURN_STATUS
1152 SetBootOrderFromQemu (
1153   IN  CONST LIST_ENTRY *BootOptionList
1154   )
1155 {
1156   RETURN_STATUS                    Status;
1157   FIRMWARE_CONFIG_ITEM             FwCfgItem;
1158   UINTN                            FwCfgSize;
1159   CHAR8                            *FwCfg;
1160   CONST CHAR8                      *FwCfgPtr;
1161
1162   BOOT_ORDER                       BootOrder;
1163   ACTIVE_OPTION                    *ActiveOption;
1164   UINTN                            ActiveCount;
1165
1166   UINTN                            TranslatedSize;
1167   CHAR16                           Translated[TRANSLATION_OUTPUT_SIZE];
1168
1169   Status = QemuFwCfgFindFile ("bootorder", &FwCfgItem, &FwCfgSize);
1170   if (Status != RETURN_SUCCESS) {
1171     return Status;
1172   }
1173
1174   if (FwCfgSize == 0) {
1175     return RETURN_NOT_FOUND;
1176   }
1177
1178   FwCfg = AllocatePool (FwCfgSize);
1179   if (FwCfg == NULL) {
1180     return RETURN_OUT_OF_RESOURCES;
1181   }
1182
1183   QemuFwCfgSelectItem (FwCfgItem);
1184   QemuFwCfgReadBytes (FwCfgSize, FwCfg);
1185   if (FwCfg[FwCfgSize - 1] != '\0') {
1186     Status = RETURN_INVALID_PARAMETER;
1187     goto ErrorFreeFwCfg;
1188   }
1189
1190   DEBUG ((DEBUG_VERBOSE, "%a: FwCfg:\n", __FUNCTION__));
1191   DEBUG ((DEBUG_VERBOSE, "%a\n", FwCfg));
1192   DEBUG ((DEBUG_VERBOSE, "%a: FwCfg: <end>\n", __FUNCTION__));
1193   FwCfgPtr = FwCfg;
1194
1195   BootOrder.Produced  = 0;
1196   BootOrder.Allocated = 1;
1197   BootOrder.Data = AllocatePool (
1198                      BootOrder.Allocated * sizeof (*BootOrder.Data)
1199                      );
1200   if (BootOrder.Data == NULL) {
1201     Status = RETURN_OUT_OF_RESOURCES;
1202     goto ErrorFreeFwCfg;
1203   }
1204
1205   Status = CollectActiveOptions (BootOptionList, &ActiveOption, &ActiveCount);
1206   if (RETURN_ERROR (Status)) {
1207     goto ErrorFreeBootOrder;
1208   }
1209
1210   //
1211   // translate each OpenFirmware path
1212   //
1213   TranslatedSize = sizeof (Translated) / sizeof (Translated[0]);
1214   Status = TranslateOfwPath (&FwCfgPtr, Translated, &TranslatedSize);
1215   while (Status == RETURN_SUCCESS ||
1216          Status == RETURN_UNSUPPORTED ||
1217          Status == RETURN_BUFFER_TOO_SMALL) {
1218     if (Status == RETURN_SUCCESS) {
1219       UINTN Idx;
1220
1221       //
1222       // match translated OpenFirmware path against all active boot options
1223       //
1224       for (Idx = 0; Idx < ActiveCount; ++Idx) {
1225         if (Match (
1226               Translated,
1227               TranslatedSize, // contains length, not size, in CHAR16's here
1228               ActiveOption[Idx].BootOption->DevicePath
1229               )
1230             ) {
1231           //
1232           // match found, store ID and continue with next OpenFirmware path
1233           //
1234           Status = BootOrderAppend (&BootOrder, &ActiveOption[Idx]);
1235           if (Status != RETURN_SUCCESS) {
1236             goto ErrorFreeActiveOption;
1237           }
1238           break;
1239         }
1240       } // scanned all active boot options
1241     }   // translation successful
1242
1243     TranslatedSize = sizeof (Translated) / sizeof (Translated[0]);
1244     Status = TranslateOfwPath (&FwCfgPtr, Translated, &TranslatedSize);
1245   } // scanning of OpenFirmware paths done
1246
1247   if (Status == RETURN_NOT_FOUND && BootOrder.Produced > 0) {
1248     //
1249     // No more OpenFirmware paths, some matches found: rewrite BootOrder NvVar.
1250     // Some of the active boot options that have not been selected over fw_cfg
1251     // should be preserved at the end of the boot order.
1252     //
1253     Status = BootOrderComplete (&BootOrder, ActiveOption, ActiveCount);
1254     if (RETURN_ERROR (Status)) {
1255       goto ErrorFreeActiveOption;
1256     }
1257
1258     //
1259     // See Table 10 in the UEFI Spec 2.3.1 with Errata C for the required
1260     // attributes.
1261     //
1262     Status = gRT->SetVariable (
1263                     L"BootOrder",
1264                     &gEfiGlobalVariableGuid,
1265                     EFI_VARIABLE_NON_VOLATILE |
1266                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
1267                       EFI_VARIABLE_RUNTIME_ACCESS,
1268                     BootOrder.Produced * sizeof (*BootOrder.Data),
1269                     BootOrder.Data
1270                     );
1271     DEBUG ((
1272       DEBUG_INFO,
1273       "%a: setting BootOrder: %a\n",
1274       __FUNCTION__,
1275       Status == EFI_SUCCESS ? "success" : "error"
1276       ));
1277   }
1278
1279 ErrorFreeActiveOption:
1280   FreePool (ActiveOption);
1281
1282 ErrorFreeBootOrder:
1283   FreePool (BootOrder.Data);
1284
1285 ErrorFreeFwCfg:
1286   FreePool (FwCfg);
1287
1288   return Status;
1289 }