1 /*- 2 * Copyright (c) 2017 Netflix, Inc. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 16 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 23 * SUCH DAMAGE. 24 */ 25 26 /* 27 * Routines to format EFI_DEVICE_PATHs from the UEFI standard. Much of 28 * this file is taken from EDK2 and rototilled. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <efivar.h> 35 #include <stdio.h> 36 #include <string.h> 37 38 #include "efichar.h" 39 40 #include "efi-osdep.h" 41 #include "efivar-dp.h" 42 43 #include "uefi-dplib.h" 44 45 /* 46 * This is a lie, but since we have converted everything 47 * from wide to narrow, it's the right lie now. 48 */ 49 #define UnicodeSPrint snprintf 50 51 /* 52 * Taken from MdePkg/Library/UefiDevicePathLib/DevicePathToText.c 53 * hash a11928f3310518ab1c6fd34e8d0fdbb72de9602c 2017-Mar-01 54 * heavily modified: 55 * wide strings converted to narrow 56 * Low level printing code redone for narrow strings 57 * Routines made static 58 * %s -> %S in spots (where it is still UCS-2) 59 * %a (ascii) -> %s 60 * %g -> %36s hack to print guid (see above for caveat) 61 * some tidying up of const and deconsting. It's evil, but const 62 * poisoning the whole file was too much. 63 */ 64 65 /** @file 66 DevicePathToText protocol as defined in the UEFI 2.0 specification. 67 68 (C) Copyright 2015 Hewlett-Packard Development Company, L.P.<BR> 69 Copyright (c) 2013 - 2015, Intel Corporation. All rights reserved.<BR> 70 This program and the accompanying materials 71 are licensed and made available under the terms and conditions of the BSD License 72 which accompanies this distribution. The full text of the license may be found at 73 http://opensource.org/licenses/bsd-license.php 74 75 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 76 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 77 78 **/ 79 80 // #include "UefiDevicePathLib.h" 81 82 /** 83 Concatenates a formatted unicode string to allocated pool. The caller must 84 free the resulting buffer. 85 86 @param Str Tracks the allocated pool, size in use, and 87 amount of pool allocated. 88 @param Fmt The format string 89 @param ... Variable arguments based on the format string. 90 91 @return Allocated buffer with the formatted string printed in it. 92 The caller must free the allocated buffer. The buffer 93 allocation is not packed. 94 95 **/ 96 static char * 97 EFIAPI 98 UefiDevicePathLibCatPrint ( 99 IN OUT POOL_PRINT *Str, 100 IN const char *Fmt, 101 ... 102 ) 103 { 104 UINTN Count; 105 VA_LIST Args; 106 107 VA_START (Args, Fmt); 108 Count = vsnprintf(NULL, 0, Fmt, Args); 109 VA_END(Args); 110 111 if ((Str->Count + (Count + 1)) > Str->Capacity) { 112 Str->Capacity = (Str->Count + (Count + 1) * 2); 113 Str->Str = reallocf(Str->Str, Str->Capacity); 114 ASSERT (Str->Str != NULL); 115 } 116 VA_START (Args, Fmt); 117 vsnprintf(Str->Str + Str->Count, Str->Capacity - Str->Count, Fmt, Args); 118 Str->Count += Count; 119 120 VA_END (Args); 121 return Str->Str; 122 } 123 124 /** 125 Converts a PCI device path structure to its string representative. 126 127 @param Str The string representative of input device. 128 @param DevPath The input device path structure. 129 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 130 of the display node is used, where applicable. If DisplayOnly 131 is FALSE, then the longer text representation of the display node 132 is used. 133 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 134 representation for a device node can be used, where applicable. 135 136 **/ 137 static VOID 138 DevPathToTextPci ( 139 IN OUT POOL_PRINT *Str, 140 IN VOID *DevPath, 141 IN BOOLEAN DisplayOnly, 142 IN BOOLEAN AllowShortcuts 143 ) 144 { 145 PCI_DEVICE_PATH *Pci; 146 147 Pci = DevPath; 148 UefiDevicePathLibCatPrint (Str, "Pci(0x%x,0x%x)", Pci->Device, Pci->Function); 149 } 150 151 /** 152 Converts a PC Card device path structure to its string representative. 153 154 @param Str The string representative of input device. 155 @param DevPath The input device path structure. 156 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 157 of the display node is used, where applicable. If DisplayOnly 158 is FALSE, then the longer text representation of the display node 159 is used. 160 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 161 representation for a device node can be used, where applicable. 162 163 **/ 164 static VOID 165 DevPathToTextPccard ( 166 IN OUT POOL_PRINT *Str, 167 IN VOID *DevPath, 168 IN BOOLEAN DisplayOnly, 169 IN BOOLEAN AllowShortcuts 170 ) 171 { 172 PCCARD_DEVICE_PATH *Pccard; 173 174 Pccard = DevPath; 175 UefiDevicePathLibCatPrint (Str, "PcCard(0x%x)", Pccard->FunctionNumber); 176 } 177 178 /** 179 Converts a Memory Map device path structure to its string representative. 180 181 @param Str The string representative of input device. 182 @param DevPath The input device path structure. 183 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 184 of the display node is used, where applicable. If DisplayOnly 185 is FALSE, then the longer text representation of the display node 186 is used. 187 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 188 representation for a device node can be used, where applicable. 189 190 **/ 191 static VOID 192 DevPathToTextMemMap ( 193 IN OUT POOL_PRINT *Str, 194 IN VOID *DevPath, 195 IN BOOLEAN DisplayOnly, 196 IN BOOLEAN AllowShortcuts 197 ) 198 { 199 MEMMAP_DEVICE_PATH *MemMap; 200 201 MemMap = DevPath; 202 UefiDevicePathLibCatPrint ( 203 Str, 204 "MemoryMapped(0x%x,0x%lx,0x%lx)", 205 MemMap->MemoryType, 206 MemMap->StartingAddress, 207 MemMap->EndingAddress 208 ); 209 } 210 211 /** 212 Converts a Vendor device path structure to its string representative. 213 214 @param Str The string representative of input device. 215 @param DevPath The input device path structure. 216 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 217 of the display node is used, where applicable. If DisplayOnly 218 is FALSE, then the longer text representation of the display node 219 is used. 220 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 221 representation for a device node can be used, where applicable. 222 223 **/ 224 static VOID 225 DevPathToTextVendor ( 226 IN OUT POOL_PRINT *Str, 227 IN VOID *DevPath, 228 IN BOOLEAN DisplayOnly, 229 IN BOOLEAN AllowShortcuts 230 ) 231 { 232 VENDOR_DEVICE_PATH *Vendor; 233 const char *Type; 234 UINTN Index; 235 UINTN DataLength; 236 UINT32 FlowControlMap; 237 UINT16 Info; 238 239 Vendor = (VENDOR_DEVICE_PATH *) DevPath; 240 switch (DevicePathType (&Vendor->Header)) { 241 case HARDWARE_DEVICE_PATH: 242 Type = "Hw"; 243 break; 244 245 case MESSAGING_DEVICE_PATH: 246 Type = "Msg"; 247 if (AllowShortcuts) { 248 if (CompareGuid (&Vendor->Guid, &gEfiPcAnsiGuid)) { 249 UefiDevicePathLibCatPrint (Str, "VenPcAnsi()"); 250 return ; 251 } else if (CompareGuid (&Vendor->Guid, &gEfiVT100Guid)) { 252 UefiDevicePathLibCatPrint (Str, "VenVt100()"); 253 return ; 254 } else if (CompareGuid (&Vendor->Guid, &gEfiVT100PlusGuid)) { 255 UefiDevicePathLibCatPrint (Str, "VenVt100Plus()"); 256 return ; 257 } else if (CompareGuid (&Vendor->Guid, &gEfiVTUTF8Guid)) { 258 UefiDevicePathLibCatPrint (Str, "VenUft8()"); 259 return ; 260 } else if (CompareGuid (&Vendor->Guid, &gEfiUartDevicePathGuid)) { 261 FlowControlMap = (((UART_FLOW_CONTROL_DEVICE_PATH *) Vendor)->FlowControlMap); 262 switch (FlowControlMap & 0x00000003) { 263 case 0: 264 UefiDevicePathLibCatPrint (Str, "UartFlowCtrl(%s)", "None"); 265 break; 266 267 case 1: 268 UefiDevicePathLibCatPrint (Str, "UartFlowCtrl(%s)", "Hardware"); 269 break; 270 271 case 2: 272 UefiDevicePathLibCatPrint (Str, "UartFlowCtrl(%s)", "XonXoff"); 273 break; 274 275 default: 276 break; 277 } 278 279 return ; 280 } else if (CompareGuid (&Vendor->Guid, &gEfiSasDevicePathGuid)) { 281 UefiDevicePathLibCatPrint ( 282 Str, 283 "SAS(0x%lx,0x%lx,0x%x,", 284 ((SAS_DEVICE_PATH *) Vendor)->SasAddress, 285 ((SAS_DEVICE_PATH *) Vendor)->Lun, 286 ((SAS_DEVICE_PATH *) Vendor)->RelativeTargetPort 287 ); 288 Info = (((SAS_DEVICE_PATH *) Vendor)->DeviceTopology); 289 if (((Info & 0x0f) == 0) && ((Info & BIT7) == 0)) { 290 UefiDevicePathLibCatPrint (Str, "NoTopology,0,0,0,"); 291 } else if (((Info & 0x0f) <= 2) && ((Info & BIT7) == 0)) { 292 UefiDevicePathLibCatPrint ( 293 Str, 294 "%s,%s,%s,", 295 ((Info & BIT4) != 0) ? "SATA" : "SAS", 296 ((Info & BIT5) != 0) ? "External" : "Internal", 297 ((Info & BIT6) != 0) ? "Expanded" : "Direct" 298 ); 299 if ((Info & 0x0f) == 1) { 300 UefiDevicePathLibCatPrint (Str, "0,"); 301 } else { 302 // 303 // Value 0x0 thru 0xFF -> Drive 1 thru Drive 256 304 // 305 UefiDevicePathLibCatPrint (Str, "0x%x,", ((Info >> 8) & 0xff) + 1); 306 } 307 } else { 308 UefiDevicePathLibCatPrint (Str, "0x%x,0,0,0,", Info); 309 } 310 311 UefiDevicePathLibCatPrint (Str, "0x%x)", ((SAS_DEVICE_PATH *) Vendor)->Reserved); 312 return ; 313 } else if (CompareGuid (&Vendor->Guid, &gEfiDebugPortProtocolGuid)) { 314 UefiDevicePathLibCatPrint (Str, "DebugPort()"); 315 return ; 316 } 317 } 318 break; 319 320 case MEDIA_DEVICE_PATH: 321 Type = "Media"; 322 break; 323 324 default: 325 Type = "?"; 326 break; 327 } 328 329 DataLength = DevicePathNodeLength (&Vendor->Header) - sizeof (VENDOR_DEVICE_PATH); 330 UefiDevicePathLibCatPrint (Str, "Ven%s(%36s", Type, G(&Vendor->Guid)); 331 if (DataLength != 0) { 332 UefiDevicePathLibCatPrint (Str, ","); 333 for (Index = 0; Index < DataLength; Index++) { 334 UefiDevicePathLibCatPrint (Str, "%02x", ((VENDOR_DEVICE_PATH_WITH_DATA *) Vendor)->VendorDefinedData[Index]); 335 } 336 } 337 338 UefiDevicePathLibCatPrint (Str, ")"); 339 } 340 341 /** 342 Converts a Controller device path structure to its string representative. 343 344 @param Str The string representative of input device. 345 @param DevPath The input device path structure. 346 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 347 of the display node is used, where applicable. If DisplayOnly 348 is FALSE, then the longer text representation of the display node 349 is used. 350 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 351 representation for a device node can be used, where applicable. 352 353 **/ 354 static VOID 355 DevPathToTextController ( 356 IN OUT POOL_PRINT *Str, 357 IN VOID *DevPath, 358 IN BOOLEAN DisplayOnly, 359 IN BOOLEAN AllowShortcuts 360 ) 361 { 362 CONTROLLER_DEVICE_PATH *Controller; 363 364 Controller = DevPath; 365 UefiDevicePathLibCatPrint ( 366 Str, 367 "Ctrl(0x%x)", 368 Controller->ControllerNumber 369 ); 370 } 371 372 /** 373 Converts a BMC device path structure to its string representative. 374 375 @param Str The string representative of input device. 376 @param DevPath The input device path structure. 377 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 378 of the display node is used, where applicable. If DisplayOnly 379 is FALSE, then the longer text representation of the display node 380 is used. 381 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 382 representation for a device node can be used, where applicable. 383 384 **/ 385 static VOID 386 DevPathToTextBmc ( 387 IN OUT POOL_PRINT *Str, 388 IN VOID *DevPath, 389 IN BOOLEAN DisplayOnly, 390 IN BOOLEAN AllowShortcuts 391 ) 392 { 393 BMC_DEVICE_PATH *Bmc; 394 395 Bmc = DevPath; 396 UefiDevicePathLibCatPrint ( 397 Str, 398 "BMC(0x%x,0x%lx)", 399 Bmc->InterfaceType, 400 ReadUnaligned64 ((&Bmc->BaseAddress)) 401 ); 402 } 403 404 /** 405 Converts a ACPI device path structure to its string representative. 406 407 @param Str The string representative of input device. 408 @param DevPath The input device path structure. 409 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 410 of the display node is used, where applicable. If DisplayOnly 411 is FALSE, then the longer text representation of the display node 412 is used. 413 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 414 representation for a device node can be used, where applicable. 415 416 **/ 417 static VOID 418 DevPathToTextAcpi ( 419 IN OUT POOL_PRINT *Str, 420 IN VOID *DevPath, 421 IN BOOLEAN DisplayOnly, 422 IN BOOLEAN AllowShortcuts 423 ) 424 { 425 ACPI_HID_DEVICE_PATH *Acpi; 426 427 Acpi = DevPath; 428 if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) { 429 switch (EISA_ID_TO_NUM (Acpi->HID)) { 430 case 0x0a03: 431 UefiDevicePathLibCatPrint (Str, "PciRoot(0x%x)", Acpi->UID); 432 break; 433 434 case 0x0a08: 435 UefiDevicePathLibCatPrint (Str, "PcieRoot(0x%x)", Acpi->UID); 436 break; 437 438 case 0x0604: 439 UefiDevicePathLibCatPrint (Str, "Floppy(0x%x)", Acpi->UID); 440 break; 441 442 case 0x0301: 443 UefiDevicePathLibCatPrint (Str, "Keyboard(0x%x)", Acpi->UID); 444 break; 445 446 case 0x0501: 447 UefiDevicePathLibCatPrint (Str, "Serial(0x%x)", Acpi->UID); 448 break; 449 450 case 0x0401: 451 UefiDevicePathLibCatPrint (Str, "ParallelPort(0x%x)", Acpi->UID); 452 break; 453 454 default: 455 UefiDevicePathLibCatPrint (Str, "Acpi(PNP%04x,0x%x)", EISA_ID_TO_NUM (Acpi->HID), Acpi->UID); 456 break; 457 } 458 } else { 459 UefiDevicePathLibCatPrint (Str, "Acpi(0x%08x,0x%x)", Acpi->HID, Acpi->UID); 460 } 461 } 462 463 /** 464 Converts a ACPI extended HID device path structure to its string representative. 465 466 @param Str The string representative of input device. 467 @param DevPath The input device path structure. 468 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 469 of the display node is used, where applicable. If DisplayOnly 470 is FALSE, then the longer text representation of the display node 471 is used. 472 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 473 representation for a device node can be used, where applicable. 474 475 **/ 476 static VOID 477 DevPathToTextAcpiEx ( 478 IN OUT POOL_PRINT *Str, 479 IN VOID *DevPath, 480 IN BOOLEAN DisplayOnly, 481 IN BOOLEAN AllowShortcuts 482 ) 483 { 484 ACPI_EXTENDED_HID_DEVICE_PATH *AcpiEx; 485 CHAR8 *HIDStr; 486 CHAR8 *UIDStr; 487 CHAR8 *CIDStr; 488 char HIDText[11]; 489 char CIDText[11]; 490 491 AcpiEx = DevPath; 492 HIDStr = (CHAR8 *) (((UINT8 *) AcpiEx) + sizeof (ACPI_EXTENDED_HID_DEVICE_PATH)); 493 UIDStr = HIDStr + AsciiStrLen (HIDStr) + 1; 494 CIDStr = UIDStr + AsciiStrLen (UIDStr) + 1; 495 496 // 497 // Converts EISA identification to string. 498 // 499 UnicodeSPrint ( 500 HIDText, 501 sizeof (HIDText), 502 "%c%c%c%04X", 503 ((AcpiEx->HID >> 10) & 0x1f) + 'A' - 1, 504 ((AcpiEx->HID >> 5) & 0x1f) + 'A' - 1, 505 ((AcpiEx->HID >> 0) & 0x1f) + 'A' - 1, 506 (AcpiEx->HID >> 16) & 0xFFFF 507 ); 508 UnicodeSPrint ( 509 CIDText, 510 sizeof (CIDText), 511 "%c%c%c%04X", 512 ((AcpiEx->CID >> 10) & 0x1f) + 'A' - 1, 513 ((AcpiEx->CID >> 5) & 0x1f) + 'A' - 1, 514 ((AcpiEx->CID >> 0) & 0x1f) + 'A' - 1, 515 (AcpiEx->CID >> 16) & 0xFFFF 516 ); 517 518 if ((*HIDStr == '\0') && (*CIDStr == '\0') && (AcpiEx->UID == 0)) { 519 // 520 // use AcpiExp() 521 // 522 UefiDevicePathLibCatPrint ( 523 Str, 524 "AcpiExp(%s,%s,%s)", 525 HIDText, 526 CIDText, 527 UIDStr 528 ); 529 } else { 530 if (AllowShortcuts) { 531 // 532 // display only 533 // 534 if (AcpiEx->HID == 0) { 535 UefiDevicePathLibCatPrint (Str, "AcpiEx(%s,", HIDStr); 536 } else { 537 UefiDevicePathLibCatPrint (Str, "AcpiEx(%s,", HIDText); 538 } 539 540 if (AcpiEx->UID == 0) { 541 UefiDevicePathLibCatPrint (Str, "%s,", UIDStr); 542 } else { 543 UefiDevicePathLibCatPrint (Str, "0x%x,", AcpiEx->UID); 544 } 545 546 if (AcpiEx->CID == 0) { 547 UefiDevicePathLibCatPrint (Str, "%s)", CIDStr); 548 } else { 549 UefiDevicePathLibCatPrint (Str, "%s)", CIDText); 550 } 551 } else { 552 UefiDevicePathLibCatPrint ( 553 Str, 554 "AcpiEx(%s,%s,0x%x,%s,%s,%s)", 555 HIDText, 556 CIDText, 557 AcpiEx->UID, 558 HIDStr, 559 CIDStr, 560 UIDStr 561 ); 562 } 563 } 564 } 565 566 /** 567 Converts a ACPI address device path structure to its string representative. 568 569 @param Str The string representative of input device. 570 @param DevPath The input device path structure. 571 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 572 of the display node is used, where applicable. If DisplayOnly 573 is FALSE, then the longer text representation of the display node 574 is used. 575 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 576 representation for a device node can be used, where applicable. 577 578 **/ 579 static VOID 580 DevPathToTextAcpiAdr ( 581 IN OUT POOL_PRINT *Str, 582 IN VOID *DevPath, 583 IN BOOLEAN DisplayOnly, 584 IN BOOLEAN AllowShortcuts 585 ) 586 { 587 ACPI_ADR_DEVICE_PATH *AcpiAdr; 588 UINT32 *Addr; 589 UINT16 Index; 590 UINT16 Length; 591 UINT16 AdditionalAdrCount; 592 593 AcpiAdr = DevPath; 594 Length = (UINT16) DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) AcpiAdr); 595 AdditionalAdrCount = (UINT16) ((Length - 8) / 4); 596 597 UefiDevicePathLibCatPrint (Str, "AcpiAdr(0x%x", AcpiAdr->ADR); 598 Addr = &AcpiAdr->ADR + 1; 599 for (Index = 0; Index < AdditionalAdrCount; Index++) { 600 UefiDevicePathLibCatPrint (Str, ",0x%x", Addr[Index]); 601 } 602 UefiDevicePathLibCatPrint (Str, ")"); 603 } 604 605 /** 606 Converts a ATAPI device path structure to its string representative. 607 608 @param Str The string representative of input device. 609 @param DevPath The input device path structure. 610 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 611 of the display node is used, where applicable. If DisplayOnly 612 is FALSE, then the longer text representation of the display node 613 is used. 614 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 615 representation for a device node can be used, where applicable. 616 617 **/ 618 static VOID 619 DevPathToTextAtapi ( 620 IN OUT POOL_PRINT *Str, 621 IN VOID *DevPath, 622 IN BOOLEAN DisplayOnly, 623 IN BOOLEAN AllowShortcuts 624 ) 625 { 626 ATAPI_DEVICE_PATH *Atapi; 627 628 Atapi = DevPath; 629 630 if (DisplayOnly) { 631 UefiDevicePathLibCatPrint (Str, "Ata(0x%x)", Atapi->Lun); 632 } else { 633 UefiDevicePathLibCatPrint ( 634 Str, 635 "Ata(%s,%s,0x%x)", 636 (Atapi->PrimarySecondary == 1) ? "Secondary" : "Primary", 637 (Atapi->SlaveMaster == 1) ? "Slave" : "Master", 638 Atapi->Lun 639 ); 640 } 641 } 642 643 /** 644 Converts a SCSI device path structure to its string representative. 645 646 @param Str The string representative of input device. 647 @param DevPath The input device path structure. 648 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 649 of the display node is used, where applicable. If DisplayOnly 650 is FALSE, then the longer text representation of the display node 651 is used. 652 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 653 representation for a device node can be used, where applicable. 654 655 **/ 656 static VOID 657 DevPathToTextScsi ( 658 IN OUT POOL_PRINT *Str, 659 IN VOID *DevPath, 660 IN BOOLEAN DisplayOnly, 661 IN BOOLEAN AllowShortcuts 662 ) 663 { 664 SCSI_DEVICE_PATH *Scsi; 665 666 Scsi = DevPath; 667 UefiDevicePathLibCatPrint (Str, "Scsi(0x%x,0x%x)", Scsi->Pun, Scsi->Lun); 668 } 669 670 /** 671 Converts a Fibre device path structure to its string representative. 672 673 @param Str The string representative of input device. 674 @param DevPath The input device path structure. 675 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 676 of the display node is used, where applicable. If DisplayOnly 677 is FALSE, then the longer text representation of the display node 678 is used. 679 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 680 representation for a device node can be used, where applicable. 681 682 **/ 683 static VOID 684 DevPathToTextFibre ( 685 IN OUT POOL_PRINT *Str, 686 IN VOID *DevPath, 687 IN BOOLEAN DisplayOnly, 688 IN BOOLEAN AllowShortcuts 689 ) 690 { 691 FIBRECHANNEL_DEVICE_PATH *Fibre; 692 693 Fibre = DevPath; 694 UefiDevicePathLibCatPrint (Str, "Fibre(0x%lx,0x%lx)", Fibre->WWN, Fibre->Lun); 695 } 696 697 /** 698 Converts a FibreEx device path structure to its string representative. 699 700 @param Str The string representative of input device. 701 @param DevPath The input device path structure. 702 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 703 of the display node is used, where applicable. If DisplayOnly 704 is FALSE, then the longer text representation of the display node 705 is used. 706 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 707 representation for a device node can be used, where applicable. 708 709 **/ 710 static VOID 711 DevPathToTextFibreEx ( 712 IN OUT POOL_PRINT *Str, 713 IN VOID *DevPath, 714 IN BOOLEAN DisplayOnly, 715 IN BOOLEAN AllowShortcuts 716 ) 717 { 718 FIBRECHANNELEX_DEVICE_PATH *FibreEx; 719 UINTN Index; 720 721 FibreEx = DevPath; 722 UefiDevicePathLibCatPrint (Str, "FibreEx(0x"); 723 for (Index = 0; Index < sizeof (FibreEx->WWN) / sizeof (FibreEx->WWN[0]); Index++) { 724 UefiDevicePathLibCatPrint (Str, "%02x", FibreEx->WWN[Index]); 725 } 726 UefiDevicePathLibCatPrint (Str, ",0x"); 727 for (Index = 0; Index < sizeof (FibreEx->Lun) / sizeof (FibreEx->Lun[0]); Index++) { 728 UefiDevicePathLibCatPrint (Str, "%02x", FibreEx->Lun[Index]); 729 } 730 UefiDevicePathLibCatPrint (Str, ")"); 731 } 732 733 /** 734 Converts a Sas Ex device path structure to its string representative. 735 736 @param Str The string representative of input device. 737 @param DevPath The input device path structure. 738 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 739 of the display node is used, where applicable. If DisplayOnly 740 is FALSE, then the longer text representation of the display node 741 is used. 742 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 743 representation for a device node can be used, where applicable. 744 745 **/ 746 static VOID 747 DevPathToTextSasEx ( 748 IN OUT POOL_PRINT *Str, 749 IN VOID *DevPath, 750 IN BOOLEAN DisplayOnly, 751 IN BOOLEAN AllowShortcuts 752 ) 753 { 754 SASEX_DEVICE_PATH *SasEx; 755 UINTN Index; 756 757 SasEx = DevPath; 758 UefiDevicePathLibCatPrint (Str, "SasEx(0x"); 759 760 for (Index = 0; Index < sizeof (SasEx->SasAddress) / sizeof (SasEx->SasAddress[0]); Index++) { 761 UefiDevicePathLibCatPrint (Str, "%02x", SasEx->SasAddress[Index]); 762 } 763 UefiDevicePathLibCatPrint (Str, ",0x"); 764 for (Index = 0; Index < sizeof (SasEx->Lun) / sizeof (SasEx->Lun[0]); Index++) { 765 UefiDevicePathLibCatPrint (Str, "%02x", SasEx->Lun[Index]); 766 } 767 UefiDevicePathLibCatPrint (Str, ",0x%x,", SasEx->RelativeTargetPort); 768 769 if (((SasEx->DeviceTopology & 0x0f) == 0) && ((SasEx->DeviceTopology & BIT7) == 0)) { 770 UefiDevicePathLibCatPrint (Str, "NoTopology,0,0,0"); 771 } else if (((SasEx->DeviceTopology & 0x0f) <= 2) && ((SasEx->DeviceTopology & BIT7) == 0)) { 772 UefiDevicePathLibCatPrint ( 773 Str, 774 "%s,%s,%s,", 775 ((SasEx->DeviceTopology & BIT4) != 0) ? "SATA" : "SAS", 776 ((SasEx->DeviceTopology & BIT5) != 0) ? "External" : "Internal", 777 ((SasEx->DeviceTopology & BIT6) != 0) ? "Expanded" : "Direct" 778 ); 779 if ((SasEx->DeviceTopology & 0x0f) == 1) { 780 UefiDevicePathLibCatPrint (Str, "0"); 781 } else { 782 // 783 // Value 0x0 thru 0xFF -> Drive 1 thru Drive 256 784 // 785 UefiDevicePathLibCatPrint (Str, "0x%x", ((SasEx->DeviceTopology >> 8) & 0xff) + 1); 786 } 787 } else { 788 UefiDevicePathLibCatPrint (Str, "0x%x,0,0,0", SasEx->DeviceTopology); 789 } 790 791 UefiDevicePathLibCatPrint (Str, ")"); 792 return ; 793 794 } 795 796 /** 797 Converts a NVM Express Namespace device path structure to its string representative. 798 799 @param Str The string representative of input device. 800 @param DevPath The input device path structure. 801 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 802 of the display node is used, where applicable. If DisplayOnly 803 is FALSE, then the longer text representation of the display node 804 is used. 805 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 806 representation for a device node can be used, where applicable. 807 808 **/ 809 static VOID 810 DevPathToTextNVMe ( 811 IN OUT POOL_PRINT *Str, 812 IN VOID *DevPath, 813 IN BOOLEAN DisplayOnly, 814 IN BOOLEAN AllowShortcuts 815 ) 816 { 817 NVME_NAMESPACE_DEVICE_PATH *Nvme; 818 UINT8 *Uuid; 819 820 Nvme = DevPath; 821 Uuid = (UINT8 *) &Nvme->NamespaceUuid; 822 UefiDevicePathLibCatPrint ( 823 Str, 824 "NVMe(0x%x,%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x)", 825 Nvme->NamespaceId, 826 Uuid[7], Uuid[6], Uuid[5], Uuid[4], 827 Uuid[3], Uuid[2], Uuid[1], Uuid[0] 828 ); 829 } 830 831 /** 832 Converts a UFS device path structure to its string representative. 833 834 @param Str The string representative of input device. 835 @param DevPath The input device path structure. 836 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 837 of the display node is used, where applicable. If DisplayOnly 838 is FALSE, then the longer text representation of the display node 839 is used. 840 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 841 representation for a device node can be used, where applicable. 842 843 **/ 844 static VOID 845 DevPathToTextUfs ( 846 IN OUT POOL_PRINT *Str, 847 IN VOID *DevPath, 848 IN BOOLEAN DisplayOnly, 849 IN BOOLEAN AllowShortcuts 850 ) 851 { 852 UFS_DEVICE_PATH *Ufs; 853 854 Ufs = DevPath; 855 UefiDevicePathLibCatPrint (Str, "UFS(0x%x,0x%x)", Ufs->Pun, Ufs->Lun); 856 } 857 858 /** 859 Converts a SD (Secure Digital) device path structure to its string representative. 860 861 @param Str The string representative of input device. 862 @param DevPath The input device path structure. 863 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 864 of the display node is used, where applicable. If DisplayOnly 865 is FALSE, then the longer text representation of the display node 866 is used. 867 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 868 representation for a device node can be used, where applicable. 869 870 **/ 871 static VOID 872 DevPathToTextSd ( 873 IN OUT POOL_PRINT *Str, 874 IN VOID *DevPath, 875 IN BOOLEAN DisplayOnly, 876 IN BOOLEAN AllowShortcuts 877 ) 878 { 879 SD_DEVICE_PATH *Sd; 880 881 Sd = DevPath; 882 UefiDevicePathLibCatPrint ( 883 Str, 884 "SD(0x%x)", 885 Sd->SlotNumber 886 ); 887 } 888 889 /** 890 Converts a EMMC (Embedded MMC) device path structure to its string representative. 891 892 @param Str The string representative of input device. 893 @param DevPath The input device path structure. 894 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 895 of the display node is used, where applicable. If DisplayOnly 896 is FALSE, then the longer text representation of the display node 897 is used. 898 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 899 representation for a device node can be used, where applicable. 900 901 **/ 902 static VOID 903 DevPathToTextEmmc ( 904 IN OUT POOL_PRINT *Str, 905 IN VOID *DevPath, 906 IN BOOLEAN DisplayOnly, 907 IN BOOLEAN AllowShortcuts 908 ) 909 { 910 EMMC_DEVICE_PATH *Emmc; 911 912 Emmc = DevPath; 913 UefiDevicePathLibCatPrint ( 914 Str, 915 "eMMC(0x%x)", 916 Emmc->SlotNumber 917 ); 918 } 919 920 /** 921 Converts a 1394 device path structure to its string representative. 922 923 @param Str The string representative of input device. 924 @param DevPath The input device path structure. 925 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 926 of the display node is used, where applicable. If DisplayOnly 927 is FALSE, then the longer text representation of the display node 928 is used. 929 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 930 representation for a device node can be used, where applicable. 931 932 **/ 933 static VOID 934 DevPathToText1394 ( 935 IN OUT POOL_PRINT *Str, 936 IN VOID *DevPath, 937 IN BOOLEAN DisplayOnly, 938 IN BOOLEAN AllowShortcuts 939 ) 940 { 941 F1394_DEVICE_PATH *F1394DevPath; 942 943 F1394DevPath = DevPath; 944 // 945 // Guid has format of IEEE-EUI64 946 // 947 UefiDevicePathLibCatPrint (Str, "I1394(%016lx)", F1394DevPath->Guid); 948 } 949 950 /** 951 Converts a USB device path structure to its string representative. 952 953 @param Str The string representative of input device. 954 @param DevPath The input device path structure. 955 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 956 of the display node is used, where applicable. If DisplayOnly 957 is FALSE, then the longer text representation of the display node 958 is used. 959 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 960 representation for a device node can be used, where applicable. 961 962 **/ 963 static VOID 964 DevPathToTextUsb ( 965 IN OUT POOL_PRINT *Str, 966 IN VOID *DevPath, 967 IN BOOLEAN DisplayOnly, 968 IN BOOLEAN AllowShortcuts 969 ) 970 { 971 USB_DEVICE_PATH *Usb; 972 973 Usb = DevPath; 974 UefiDevicePathLibCatPrint (Str, "USB(0x%x,0x%x)", Usb->ParentPortNumber, Usb->InterfaceNumber); 975 } 976 977 /** 978 Converts a USB WWID device path structure to its string representative. 979 980 @param Str The string representative of input device. 981 @param DevPath The input device path structure. 982 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 983 of the display node is used, where applicable. If DisplayOnly 984 is FALSE, then the longer text representation of the display node 985 is used. 986 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 987 representation for a device node can be used, where applicable. 988 989 **/ 990 static VOID 991 DevPathToTextUsbWWID ( 992 IN OUT POOL_PRINT *Str, 993 IN VOID *DevPath, 994 IN BOOLEAN DisplayOnly, 995 IN BOOLEAN AllowShortcuts 996 ) 997 { 998 USB_WWID_DEVICE_PATH *UsbWWId; 999 CHAR16 *SerialNumberStr; 1000 CHAR16 *NewStr; 1001 UINT16 Length; 1002 1003 UsbWWId = DevPath; 1004 1005 SerialNumberStr = (CHAR16 *) (&UsbWWId + 1); 1006 Length = (UINT16) ((DevicePathNodeLength ((EFI_DEVICE_PATH_PROTOCOL *) UsbWWId) - sizeof (USB_WWID_DEVICE_PATH)) / sizeof (CHAR16)); 1007 if (SerialNumberStr [Length - 1] != 0) { 1008 // 1009 // In case no NULL terminator in SerialNumber, create a new one with NULL terminator 1010 // 1011 NewStr = AllocateCopyPool ((Length + 1) * sizeof (CHAR16), SerialNumberStr); 1012 ASSERT (NewStr != NULL); 1013 NewStr [Length] = 0; 1014 SerialNumberStr = NewStr; 1015 } 1016 1017 UefiDevicePathLibCatPrint ( 1018 Str, 1019 "UsbWwid(0x%x,0x%x,0x%x,\"%S\")", 1020 UsbWWId->VendorId, 1021 UsbWWId->ProductId, 1022 UsbWWId->InterfaceNumber, 1023 SerialNumberStr 1024 ); 1025 } 1026 1027 /** 1028 Converts a Logic Unit device path structure to its string representative. 1029 1030 @param Str The string representative of input device. 1031 @param DevPath The input device path structure. 1032 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1033 of the display node is used, where applicable. If DisplayOnly 1034 is FALSE, then the longer text representation of the display node 1035 is used. 1036 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1037 representation for a device node can be used, where applicable. 1038 1039 **/ 1040 static VOID 1041 DevPathToTextLogicalUnit ( 1042 IN OUT POOL_PRINT *Str, 1043 IN VOID *DevPath, 1044 IN BOOLEAN DisplayOnly, 1045 IN BOOLEAN AllowShortcuts 1046 ) 1047 { 1048 DEVICE_LOGICAL_UNIT_DEVICE_PATH *LogicalUnit; 1049 1050 LogicalUnit = DevPath; 1051 UefiDevicePathLibCatPrint (Str, "Unit(0x%x)", LogicalUnit->Lun); 1052 } 1053 1054 /** 1055 Converts a USB class device path structure to its string representative. 1056 1057 @param Str The string representative of input device. 1058 @param DevPath The input device path structure. 1059 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1060 of the display node is used, where applicable. If DisplayOnly 1061 is FALSE, then the longer text representation of the display node 1062 is used. 1063 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1064 representation for a device node can be used, where applicable. 1065 1066 **/ 1067 static VOID 1068 DevPathToTextUsbClass ( 1069 IN OUT POOL_PRINT *Str, 1070 IN VOID *DevPath, 1071 IN BOOLEAN DisplayOnly, 1072 IN BOOLEAN AllowShortcuts 1073 ) 1074 { 1075 USB_CLASS_DEVICE_PATH *UsbClass; 1076 BOOLEAN IsKnownSubClass; 1077 1078 1079 UsbClass = DevPath; 1080 1081 IsKnownSubClass = TRUE; 1082 switch (UsbClass->DeviceClass) { 1083 case USB_CLASS_AUDIO: 1084 UefiDevicePathLibCatPrint (Str, "UsbAudio"); 1085 break; 1086 1087 case USB_CLASS_CDCCONTROL: 1088 UefiDevicePathLibCatPrint (Str, "UsbCDCControl"); 1089 break; 1090 1091 case USB_CLASS_HID: 1092 UefiDevicePathLibCatPrint (Str, "UsbHID"); 1093 break; 1094 1095 case USB_CLASS_IMAGE: 1096 UefiDevicePathLibCatPrint (Str, "UsbImage"); 1097 break; 1098 1099 case USB_CLASS_PRINTER: 1100 UefiDevicePathLibCatPrint (Str, "UsbPrinter"); 1101 break; 1102 1103 case USB_CLASS_MASS_STORAGE: 1104 UefiDevicePathLibCatPrint (Str, "UsbMassStorage"); 1105 break; 1106 1107 case USB_CLASS_HUB: 1108 UefiDevicePathLibCatPrint (Str, "UsbHub"); 1109 break; 1110 1111 case USB_CLASS_CDCDATA: 1112 UefiDevicePathLibCatPrint (Str, "UsbCDCData"); 1113 break; 1114 1115 case USB_CLASS_SMART_CARD: 1116 UefiDevicePathLibCatPrint (Str, "UsbSmartCard"); 1117 break; 1118 1119 case USB_CLASS_VIDEO: 1120 UefiDevicePathLibCatPrint (Str, "UsbVideo"); 1121 break; 1122 1123 case USB_CLASS_DIAGNOSTIC: 1124 UefiDevicePathLibCatPrint (Str, "UsbDiagnostic"); 1125 break; 1126 1127 case USB_CLASS_WIRELESS: 1128 UefiDevicePathLibCatPrint (Str, "UsbWireless"); 1129 break; 1130 1131 default: 1132 IsKnownSubClass = FALSE; 1133 break; 1134 } 1135 1136 if (IsKnownSubClass) { 1137 UefiDevicePathLibCatPrint ( 1138 Str, 1139 "(0x%x,0x%x,0x%x,0x%x)", 1140 UsbClass->VendorId, 1141 UsbClass->ProductId, 1142 UsbClass->DeviceSubClass, 1143 UsbClass->DeviceProtocol 1144 ); 1145 return; 1146 } 1147 1148 if (UsbClass->DeviceClass == USB_CLASS_RESERVE) { 1149 if (UsbClass->DeviceSubClass == USB_SUBCLASS_FW_UPDATE) { 1150 UefiDevicePathLibCatPrint ( 1151 Str, 1152 "UsbDeviceFirmwareUpdate(0x%x,0x%x,0x%x)", 1153 UsbClass->VendorId, 1154 UsbClass->ProductId, 1155 UsbClass->DeviceProtocol 1156 ); 1157 return; 1158 } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_IRDA_BRIDGE) { 1159 UefiDevicePathLibCatPrint ( 1160 Str, 1161 "UsbIrdaBridge(0x%x,0x%x,0x%x)", 1162 UsbClass->VendorId, 1163 UsbClass->ProductId, 1164 UsbClass->DeviceProtocol 1165 ); 1166 return; 1167 } else if (UsbClass->DeviceSubClass == USB_SUBCLASS_TEST) { 1168 UefiDevicePathLibCatPrint ( 1169 Str, 1170 "UsbTestAndMeasurement(0x%x,0x%x,0x%x)", 1171 UsbClass->VendorId, 1172 UsbClass->ProductId, 1173 UsbClass->DeviceProtocol 1174 ); 1175 return; 1176 } 1177 } 1178 1179 UefiDevicePathLibCatPrint ( 1180 Str, 1181 "UsbClass(0x%x,0x%x,0x%x,0x%x,0x%x)", 1182 UsbClass->VendorId, 1183 UsbClass->ProductId, 1184 UsbClass->DeviceClass, 1185 UsbClass->DeviceSubClass, 1186 UsbClass->DeviceProtocol 1187 ); 1188 } 1189 1190 /** 1191 Converts a SATA device path structure to its string representative. 1192 1193 @param Str The string representative of input device. 1194 @param DevPath The input device path structure. 1195 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1196 of the display node is used, where applicable. If DisplayOnly 1197 is FALSE, then the longer text representation of the display node 1198 is used. 1199 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1200 representation for a device node can be used, where applicable. 1201 1202 **/ 1203 static VOID 1204 DevPathToTextSata ( 1205 IN OUT POOL_PRINT *Str, 1206 IN VOID *DevPath, 1207 IN BOOLEAN DisplayOnly, 1208 IN BOOLEAN AllowShortcuts 1209 ) 1210 { 1211 SATA_DEVICE_PATH *Sata; 1212 1213 Sata = DevPath; 1214 UefiDevicePathLibCatPrint ( 1215 Str, 1216 "Sata(0x%x,0x%x,0x%x)", 1217 Sata->HBAPortNumber, 1218 Sata->PortMultiplierPortNumber, 1219 Sata->Lun 1220 ); 1221 } 1222 1223 /** 1224 Converts a I20 device path structure to its string representative. 1225 1226 @param Str The string representative of input device. 1227 @param DevPath The input device path structure. 1228 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1229 of the display node is used, where applicable. If DisplayOnly 1230 is FALSE, then the longer text representation of the display node 1231 is used. 1232 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1233 representation for a device node can be used, where applicable. 1234 1235 **/ 1236 static VOID 1237 DevPathToTextI2O ( 1238 IN OUT POOL_PRINT *Str, 1239 IN VOID *DevPath, 1240 IN BOOLEAN DisplayOnly, 1241 IN BOOLEAN AllowShortcuts 1242 ) 1243 { 1244 I2O_DEVICE_PATH *I2ODevPath; 1245 1246 I2ODevPath = DevPath; 1247 UefiDevicePathLibCatPrint (Str, "I2O(0x%x)", I2ODevPath->Tid); 1248 } 1249 1250 /** 1251 Converts a MAC address device path structure to its string representative. 1252 1253 @param Str The string representative of input device. 1254 @param DevPath The input device path structure. 1255 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1256 of the display node is used, where applicable. If DisplayOnly 1257 is FALSE, then the longer text representation of the display node 1258 is used. 1259 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1260 representation for a device node can be used, where applicable. 1261 1262 **/ 1263 static VOID 1264 DevPathToTextMacAddr ( 1265 IN OUT POOL_PRINT *Str, 1266 IN VOID *DevPath, 1267 IN BOOLEAN DisplayOnly, 1268 IN BOOLEAN AllowShortcuts 1269 ) 1270 { 1271 MAC_ADDR_DEVICE_PATH *MacDevPath; 1272 UINTN HwAddressSize; 1273 UINTN Index; 1274 1275 MacDevPath = DevPath; 1276 1277 HwAddressSize = sizeof (EFI_MAC_ADDRESS); 1278 if (MacDevPath->IfType == 0x01 || MacDevPath->IfType == 0x00) { 1279 HwAddressSize = 6; 1280 } 1281 1282 UefiDevicePathLibCatPrint (Str, "MAC("); 1283 1284 for (Index = 0; Index < HwAddressSize; Index++) { 1285 UefiDevicePathLibCatPrint (Str, "%02x", MacDevPath->MacAddress.Addr[Index]); 1286 } 1287 1288 UefiDevicePathLibCatPrint (Str, ",0x%x)", MacDevPath->IfType); 1289 } 1290 1291 /** 1292 Converts network protocol string to its text representation. 1293 1294 @param Str The string representative of input device. 1295 @param Protocol The network protocol ID. 1296 1297 **/ 1298 static VOID 1299 CatNetworkProtocol ( 1300 IN OUT POOL_PRINT *Str, 1301 IN UINT16 Protocol 1302 ) 1303 { 1304 if (Protocol == RFC_1700_TCP_PROTOCOL) { 1305 UefiDevicePathLibCatPrint (Str, "TCP"); 1306 } else if (Protocol == RFC_1700_UDP_PROTOCOL) { 1307 UefiDevicePathLibCatPrint (Str, "UDP"); 1308 } else { 1309 UefiDevicePathLibCatPrint (Str, "0x%x", Protocol); 1310 } 1311 } 1312 1313 /** 1314 Converts IP v4 address to its text representation. 1315 1316 @param Str The string representative of input device. 1317 @param Address The IP v4 address. 1318 **/ 1319 static VOID 1320 CatIPv4Address ( 1321 IN OUT POOL_PRINT *Str, 1322 IN EFI_IPv4_ADDRESS *Address 1323 ) 1324 { 1325 UefiDevicePathLibCatPrint (Str, "%d.%d.%d.%d", Address->Addr[0], Address->Addr[1], Address->Addr[2], Address->Addr[3]); 1326 } 1327 1328 /** 1329 Converts IP v6 address to its text representation. 1330 1331 @param Str The string representative of input device. 1332 @param Address The IP v6 address. 1333 **/ 1334 static VOID 1335 CatIPv6Address ( 1336 IN OUT POOL_PRINT *Str, 1337 IN EFI_IPv6_ADDRESS *Address 1338 ) 1339 { 1340 UefiDevicePathLibCatPrint ( 1341 Str, "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x", 1342 Address->Addr[0], Address->Addr[1], 1343 Address->Addr[2], Address->Addr[3], 1344 Address->Addr[4], Address->Addr[5], 1345 Address->Addr[6], Address->Addr[7], 1346 Address->Addr[8], Address->Addr[9], 1347 Address->Addr[10], Address->Addr[11], 1348 Address->Addr[12], Address->Addr[13], 1349 Address->Addr[14], Address->Addr[15] 1350 ); 1351 } 1352 1353 /** 1354 Converts a IPv4 device path structure to its string representative. 1355 1356 @param Str The string representative of input device. 1357 @param DevPath The input device path structure. 1358 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1359 of the display node is used, where applicable. If DisplayOnly 1360 is FALSE, then the longer text representation of the display node 1361 is used. 1362 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1363 representation for a device node can be used, where applicable. 1364 1365 **/ 1366 static VOID 1367 DevPathToTextIPv4 ( 1368 IN OUT POOL_PRINT *Str, 1369 IN VOID *DevPath, 1370 IN BOOLEAN DisplayOnly, 1371 IN BOOLEAN AllowShortcuts 1372 ) 1373 { 1374 IPv4_DEVICE_PATH *IPDevPath; 1375 1376 IPDevPath = DevPath; 1377 UefiDevicePathLibCatPrint (Str, "IPv4("); 1378 CatIPv4Address (Str, &IPDevPath->RemoteIpAddress); 1379 1380 if (DisplayOnly) { 1381 UefiDevicePathLibCatPrint (Str, ")"); 1382 return ; 1383 } 1384 1385 UefiDevicePathLibCatPrint (Str, ","); 1386 CatNetworkProtocol (Str, IPDevPath->Protocol); 1387 1388 UefiDevicePathLibCatPrint (Str, ",%s,", IPDevPath->StaticIpAddress ? "Static" : "DHCP"); 1389 CatIPv4Address (Str, &IPDevPath->LocalIpAddress); 1390 if (DevicePathNodeLength (IPDevPath) == sizeof (IPv4_DEVICE_PATH)) { 1391 UefiDevicePathLibCatPrint (Str, ","); 1392 CatIPv4Address (Str, &IPDevPath->GatewayIpAddress); 1393 UefiDevicePathLibCatPrint (Str, ","); 1394 CatIPv4Address (Str, &IPDevPath->SubnetMask); 1395 } 1396 UefiDevicePathLibCatPrint (Str, ")"); 1397 } 1398 1399 /** 1400 Converts a IPv6 device path structure to its string representative. 1401 1402 @param Str The string representative of input device. 1403 @param DevPath The input device path structure. 1404 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1405 of the display node is used, where applicable. If DisplayOnly 1406 is FALSE, then the longer text representation of the display node 1407 is used. 1408 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1409 representation for a device node can be used, where applicable. 1410 1411 **/ 1412 static VOID 1413 DevPathToTextIPv6 ( 1414 IN OUT POOL_PRINT *Str, 1415 IN VOID *DevPath, 1416 IN BOOLEAN DisplayOnly, 1417 IN BOOLEAN AllowShortcuts 1418 ) 1419 { 1420 IPv6_DEVICE_PATH *IPDevPath; 1421 1422 IPDevPath = DevPath; 1423 UefiDevicePathLibCatPrint (Str, "IPv6("); 1424 CatIPv6Address (Str, &IPDevPath->RemoteIpAddress); 1425 if (DisplayOnly) { 1426 UefiDevicePathLibCatPrint (Str, ")"); 1427 return ; 1428 } 1429 1430 UefiDevicePathLibCatPrint (Str, ","); 1431 CatNetworkProtocol (Str, IPDevPath->Protocol); 1432 1433 switch (IPDevPath->IpAddressOrigin) { 1434 case 0: 1435 UefiDevicePathLibCatPrint (Str, ",Static,"); 1436 break; 1437 case 1: 1438 UefiDevicePathLibCatPrint (Str, ",StatelessAutoConfigure,"); 1439 break; 1440 default: 1441 UefiDevicePathLibCatPrint (Str, ",StatefulAutoConfigure,"); 1442 break; 1443 } 1444 1445 CatIPv6Address (Str, &IPDevPath->LocalIpAddress); 1446 1447 if (DevicePathNodeLength (IPDevPath) == sizeof (IPv6_DEVICE_PATH)) { 1448 UefiDevicePathLibCatPrint (Str, ",0x%x,", IPDevPath->PrefixLength); 1449 CatIPv6Address (Str, &IPDevPath->GatewayIpAddress); 1450 } 1451 UefiDevicePathLibCatPrint (Str, ")"); 1452 } 1453 1454 /** 1455 Converts an Infini Band device path structure to its string representative. 1456 1457 @param Str The string representative of input device. 1458 @param DevPath The input device path structure. 1459 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1460 of the display node is used, where applicable. If DisplayOnly 1461 is FALSE, then the longer text representation of the display node 1462 is used. 1463 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1464 representation for a device node can be used, where applicable. 1465 1466 **/ 1467 static VOID 1468 DevPathToTextInfiniBand ( 1469 IN OUT POOL_PRINT *Str, 1470 IN VOID *DevPath, 1471 IN BOOLEAN DisplayOnly, 1472 IN BOOLEAN AllowShortcuts 1473 ) 1474 { 1475 INFINIBAND_DEVICE_PATH *InfiniBand; 1476 1477 InfiniBand = DevPath; 1478 UefiDevicePathLibCatPrint ( 1479 Str, 1480 "Infiniband(0x%x,%36s,0x%lx,0x%lx,0x%lx)", 1481 InfiniBand->ResourceFlags, 1482 G(InfiniBand->PortGid), 1483 InfiniBand->ServiceId, 1484 InfiniBand->TargetPortId, 1485 InfiniBand->DeviceId 1486 ); 1487 } 1488 1489 /** 1490 Converts a UART device path structure to its string representative. 1491 1492 @param Str The string representative of input device. 1493 @param DevPath The input device path structure. 1494 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1495 of the display node is used, where applicable. If DisplayOnly 1496 is FALSE, then the longer text representation of the display node 1497 is used. 1498 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1499 representation for a device node can be used, where applicable. 1500 1501 **/ 1502 static VOID 1503 DevPathToTextUart ( 1504 IN OUT POOL_PRINT *Str, 1505 IN VOID *DevPath, 1506 IN BOOLEAN DisplayOnly, 1507 IN BOOLEAN AllowShortcuts 1508 ) 1509 { 1510 UART_DEVICE_PATH *Uart; 1511 CHAR8 Parity; 1512 1513 Uart = DevPath; 1514 switch (Uart->Parity) { 1515 case 0: 1516 Parity = 'D'; 1517 break; 1518 1519 case 1: 1520 Parity = 'N'; 1521 break; 1522 1523 case 2: 1524 Parity = 'E'; 1525 break; 1526 1527 case 3: 1528 Parity = 'O'; 1529 break; 1530 1531 case 4: 1532 Parity = 'M'; 1533 break; 1534 1535 case 5: 1536 Parity = 'S'; 1537 break; 1538 1539 default: 1540 Parity = 'x'; 1541 break; 1542 } 1543 1544 if (Uart->BaudRate == 0) { 1545 UefiDevicePathLibCatPrint (Str, "Uart(DEFAULT,"); 1546 } else { 1547 UefiDevicePathLibCatPrint (Str, "Uart(%ld,", Uart->BaudRate); 1548 } 1549 1550 if (Uart->DataBits == 0) { 1551 UefiDevicePathLibCatPrint (Str, "DEFAULT,"); 1552 } else { 1553 UefiDevicePathLibCatPrint (Str, "%d,", Uart->DataBits); 1554 } 1555 1556 UefiDevicePathLibCatPrint (Str, "%c,", Parity); 1557 1558 switch (Uart->StopBits) { 1559 case 0: 1560 UefiDevicePathLibCatPrint (Str, "D)"); 1561 break; 1562 1563 case 1: 1564 UefiDevicePathLibCatPrint (Str, "1)"); 1565 break; 1566 1567 case 2: 1568 UefiDevicePathLibCatPrint (Str, "1.5)"); 1569 break; 1570 1571 case 3: 1572 UefiDevicePathLibCatPrint (Str, "2)"); 1573 break; 1574 1575 default: 1576 UefiDevicePathLibCatPrint (Str, "x)"); 1577 break; 1578 } 1579 } 1580 1581 /** 1582 Converts an iSCSI device path structure to its string representative. 1583 1584 @param Str The string representative of input device. 1585 @param DevPath The input device path structure. 1586 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1587 of the display node is used, where applicable. If DisplayOnly 1588 is FALSE, then the longer text representation of the display node 1589 is used. 1590 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1591 representation for a device node can be used, where applicable. 1592 1593 **/ 1594 static VOID 1595 DevPathToTextiSCSI ( 1596 IN OUT POOL_PRINT *Str, 1597 IN VOID *DevPath, 1598 IN BOOLEAN DisplayOnly, 1599 IN BOOLEAN AllowShortcuts 1600 ) 1601 { 1602 ISCSI_DEVICE_PATH_WITH_NAME *ISCSIDevPath; 1603 UINT16 Options; 1604 1605 ISCSIDevPath = DevPath; 1606 UefiDevicePathLibCatPrint ( 1607 Str, 1608 "iSCSI(%s,0x%x,0x%lx,", 1609 ISCSIDevPath->TargetName, 1610 ISCSIDevPath->TargetPortalGroupTag, 1611 ISCSIDevPath->Lun 1612 ); 1613 1614 Options = ISCSIDevPath->LoginOption; 1615 UefiDevicePathLibCatPrint (Str, "%s,", (((Options >> 1) & 0x0001) != 0) ? "CRC32C" : "None"); 1616 UefiDevicePathLibCatPrint (Str, "%s,", (((Options >> 3) & 0x0001) != 0) ? "CRC32C" : "None"); 1617 if (((Options >> 11) & 0x0001) != 0) { 1618 UefiDevicePathLibCatPrint (Str, "%s,", "None"); 1619 } else if (((Options >> 12) & 0x0001) != 0) { 1620 UefiDevicePathLibCatPrint (Str, "%s,", "CHAP_UNI"); 1621 } else { 1622 UefiDevicePathLibCatPrint (Str, "%s,", "CHAP_BI"); 1623 1624 } 1625 1626 UefiDevicePathLibCatPrint (Str, "%s)", (ISCSIDevPath->NetworkProtocol == 0) ? "TCP" : "reserved"); 1627 } 1628 1629 /** 1630 Converts a VLAN device path structure to its string representative. 1631 1632 @param Str The string representative of input device. 1633 @param DevPath The input device path structure. 1634 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1635 of the display node is used, where applicable. If DisplayOnly 1636 is FALSE, then the longer text representation of the display node 1637 is used. 1638 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1639 representation for a device node can be used, where applicable. 1640 1641 **/ 1642 static VOID 1643 DevPathToTextVlan ( 1644 IN OUT POOL_PRINT *Str, 1645 IN VOID *DevPath, 1646 IN BOOLEAN DisplayOnly, 1647 IN BOOLEAN AllowShortcuts 1648 ) 1649 { 1650 VLAN_DEVICE_PATH *Vlan; 1651 1652 Vlan = DevPath; 1653 UefiDevicePathLibCatPrint (Str, "Vlan(%d)", Vlan->VlanId); 1654 } 1655 1656 /** 1657 Converts a Bluetooth device path structure to its string representative. 1658 1659 @param Str The string representative of input device. 1660 @param DevPath The input device path structure. 1661 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1662 of the display node is used, where applicable. If DisplayOnly 1663 is FALSE, then the longer text representation of the display node 1664 is used. 1665 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1666 representation for a device node can be used, where applicable. 1667 1668 **/ 1669 static VOID 1670 DevPathToTextBluetooth ( 1671 IN OUT POOL_PRINT *Str, 1672 IN VOID *DevPath, 1673 IN BOOLEAN DisplayOnly, 1674 IN BOOLEAN AllowShortcuts 1675 ) 1676 { 1677 BLUETOOTH_DEVICE_PATH *Bluetooth; 1678 1679 Bluetooth = DevPath; 1680 UefiDevicePathLibCatPrint ( 1681 Str, 1682 "Bluetooth(%02x%02x%02x%02x%02x%02x)", 1683 Bluetooth->BD_ADDR.Address[5], 1684 Bluetooth->BD_ADDR.Address[4], 1685 Bluetooth->BD_ADDR.Address[3], 1686 Bluetooth->BD_ADDR.Address[2], 1687 Bluetooth->BD_ADDR.Address[1], 1688 Bluetooth->BD_ADDR.Address[0] 1689 ); 1690 } 1691 1692 /** 1693 Converts a Wi-Fi device path structure to its string representative. 1694 1695 @param Str The string representative of input device. 1696 @param DevPath The input device path structure. 1697 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1698 of the display node is used, where applicable. If DisplayOnly 1699 is FALSE, then the longer text representation of the display node 1700 is used. 1701 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1702 representation for a device node can be used, where applicable. 1703 1704 **/ 1705 static VOID 1706 DevPathToTextWiFi ( 1707 IN OUT POOL_PRINT *Str, 1708 IN VOID *DevPath, 1709 IN BOOLEAN DisplayOnly, 1710 IN BOOLEAN AllowShortcuts 1711 ) 1712 { 1713 WIFI_DEVICE_PATH *WiFi; 1714 UINT8 SSId[33]; 1715 1716 WiFi = DevPath; 1717 1718 SSId[32] = '\0'; 1719 CopyMem (SSId, WiFi->SSId, 32); 1720 1721 UefiDevicePathLibCatPrint (Str, "Wi-Fi(%s)", SSId); 1722 } 1723 1724 /** 1725 Converts a URI device path structure to its string representative. 1726 1727 @param Str The string representative of input device. 1728 @param DevPath The input device path structure. 1729 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1730 of the display node is used, where applicable. If DisplayOnly 1731 is FALSE, then the longer text representation of the display node 1732 is used. 1733 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1734 representation for a device node can be used, where applicable. 1735 1736 **/ 1737 static VOID 1738 DevPathToTextUri ( 1739 IN OUT POOL_PRINT *Str, 1740 IN VOID *DevPath, 1741 IN BOOLEAN DisplayOnly, 1742 IN BOOLEAN AllowShortcuts 1743 ) 1744 { 1745 URI_DEVICE_PATH *Uri; 1746 UINTN UriLength; 1747 CHAR8 *UriStr; 1748 1749 // 1750 // Uri in the device path may not be null terminated. 1751 // 1752 Uri = DevPath; 1753 UriLength = DevicePathNodeLength (Uri) - sizeof (URI_DEVICE_PATH); 1754 UriStr = AllocatePool (UriLength + 1); 1755 ASSERT (UriStr != NULL); 1756 1757 CopyMem (UriStr, Uri->Uri, UriLength); 1758 UriStr[UriLength] = '\0'; 1759 UefiDevicePathLibCatPrint (Str, "Uri(%s)", UriStr); 1760 FreePool (UriStr); 1761 } 1762 1763 /** 1764 Converts a Hard drive device path structure to its string representative. 1765 1766 @param Str The string representative of input device. 1767 @param DevPath The input device path structure. 1768 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1769 of the display node is used, where applicable. If DisplayOnly 1770 is FALSE, then the longer text representation of the display node 1771 is used. 1772 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1773 representation for a device node can be used, where applicable. 1774 1775 **/ 1776 static VOID 1777 DevPathToTextHardDrive ( 1778 IN OUT POOL_PRINT *Str, 1779 IN VOID *DevPath, 1780 IN BOOLEAN DisplayOnly, 1781 IN BOOLEAN AllowShortcuts 1782 ) 1783 { 1784 HARDDRIVE_DEVICE_PATH *Hd; 1785 1786 Hd = DevPath; 1787 switch (Hd->SignatureType) { 1788 case SIGNATURE_TYPE_MBR: 1789 UefiDevicePathLibCatPrint ( 1790 Str, 1791 "HD(%d,%s,0x%08x,", 1792 Hd->PartitionNumber, 1793 "MBR", 1794 // *((UINT32 *) (&(Hd->Signature[0]))) 1795 le32dec(&(Hd->Signature[0])) 1796 ); 1797 break; 1798 1799 case SIGNATURE_TYPE_GUID: 1800 UefiDevicePathLibCatPrint ( 1801 Str, 1802 "HD(%d,%s,%36s,", 1803 Hd->PartitionNumber, 1804 "GPT", 1805 G(&(Hd->Signature[0])) 1806 ); 1807 break; 1808 1809 default: 1810 UefiDevicePathLibCatPrint ( 1811 Str, 1812 "HD(%d,%d,0,", 1813 Hd->PartitionNumber, 1814 Hd->SignatureType 1815 ); 1816 break; 1817 } 1818 1819 UefiDevicePathLibCatPrint (Str, "0x%lx,0x%lx)", Hd->PartitionStart, Hd->PartitionSize); 1820 } 1821 1822 /** 1823 Converts a CDROM device path structure to its string representative. 1824 1825 @param Str The string representative of input device. 1826 @param DevPath The input device path structure. 1827 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1828 of the display node is used, where applicable. If DisplayOnly 1829 is FALSE, then the longer text representation of the display node 1830 is used. 1831 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1832 representation for a device node can be used, where applicable. 1833 1834 **/ 1835 static VOID 1836 DevPathToTextCDROM ( 1837 IN OUT POOL_PRINT *Str, 1838 IN VOID *DevPath, 1839 IN BOOLEAN DisplayOnly, 1840 IN BOOLEAN AllowShortcuts 1841 ) 1842 { 1843 CDROM_DEVICE_PATH *Cd; 1844 1845 Cd = DevPath; 1846 if (DisplayOnly) { 1847 UefiDevicePathLibCatPrint (Str, "CDROM(0x%x)", Cd->BootEntry); 1848 return ; 1849 } 1850 1851 UefiDevicePathLibCatPrint (Str, "CDROM(0x%x,0x%lx,0x%lx)", Cd->BootEntry, Cd->PartitionStart, Cd->PartitionSize); 1852 } 1853 1854 /** 1855 Converts a File device path structure to its string representative. 1856 1857 @param Str The string representative of input device. 1858 @param DevPath The input device path structure. 1859 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1860 of the display node is used, where applicable. If DisplayOnly 1861 is FALSE, then the longer text representation of the display node 1862 is used. 1863 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1864 representation for a device node can be used, where applicable. 1865 1866 **/ 1867 static VOID 1868 DevPathToTextFilePath ( 1869 IN OUT POOL_PRINT *Str, 1870 IN VOID *DevPath, 1871 IN BOOLEAN DisplayOnly, 1872 IN BOOLEAN AllowShortcuts 1873 ) 1874 { 1875 FILEPATH_DEVICE_PATH *Fp; 1876 char *name = NULL; 1877 1878 Fp = DevPath; 1879 ucs2_to_utf8(Fp->PathName, &name); 1880 UefiDevicePathLibCatPrint (Str, "File(%s)", name); 1881 free(name); 1882 } 1883 1884 /** 1885 Converts a Media protocol device path structure to its string representative. 1886 1887 @param Str The string representative of input device. 1888 @param DevPath The input device path structure. 1889 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1890 of the display node is used, where applicable. If DisplayOnly 1891 is FALSE, then the longer text representation of the display node 1892 is used. 1893 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1894 representation for a device node can be used, where applicable. 1895 1896 **/ 1897 static VOID 1898 DevPathToTextMediaProtocol ( 1899 IN OUT POOL_PRINT *Str, 1900 IN VOID *DevPath, 1901 IN BOOLEAN DisplayOnly, 1902 IN BOOLEAN AllowShortcuts 1903 ) 1904 { 1905 MEDIA_PROTOCOL_DEVICE_PATH *MediaProt; 1906 1907 MediaProt = DevPath; 1908 UefiDevicePathLibCatPrint (Str, "Media(%36s)", G(&MediaProt->Protocol)); 1909 } 1910 1911 /** 1912 Converts a Firmware Volume device path structure to its string representative. 1913 1914 @param Str The string representative of input device. 1915 @param DevPath The input device path structure. 1916 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1917 of the display node is used, where applicable. If DisplayOnly 1918 is FALSE, then the longer text representation of the display node 1919 is used. 1920 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1921 representation for a device node can be used, where applicable. 1922 1923 **/ 1924 static VOID 1925 DevPathToTextFv ( 1926 IN OUT POOL_PRINT *Str, 1927 IN VOID *DevPath, 1928 IN BOOLEAN DisplayOnly, 1929 IN BOOLEAN AllowShortcuts 1930 ) 1931 { 1932 MEDIA_FW_VOL_DEVICE_PATH *Fv; 1933 1934 Fv = DevPath; 1935 UefiDevicePathLibCatPrint (Str, "Fv(%36s)", G(&Fv->FvName)); 1936 } 1937 1938 /** 1939 Converts a Firmware Volume File device path structure to its string representative. 1940 1941 @param Str The string representative of input device. 1942 @param DevPath The input device path structure. 1943 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1944 of the display node is used, where applicable. If DisplayOnly 1945 is FALSE, then the longer text representation of the display node 1946 is used. 1947 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1948 representation for a device node can be used, where applicable. 1949 1950 **/ 1951 static VOID 1952 DevPathToTextFvFile ( 1953 IN OUT POOL_PRINT *Str, 1954 IN VOID *DevPath, 1955 IN BOOLEAN DisplayOnly, 1956 IN BOOLEAN AllowShortcuts 1957 ) 1958 { 1959 MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFile; 1960 1961 FvFile = DevPath; 1962 UefiDevicePathLibCatPrint (Str, "FvFile(%36s)", G(&FvFile->FvFileName)); 1963 } 1964 1965 /** 1966 Converts a Relative Offset device path structure to its string representative. 1967 1968 @param Str The string representative of input device. 1969 @param DevPath The input device path structure. 1970 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 1971 of the display node is used, where applicable. If DisplayOnly 1972 is FALSE, then the longer text representation of the display node 1973 is used. 1974 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 1975 representation for a device node can be used, where applicable. 1976 1977 **/ 1978 static VOID 1979 DevPathRelativeOffsetRange ( 1980 IN OUT POOL_PRINT *Str, 1981 IN VOID *DevPath, 1982 IN BOOLEAN DisplayOnly, 1983 IN BOOLEAN AllowShortcuts 1984 ) 1985 { 1986 MEDIA_RELATIVE_OFFSET_RANGE_DEVICE_PATH *Offset; 1987 1988 Offset = DevPath; 1989 UefiDevicePathLibCatPrint ( 1990 Str, 1991 "Offset(0x%lx,0x%lx)", 1992 Offset->StartingOffset, 1993 Offset->EndingOffset 1994 ); 1995 } 1996 1997 /** 1998 Converts a Ram Disk device path structure to its string representative. 1999 2000 @param Str The string representative of input device. 2001 @param DevPath The input device path structure. 2002 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 2003 of the display node is used, where applicable. If DisplayOnly 2004 is FALSE, then the longer text representation of the display node 2005 is used. 2006 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 2007 representation for a device node can be used, where applicable. 2008 2009 **/ 2010 static VOID 2011 DevPathToTextRamDisk ( 2012 IN OUT POOL_PRINT *Str, 2013 IN VOID *DevPath, 2014 IN BOOLEAN DisplayOnly, 2015 IN BOOLEAN AllowShortcuts 2016 ) 2017 { 2018 MEDIA_RAM_DISK_DEVICE_PATH *RamDisk; 2019 2020 RamDisk = DevPath; 2021 2022 if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualDiskGuid)) { 2023 UefiDevicePathLibCatPrint ( 2024 Str, 2025 "VirtualDisk(0x%lx,0x%lx,%d)", 2026 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0], 2027 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0], 2028 RamDisk->Instance 2029 ); 2030 } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiVirtualCdGuid)) { 2031 UefiDevicePathLibCatPrint ( 2032 Str, 2033 "VirtualCD(0x%lx,0x%lx,%d)", 2034 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0], 2035 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0], 2036 RamDisk->Instance 2037 ); 2038 } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualDiskGuid)) { 2039 UefiDevicePathLibCatPrint ( 2040 Str, 2041 "PersistentVirtualDisk(0x%lx,0x%lx,%d)", 2042 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0], 2043 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0], 2044 RamDisk->Instance 2045 ); 2046 } else if (CompareGuid (&RamDisk->TypeGuid, &gEfiPersistentVirtualCdGuid)) { 2047 UefiDevicePathLibCatPrint ( 2048 Str, 2049 "PersistentVirtualCD(0x%lx,0x%lx,%d)", 2050 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0], 2051 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0], 2052 RamDisk->Instance 2053 ); 2054 } else { 2055 UefiDevicePathLibCatPrint ( 2056 Str, 2057 "RamDisk(0x%lx,0x%lx,%d,%36s)", 2058 LShiftU64 ((UINT64)RamDisk->StartingAddr[1], 32) | RamDisk->StartingAddr[0], 2059 LShiftU64 ((UINT64)RamDisk->EndingAddr[1], 32) | RamDisk->EndingAddr[0], 2060 RamDisk->Instance, 2061 G(&RamDisk->TypeGuid) 2062 ); 2063 } 2064 } 2065 2066 /** 2067 Converts a BIOS Boot Specification device path structure to its string representative. 2068 2069 @param Str The string representative of input device. 2070 @param DevPath The input device path structure. 2071 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 2072 of the display node is used, where applicable. If DisplayOnly 2073 is FALSE, then the longer text representation of the display node 2074 is used. 2075 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 2076 representation for a device node can be used, where applicable. 2077 2078 **/ 2079 static VOID 2080 DevPathToTextBBS ( 2081 IN OUT POOL_PRINT *Str, 2082 IN VOID *DevPath, 2083 IN BOOLEAN DisplayOnly, 2084 IN BOOLEAN AllowShortcuts 2085 ) 2086 { 2087 BBS_BBS_DEVICE_PATH *Bbs; 2088 const char *Type; 2089 2090 Bbs = DevPath; 2091 switch (Bbs->DeviceType) { 2092 case BBS_TYPE_FLOPPY: 2093 Type = "Floppy"; 2094 break; 2095 2096 case BBS_TYPE_HARDDRIVE: 2097 Type = "HD"; 2098 break; 2099 2100 case BBS_TYPE_CDROM: 2101 Type = "CDROM"; 2102 break; 2103 2104 case BBS_TYPE_PCMCIA: 2105 Type = "PCMCIA"; 2106 break; 2107 2108 case BBS_TYPE_USB: 2109 Type = "USB"; 2110 break; 2111 2112 case BBS_TYPE_EMBEDDED_NETWORK: 2113 Type = "Network"; 2114 break; 2115 2116 default: 2117 Type = NULL; 2118 break; 2119 } 2120 2121 if (Type != NULL) { 2122 UefiDevicePathLibCatPrint (Str, "BBS(%s,%s", Type, Bbs->String); 2123 } else { 2124 UefiDevicePathLibCatPrint (Str, "BBS(0x%x,%s", Bbs->DeviceType, Bbs->String); 2125 } 2126 2127 if (DisplayOnly) { 2128 UefiDevicePathLibCatPrint (Str, ")"); 2129 return ; 2130 } 2131 2132 UefiDevicePathLibCatPrint (Str, ",0x%x)", Bbs->StatusFlag); 2133 } 2134 2135 /** 2136 Converts an End-of-Device-Path structure to its string representative. 2137 2138 @param Str The string representative of input device. 2139 @param DevPath The input device path structure. 2140 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 2141 of the display node is used, where applicable. If DisplayOnly 2142 is FALSE, then the longer text representation of the display node 2143 is used. 2144 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 2145 representation for a device node can be used, where applicable. 2146 2147 **/ 2148 static VOID 2149 DevPathToTextEndInstance ( 2150 IN OUT POOL_PRINT *Str, 2151 IN VOID *DevPath, 2152 IN BOOLEAN DisplayOnly, 2153 IN BOOLEAN AllowShortcuts 2154 ) 2155 { 2156 UefiDevicePathLibCatPrint (Str, ","); 2157 } 2158 2159 GLOBAL_REMOVE_IF_UNREFERENCED const DEVICE_PATH_TO_TEXT_GENERIC_TABLE mUefiDevicePathLibToTextTableGeneric[] = { 2160 {HARDWARE_DEVICE_PATH, "HardwarePath" }, 2161 {ACPI_DEVICE_PATH, "AcpiPath" }, 2162 {MESSAGING_DEVICE_PATH, "Msg" }, 2163 {MEDIA_DEVICE_PATH, "MediaPath" }, 2164 {BBS_DEVICE_PATH, "BbsPath" }, 2165 {0, NULL} 2166 }; 2167 2168 /** 2169 Converts an unknown device path structure to its string representative. 2170 2171 @param Str The string representative of input device. 2172 @param DevPath The input device path structure. 2173 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 2174 of the display node is used, where applicable. If DisplayOnly 2175 is FALSE, then the longer text representation of the display node 2176 is used. 2177 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 2178 representation for a device node can be used, where applicable. 2179 2180 **/ 2181 static VOID 2182 DevPathToTextNodeGeneric ( 2183 IN OUT POOL_PRINT *Str, 2184 IN VOID *DevPath, 2185 IN BOOLEAN DisplayOnly, 2186 IN BOOLEAN AllowShortcuts 2187 ) 2188 { 2189 EFI_DEVICE_PATH_PROTOCOL *Node; 2190 UINTN Index; 2191 2192 Node = DevPath; 2193 2194 for (Index = 0; mUefiDevicePathLibToTextTableGeneric[Index].Text != NULL; Index++) { 2195 if (DevicePathType (Node) == mUefiDevicePathLibToTextTableGeneric[Index].Type) { 2196 break; 2197 } 2198 } 2199 2200 if (mUefiDevicePathLibToTextTableGeneric[Index].Text == NULL) { 2201 // 2202 // It's a node whose type cannot be recognized 2203 // 2204 UefiDevicePathLibCatPrint (Str, "Path(%d,%d", DevicePathType (Node), DevicePathSubType (Node)); 2205 } else { 2206 // 2207 // It's a node whose type can be recognized 2208 // 2209 UefiDevicePathLibCatPrint (Str, "%s(%d", mUefiDevicePathLibToTextTableGeneric[Index].Text, DevicePathSubType (Node)); 2210 } 2211 2212 Index = sizeof (EFI_DEVICE_PATH_PROTOCOL); 2213 if (Index < DevicePathNodeLength (Node)) { 2214 UefiDevicePathLibCatPrint (Str, ","); 2215 for (; Index < DevicePathNodeLength (Node); Index++) { 2216 UefiDevicePathLibCatPrint (Str, "%02x", ((UINT8 *) Node)[Index]); 2217 } 2218 } 2219 2220 UefiDevicePathLibCatPrint (Str, ")"); 2221 } 2222 2223 static const DEVICE_PATH_TO_TEXT_TABLE mUefiDevicePathLibToTextTable[] = { 2224 {HARDWARE_DEVICE_PATH, HW_PCI_DP, DevPathToTextPci }, 2225 {HARDWARE_DEVICE_PATH, HW_PCCARD_DP, DevPathToTextPccard }, 2226 {HARDWARE_DEVICE_PATH, HW_MEMMAP_DP, DevPathToTextMemMap }, 2227 {HARDWARE_DEVICE_PATH, HW_VENDOR_DP, DevPathToTextVendor }, 2228 {HARDWARE_DEVICE_PATH, HW_CONTROLLER_DP, DevPathToTextController }, 2229 {HARDWARE_DEVICE_PATH, HW_BMC_DP, DevPathToTextBmc }, 2230 {ACPI_DEVICE_PATH, ACPI_DP, DevPathToTextAcpi }, 2231 {ACPI_DEVICE_PATH, ACPI_EXTENDED_DP, DevPathToTextAcpiEx }, 2232 {ACPI_DEVICE_PATH, ACPI_ADR_DP, DevPathToTextAcpiAdr }, 2233 {MESSAGING_DEVICE_PATH, MSG_ATAPI_DP, DevPathToTextAtapi }, 2234 {MESSAGING_DEVICE_PATH, MSG_SCSI_DP, DevPathToTextScsi }, 2235 {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP, DevPathToTextFibre }, 2236 {MESSAGING_DEVICE_PATH, MSG_FIBRECHANNELEX_DP, DevPathToTextFibreEx }, 2237 {MESSAGING_DEVICE_PATH, MSG_SASEX_DP, DevPathToTextSasEx }, 2238 {MESSAGING_DEVICE_PATH, MSG_NVME_NAMESPACE_DP, DevPathToTextNVMe }, 2239 {MESSAGING_DEVICE_PATH, MSG_UFS_DP, DevPathToTextUfs }, 2240 {MESSAGING_DEVICE_PATH, MSG_SD_DP, DevPathToTextSd }, 2241 {MESSAGING_DEVICE_PATH, MSG_EMMC_DP, DevPathToTextEmmc }, 2242 {MESSAGING_DEVICE_PATH, MSG_1394_DP, DevPathToText1394 }, 2243 {MESSAGING_DEVICE_PATH, MSG_USB_DP, DevPathToTextUsb }, 2244 {MESSAGING_DEVICE_PATH, MSG_USB_WWID_DP, DevPathToTextUsbWWID }, 2245 {MESSAGING_DEVICE_PATH, MSG_DEVICE_LOGICAL_UNIT_DP, DevPathToTextLogicalUnit }, 2246 {MESSAGING_DEVICE_PATH, MSG_USB_CLASS_DP, DevPathToTextUsbClass }, 2247 {MESSAGING_DEVICE_PATH, MSG_SATA_DP, DevPathToTextSata }, 2248 {MESSAGING_DEVICE_PATH, MSG_I2O_DP, DevPathToTextI2O }, 2249 {MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, DevPathToTextMacAddr }, 2250 {MESSAGING_DEVICE_PATH, MSG_IPv4_DP, DevPathToTextIPv4 }, 2251 {MESSAGING_DEVICE_PATH, MSG_IPv6_DP, DevPathToTextIPv6 }, 2252 {MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, DevPathToTextInfiniBand }, 2253 {MESSAGING_DEVICE_PATH, MSG_UART_DP, DevPathToTextUart }, 2254 {MESSAGING_DEVICE_PATH, MSG_VENDOR_DP, DevPathToTextVendor }, 2255 {MESSAGING_DEVICE_PATH, MSG_ISCSI_DP, DevPathToTextiSCSI }, 2256 {MESSAGING_DEVICE_PATH, MSG_VLAN_DP, DevPathToTextVlan }, 2257 {MESSAGING_DEVICE_PATH, MSG_URI_DP, DevPathToTextUri }, 2258 {MESSAGING_DEVICE_PATH, MSG_BLUETOOTH_DP, DevPathToTextBluetooth }, 2259 {MESSAGING_DEVICE_PATH, MSG_WIFI_DP, DevPathToTextWiFi }, 2260 {MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, DevPathToTextHardDrive }, 2261 {MEDIA_DEVICE_PATH, MEDIA_CDROM_DP, DevPathToTextCDROM }, 2262 {MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP, DevPathToTextVendor }, 2263 {MEDIA_DEVICE_PATH, MEDIA_PROTOCOL_DP, DevPathToTextMediaProtocol }, 2264 {MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, DevPathToTextFilePath }, 2265 {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_VOL_DP, DevPathToTextFv }, 2266 {MEDIA_DEVICE_PATH, MEDIA_PIWG_FW_FILE_DP, DevPathToTextFvFile }, 2267 {MEDIA_DEVICE_PATH, MEDIA_RELATIVE_OFFSET_RANGE_DP, DevPathRelativeOffsetRange }, 2268 {MEDIA_DEVICE_PATH, MEDIA_RAM_DISK_DP, DevPathToTextRamDisk }, 2269 {BBS_DEVICE_PATH, BBS_BBS_DP, DevPathToTextBBS }, 2270 {END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, DevPathToTextEndInstance }, 2271 {0, 0, NULL} 2272 }; 2273 2274 /** 2275 Converts a device node to its string representation. 2276 2277 @param DeviceNode A Pointer to the device node to be converted. 2278 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 2279 of the display node is used, where applicable. If DisplayOnly 2280 is FALSE, then the longer text representation of the display node 2281 is used. 2282 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 2283 representation for a device node can be used, where applicable. 2284 2285 @return A pointer to the allocated text representation of the device node or NULL if DeviceNode 2286 is NULL or there was insufficient memory. 2287 2288 **/ 2289 static char * 2290 EFIAPI 2291 UefiDevicePathLibConvertDeviceNodeToText ( 2292 IN CONST EFI_DEVICE_PATH_PROTOCOL *DeviceNode, 2293 IN BOOLEAN DisplayOnly, 2294 IN BOOLEAN AllowShortcuts 2295 ) 2296 { 2297 POOL_PRINT Str; 2298 UINTN Index; 2299 DEVICE_PATH_TO_TEXT ToText; 2300 EFI_DEVICE_PATH_PROTOCOL *Node; 2301 2302 if (DeviceNode == NULL) { 2303 return NULL; 2304 } 2305 2306 ZeroMem (&Str, sizeof (Str)); 2307 2308 // 2309 // Process the device path node 2310 // If not found, use a generic function 2311 // 2312 Node = __DECONST(EFI_DEVICE_PATH_PROTOCOL *, DeviceNode); 2313 ToText = DevPathToTextNodeGeneric; 2314 for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index++) { 2315 if (DevicePathType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].Type && 2316 DevicePathSubType (DeviceNode) == mUefiDevicePathLibToTextTable[Index].SubType 2317 ) { 2318 ToText = mUefiDevicePathLibToTextTable[Index].Function; 2319 break; 2320 } 2321 } 2322 2323 // 2324 // Print this node 2325 // 2326 ToText (&Str, (VOID *) Node, DisplayOnly, AllowShortcuts); 2327 2328 ASSERT (Str.Str != NULL); 2329 return Str.Str; 2330 } 2331 2332 /** 2333 Converts a device path to its text representation. 2334 2335 @param DevicePath A Pointer to the device to be converted. 2336 @param DisplayOnly If DisplayOnly is TRUE, then the shorter text representation 2337 of the display node is used, where applicable. If DisplayOnly 2338 is FALSE, then the longer text representation of the display node 2339 is used. 2340 @param AllowShortcuts If AllowShortcuts is TRUE, then the shortcut forms of text 2341 representation for a device node can be used, where applicable. 2342 2343 @return A pointer to the allocated text representation of the device path or 2344 NULL if DeviceNode is NULL or there was insufficient memory. 2345 2346 **/ 2347 static char * 2348 EFIAPI 2349 UefiDevicePathLibConvertDevicePathToText ( 2350 IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath, 2351 IN BOOLEAN DisplayOnly, 2352 IN BOOLEAN AllowShortcuts 2353 ) 2354 { 2355 POOL_PRINT Str; 2356 EFI_DEVICE_PATH_PROTOCOL *Node; 2357 EFI_DEVICE_PATH_PROTOCOL *AlignedNode; 2358 UINTN Index; 2359 DEVICE_PATH_TO_TEXT ToText; 2360 2361 if (DevicePath == NULL) { 2362 return NULL; 2363 } 2364 2365 ZeroMem (&Str, sizeof (Str)); 2366 2367 // 2368 // Process each device path node 2369 // 2370 Node = __DECONST(EFI_DEVICE_PATH_PROTOCOL *, DevicePath); 2371 while (!IsDevicePathEnd (Node)) { 2372 // 2373 // Find the handler to dump this device path node 2374 // If not found, use a generic function 2375 // 2376 ToText = DevPathToTextNodeGeneric; 2377 for (Index = 0; mUefiDevicePathLibToTextTable[Index].Function != NULL; Index += 1) { 2378 2379 if (DevicePathType (Node) == mUefiDevicePathLibToTextTable[Index].Type && 2380 DevicePathSubType (Node) == mUefiDevicePathLibToTextTable[Index].SubType 2381 ) { 2382 ToText = mUefiDevicePathLibToTextTable[Index].Function; 2383 break; 2384 } 2385 } 2386 // 2387 // Put a path separator in if needed 2388 // 2389 if ((Str.Count != 0) && (ToText != DevPathToTextEndInstance)) { 2390 if (Str.Str[Str.Count] != ',') { 2391 UefiDevicePathLibCatPrint (&Str, "/"); 2392 } 2393 } 2394 2395 AlignedNode = AllocateCopyPool (DevicePathNodeLength (Node), Node); 2396 // 2397 // Print this node of the device path 2398 // 2399 ToText (&Str, AlignedNode, DisplayOnly, AllowShortcuts); 2400 FreePool (AlignedNode); 2401 2402 // 2403 // Next device path node 2404 // 2405 Node = NextDevicePathNode (Node); 2406 } 2407 2408 if (Str.Str == NULL) { 2409 return AllocateZeroPool (sizeof (CHAR16)); 2410 } else { 2411 return Str.Str; 2412 } 2413 } 2414 2415 ssize_t 2416 efidp_format_device_path(char *buf, size_t len, const_efidp dp, ssize_t max) 2417 { 2418 char *str; 2419 ssize_t retval; 2420 2421 /* 2422 * Basic sanity check on the device path. 2423 */ 2424 if (!IsDevicePathValid((CONST EFI_DEVICE_PATH_PROTOCOL *) dp, max)) { 2425 *buf = '\0'; 2426 return 0; 2427 } 2428 2429 str = UefiDevicePathLibConvertDevicePathToText ( 2430 __DECONST(EFI_DEVICE_PATH_PROTOCOL *, dp), FALSE, TRUE); 2431 if (str == NULL) 2432 return -1; 2433 strlcpy(buf, str, len); 2434 retval = strlen(str); 2435 free(str); 2436 2437 return retval; 2438 } 2439 2440 ssize_t 2441 efidp_format_device_path_node(char *buf, size_t len, const_efidp dp) 2442 { 2443 char *str; 2444 ssize_t retval; 2445 2446 str = UefiDevicePathLibConvertDeviceNodeToText ( 2447 __DECONST(EFI_DEVICE_PATH_PROTOCOL *, dp), FALSE, TRUE); 2448 if (str == NULL) 2449 return -1; 2450 strlcpy(buf, str, len); 2451 retval = strlen(str); 2452 free(str); 2453 2454 return retval; 2455 } 2456 2457 size_t 2458 efidp_size(const_efidp dp) 2459 { 2460 2461 return GetDevicePathSize(__DECONST(EFI_DEVICE_PATH_PROTOCOL *, dp)); 2462 } 2463 2464 char * 2465 efidp_extract_file_path(const_efidp dp) 2466 { 2467 const FILEPATH_DEVICE_PATH *fp; 2468 char *name = NULL; 2469 2470 fp = (const void *)dp; 2471 ucs2_to_utf8(fp->PathName, &name); 2472 return name; 2473 } 2474