1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Helper functions used by the EFI stub on multiple 4 * architectures. This should be #included by the EFI stub 5 * implementation files. 6 * 7 * Copyright 2011 Intel Corporation; author Matt Fleming 8 */ 9 10 #include <linux/efi.h> 11 #include <asm/efi.h> 12 13 #include "efistub.h" 14 15 /* 16 * Some firmware implementations have problems reading files in one go. 17 * A read chunk size of 1MB seems to work for most platforms. 18 * 19 * Unfortunately, reading files in chunks triggers *other* bugs on some 20 * platforms, so we provide a way to disable this workaround, which can 21 * be done by passing "efi=nochunk" on the EFI boot stub command line. 22 * 23 * If you experience issues with initrd images being corrupt it's worth 24 * trying efi=nochunk, but chunking is enabled by default because there 25 * are far more machines that require the workaround than those that 26 * break with it enabled. 27 */ 28 #define EFI_READ_CHUNK_SIZE (1024 * 1024) 29 30 static unsigned long __chunk_size = EFI_READ_CHUNK_SIZE; 31 32 static int __section(.data) __nokaslr; 33 static int __section(.data) __quiet; 34 static int __section(.data) __novamap; 35 36 int __pure nokaslr(void) 37 { 38 return __nokaslr; 39 } 40 int __pure is_quiet(void) 41 { 42 return __quiet; 43 } 44 int __pure novamap(void) 45 { 46 return __novamap; 47 } 48 49 #define EFI_MMAP_NR_SLACK_SLOTS 8 50 51 struct file_info { 52 efi_file_handle_t *handle; 53 u64 size; 54 }; 55 56 void efi_printk(efi_system_table_t *sys_table_arg, char *str) 57 { 58 char *s8; 59 60 for (s8 = str; *s8; s8++) { 61 efi_char16_t ch[2] = { 0 }; 62 63 ch[0] = *s8; 64 if (*s8 == '\n') { 65 efi_char16_t nl[2] = { '\r', 0 }; 66 efi_char16_printk(sys_table_arg, nl); 67 } 68 69 efi_char16_printk(sys_table_arg, ch); 70 } 71 } 72 73 static inline bool mmap_has_headroom(unsigned long buff_size, 74 unsigned long map_size, 75 unsigned long desc_size) 76 { 77 unsigned long slack = buff_size - map_size; 78 79 return slack / desc_size >= EFI_MMAP_NR_SLACK_SLOTS; 80 } 81 82 efi_status_t efi_get_memory_map(efi_system_table_t *sys_table_arg, 83 struct efi_boot_memmap *map) 84 { 85 efi_memory_desc_t *m = NULL; 86 efi_status_t status; 87 unsigned long key; 88 u32 desc_version; 89 90 *map->desc_size = sizeof(*m); 91 *map->map_size = *map->desc_size * 32; 92 *map->buff_size = *map->map_size; 93 again: 94 status = efi_call_early(allocate_pool, EFI_LOADER_DATA, 95 *map->map_size, (void **)&m); 96 if (status != EFI_SUCCESS) 97 goto fail; 98 99 *map->desc_size = 0; 100 key = 0; 101 status = efi_call_early(get_memory_map, map->map_size, m, 102 &key, map->desc_size, &desc_version); 103 if (status == EFI_BUFFER_TOO_SMALL || 104 !mmap_has_headroom(*map->buff_size, *map->map_size, 105 *map->desc_size)) { 106 efi_call_early(free_pool, m); 107 /* 108 * Make sure there is some entries of headroom so that the 109 * buffer can be reused for a new map after allocations are 110 * no longer permitted. Its unlikely that the map will grow to 111 * exceed this headroom once we are ready to trigger 112 * ExitBootServices() 113 */ 114 *map->map_size += *map->desc_size * EFI_MMAP_NR_SLACK_SLOTS; 115 *map->buff_size = *map->map_size; 116 goto again; 117 } 118 119 if (status != EFI_SUCCESS) 120 efi_call_early(free_pool, m); 121 122 if (map->key_ptr && status == EFI_SUCCESS) 123 *map->key_ptr = key; 124 if (map->desc_ver && status == EFI_SUCCESS) 125 *map->desc_ver = desc_version; 126 127 fail: 128 *map->map = m; 129 return status; 130 } 131 132 133 unsigned long get_dram_base(efi_system_table_t *sys_table_arg) 134 { 135 efi_status_t status; 136 unsigned long map_size, buff_size; 137 unsigned long membase = EFI_ERROR; 138 struct efi_memory_map map; 139 efi_memory_desc_t *md; 140 struct efi_boot_memmap boot_map; 141 142 boot_map.map = (efi_memory_desc_t **)&map.map; 143 boot_map.map_size = &map_size; 144 boot_map.desc_size = &map.desc_size; 145 boot_map.desc_ver = NULL; 146 boot_map.key_ptr = NULL; 147 boot_map.buff_size = &buff_size; 148 149 status = efi_get_memory_map(sys_table_arg, &boot_map); 150 if (status != EFI_SUCCESS) 151 return membase; 152 153 map.map_end = map.map + map_size; 154 155 for_each_efi_memory_desc_in_map(&map, md) { 156 if (md->attribute & EFI_MEMORY_WB) { 157 if (membase > md->phys_addr) 158 membase = md->phys_addr; 159 } 160 } 161 162 efi_call_early(free_pool, map.map); 163 164 return membase; 165 } 166 167 /* 168 * Allocate at the highest possible address that is not above 'max'. 169 */ 170 efi_status_t efi_high_alloc(efi_system_table_t *sys_table_arg, 171 unsigned long size, unsigned long align, 172 unsigned long *addr, unsigned long max) 173 { 174 unsigned long map_size, desc_size, buff_size; 175 efi_memory_desc_t *map; 176 efi_status_t status; 177 unsigned long nr_pages; 178 u64 max_addr = 0; 179 int i; 180 struct efi_boot_memmap boot_map; 181 182 boot_map.map = ↦ 183 boot_map.map_size = &map_size; 184 boot_map.desc_size = &desc_size; 185 boot_map.desc_ver = NULL; 186 boot_map.key_ptr = NULL; 187 boot_map.buff_size = &buff_size; 188 189 status = efi_get_memory_map(sys_table_arg, &boot_map); 190 if (status != EFI_SUCCESS) 191 goto fail; 192 193 /* 194 * Enforce minimum alignment that EFI or Linux requires when 195 * requesting a specific address. We are doing page-based (or 196 * larger) allocations, and both the address and size must meet 197 * alignment constraints. 198 */ 199 if (align < EFI_ALLOC_ALIGN) 200 align = EFI_ALLOC_ALIGN; 201 202 size = round_up(size, EFI_ALLOC_ALIGN); 203 nr_pages = size / EFI_PAGE_SIZE; 204 again: 205 for (i = 0; i < map_size / desc_size; i++) { 206 efi_memory_desc_t *desc; 207 unsigned long m = (unsigned long)map; 208 u64 start, end; 209 210 desc = efi_early_memdesc_ptr(m, desc_size, i); 211 if (desc->type != EFI_CONVENTIONAL_MEMORY) 212 continue; 213 214 if (desc->num_pages < nr_pages) 215 continue; 216 217 start = desc->phys_addr; 218 end = start + desc->num_pages * EFI_PAGE_SIZE; 219 220 if (end > max) 221 end = max; 222 223 if ((start + size) > end) 224 continue; 225 226 if (round_down(end - size, align) < start) 227 continue; 228 229 start = round_down(end - size, align); 230 231 /* 232 * Don't allocate at 0x0. It will confuse code that 233 * checks pointers against NULL. 234 */ 235 if (start == 0x0) 236 continue; 237 238 if (start > max_addr) 239 max_addr = start; 240 } 241 242 if (!max_addr) 243 status = EFI_NOT_FOUND; 244 else { 245 status = efi_call_early(allocate_pages, 246 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA, 247 nr_pages, &max_addr); 248 if (status != EFI_SUCCESS) { 249 max = max_addr; 250 max_addr = 0; 251 goto again; 252 } 253 254 *addr = max_addr; 255 } 256 257 efi_call_early(free_pool, map); 258 fail: 259 return status; 260 } 261 262 /* 263 * Allocate at the lowest possible address that is not below 'min'. 264 */ 265 efi_status_t efi_low_alloc_above(efi_system_table_t *sys_table_arg, 266 unsigned long size, unsigned long align, 267 unsigned long *addr, unsigned long min) 268 { 269 unsigned long map_size, desc_size, buff_size; 270 efi_memory_desc_t *map; 271 efi_status_t status; 272 unsigned long nr_pages; 273 int i; 274 struct efi_boot_memmap boot_map; 275 276 boot_map.map = ↦ 277 boot_map.map_size = &map_size; 278 boot_map.desc_size = &desc_size; 279 boot_map.desc_ver = NULL; 280 boot_map.key_ptr = NULL; 281 boot_map.buff_size = &buff_size; 282 283 status = efi_get_memory_map(sys_table_arg, &boot_map); 284 if (status != EFI_SUCCESS) 285 goto fail; 286 287 /* 288 * Enforce minimum alignment that EFI or Linux requires when 289 * requesting a specific address. We are doing page-based (or 290 * larger) allocations, and both the address and size must meet 291 * alignment constraints. 292 */ 293 if (align < EFI_ALLOC_ALIGN) 294 align = EFI_ALLOC_ALIGN; 295 296 size = round_up(size, EFI_ALLOC_ALIGN); 297 nr_pages = size / EFI_PAGE_SIZE; 298 for (i = 0; i < map_size / desc_size; i++) { 299 efi_memory_desc_t *desc; 300 unsigned long m = (unsigned long)map; 301 u64 start, end; 302 303 desc = efi_early_memdesc_ptr(m, desc_size, i); 304 305 if (desc->type != EFI_CONVENTIONAL_MEMORY) 306 continue; 307 308 if (desc->num_pages < nr_pages) 309 continue; 310 311 start = desc->phys_addr; 312 end = start + desc->num_pages * EFI_PAGE_SIZE; 313 314 if (start < min) 315 start = min; 316 317 start = round_up(start, align); 318 if ((start + size) > end) 319 continue; 320 321 status = efi_call_early(allocate_pages, 322 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA, 323 nr_pages, &start); 324 if (status == EFI_SUCCESS) { 325 *addr = start; 326 break; 327 } 328 } 329 330 if (i == map_size / desc_size) 331 status = EFI_NOT_FOUND; 332 333 efi_call_early(free_pool, map); 334 fail: 335 return status; 336 } 337 338 void efi_free(efi_system_table_t *sys_table_arg, unsigned long size, 339 unsigned long addr) 340 { 341 unsigned long nr_pages; 342 343 if (!size) 344 return; 345 346 nr_pages = round_up(size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE; 347 efi_call_early(free_pages, addr, nr_pages); 348 } 349 350 static efi_status_t efi_file_size(efi_system_table_t *sys_table_arg, void *__fh, 351 efi_char16_t *filename_16, void **handle, 352 u64 *file_sz) 353 { 354 efi_file_handle_t *h, *fh = __fh; 355 efi_file_info_t *info; 356 efi_status_t status; 357 efi_guid_t info_guid = EFI_FILE_INFO_ID; 358 unsigned long info_sz; 359 360 status = efi_call_proto(efi_file_handle, open, fh, &h, filename_16, 361 EFI_FILE_MODE_READ, (u64)0); 362 if (status != EFI_SUCCESS) { 363 efi_printk(sys_table_arg, "Failed to open file: "); 364 efi_char16_printk(sys_table_arg, filename_16); 365 efi_printk(sys_table_arg, "\n"); 366 return status; 367 } 368 369 *handle = h; 370 371 info_sz = 0; 372 status = efi_call_proto(efi_file_handle, get_info, h, &info_guid, 373 &info_sz, NULL); 374 if (status != EFI_BUFFER_TOO_SMALL) { 375 efi_printk(sys_table_arg, "Failed to get file info size\n"); 376 return status; 377 } 378 379 grow: 380 status = efi_call_early(allocate_pool, EFI_LOADER_DATA, 381 info_sz, (void **)&info); 382 if (status != EFI_SUCCESS) { 383 efi_printk(sys_table_arg, "Failed to alloc mem for file info\n"); 384 return status; 385 } 386 387 status = efi_call_proto(efi_file_handle, get_info, h, &info_guid, 388 &info_sz, info); 389 if (status == EFI_BUFFER_TOO_SMALL) { 390 efi_call_early(free_pool, info); 391 goto grow; 392 } 393 394 *file_sz = info->file_size; 395 efi_call_early(free_pool, info); 396 397 if (status != EFI_SUCCESS) 398 efi_printk(sys_table_arg, "Failed to get initrd info\n"); 399 400 return status; 401 } 402 403 static efi_status_t efi_file_read(void *handle, unsigned long *size, void *addr) 404 { 405 return efi_call_proto(efi_file_handle, read, handle, size, addr); 406 } 407 408 static efi_status_t efi_file_close(void *handle) 409 { 410 return efi_call_proto(efi_file_handle, close, handle); 411 } 412 413 static efi_status_t efi_open_volume(efi_system_table_t *sys_table_arg, 414 efi_loaded_image_t *image, 415 efi_file_handle_t **__fh) 416 { 417 efi_file_io_interface_t *io; 418 efi_file_handle_t *fh; 419 efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID; 420 efi_status_t status; 421 void *handle = (void *)(unsigned long)efi_table_attr(efi_loaded_image, 422 device_handle, 423 image); 424 425 status = efi_call_early(handle_protocol, handle, 426 &fs_proto, (void **)&io); 427 if (status != EFI_SUCCESS) { 428 efi_printk(sys_table_arg, "Failed to handle fs_proto\n"); 429 return status; 430 } 431 432 status = efi_call_proto(efi_file_io_interface, open_volume, io, &fh); 433 if (status != EFI_SUCCESS) 434 efi_printk(sys_table_arg, "Failed to open volume\n"); 435 else 436 *__fh = fh; 437 438 return status; 439 } 440 441 /* 442 * Parse the ASCII string 'cmdline' for EFI options, denoted by the efi= 443 * option, e.g. efi=nochunk. 444 * 445 * It should be noted that efi= is parsed in two very different 446 * environments, first in the early boot environment of the EFI boot 447 * stub, and subsequently during the kernel boot. 448 */ 449 efi_status_t efi_parse_options(char const *cmdline) 450 { 451 char *str; 452 453 str = strstr(cmdline, "nokaslr"); 454 if (str == cmdline || (str && str > cmdline && *(str - 1) == ' ')) 455 __nokaslr = 1; 456 457 str = strstr(cmdline, "quiet"); 458 if (str == cmdline || (str && str > cmdline && *(str - 1) == ' ')) 459 __quiet = 1; 460 461 /* 462 * If no EFI parameters were specified on the cmdline we've got 463 * nothing to do. 464 */ 465 str = strstr(cmdline, "efi="); 466 if (!str) 467 return EFI_SUCCESS; 468 469 /* Skip ahead to first argument */ 470 str += strlen("efi="); 471 472 /* 473 * Remember, because efi= is also used by the kernel we need to 474 * skip over arguments we don't understand. 475 */ 476 while (*str && *str != ' ') { 477 if (!strncmp(str, "nochunk", 7)) { 478 str += strlen("nochunk"); 479 __chunk_size = -1UL; 480 } 481 482 if (!strncmp(str, "novamap", 7)) { 483 str += strlen("novamap"); 484 __novamap = 1; 485 } 486 487 /* Group words together, delimited by "," */ 488 while (*str && *str != ' ' && *str != ',') 489 str++; 490 491 if (*str == ',') 492 str++; 493 } 494 495 return EFI_SUCCESS; 496 } 497 498 /* 499 * Check the cmdline for a LILO-style file= arguments. 500 * 501 * We only support loading a file from the same filesystem as 502 * the kernel image. 503 */ 504 efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg, 505 efi_loaded_image_t *image, 506 char *cmd_line, char *option_string, 507 unsigned long max_addr, 508 unsigned long *load_addr, 509 unsigned long *load_size) 510 { 511 struct file_info *files; 512 unsigned long file_addr; 513 u64 file_size_total; 514 efi_file_handle_t *fh = NULL; 515 efi_status_t status; 516 int nr_files; 517 char *str; 518 int i, j, k; 519 520 file_addr = 0; 521 file_size_total = 0; 522 523 str = cmd_line; 524 525 j = 0; /* See close_handles */ 526 527 if (!load_addr || !load_size) 528 return EFI_INVALID_PARAMETER; 529 530 *load_addr = 0; 531 *load_size = 0; 532 533 if (!str || !*str) 534 return EFI_SUCCESS; 535 536 for (nr_files = 0; *str; nr_files++) { 537 str = strstr(str, option_string); 538 if (!str) 539 break; 540 541 str += strlen(option_string); 542 543 /* Skip any leading slashes */ 544 while (*str == '/' || *str == '\\') 545 str++; 546 547 while (*str && *str != ' ' && *str != '\n') 548 str++; 549 } 550 551 if (!nr_files) 552 return EFI_SUCCESS; 553 554 status = efi_call_early(allocate_pool, EFI_LOADER_DATA, 555 nr_files * sizeof(*files), (void **)&files); 556 if (status != EFI_SUCCESS) { 557 pr_efi_err(sys_table_arg, "Failed to alloc mem for file handle list\n"); 558 goto fail; 559 } 560 561 str = cmd_line; 562 for (i = 0; i < nr_files; i++) { 563 struct file_info *file; 564 efi_char16_t filename_16[256]; 565 efi_char16_t *p; 566 567 str = strstr(str, option_string); 568 if (!str) 569 break; 570 571 str += strlen(option_string); 572 573 file = &files[i]; 574 p = filename_16; 575 576 /* Skip any leading slashes */ 577 while (*str == '/' || *str == '\\') 578 str++; 579 580 while (*str && *str != ' ' && *str != '\n') { 581 if ((u8 *)p >= (u8 *)filename_16 + sizeof(filename_16)) 582 break; 583 584 if (*str == '/') { 585 *p++ = '\\'; 586 str++; 587 } else { 588 *p++ = *str++; 589 } 590 } 591 592 *p = '\0'; 593 594 /* Only open the volume once. */ 595 if (!i) { 596 status = efi_open_volume(sys_table_arg, image, &fh); 597 if (status != EFI_SUCCESS) 598 goto free_files; 599 } 600 601 status = efi_file_size(sys_table_arg, fh, filename_16, 602 (void **)&file->handle, &file->size); 603 if (status != EFI_SUCCESS) 604 goto close_handles; 605 606 file_size_total += file->size; 607 } 608 609 if (file_size_total) { 610 unsigned long addr; 611 612 /* 613 * Multiple files need to be at consecutive addresses in memory, 614 * so allocate enough memory for all the files. This is used 615 * for loading multiple files. 616 */ 617 status = efi_high_alloc(sys_table_arg, file_size_total, 0x1000, 618 &file_addr, max_addr); 619 if (status != EFI_SUCCESS) { 620 pr_efi_err(sys_table_arg, "Failed to alloc highmem for files\n"); 621 goto close_handles; 622 } 623 624 /* We've run out of free low memory. */ 625 if (file_addr > max_addr) { 626 pr_efi_err(sys_table_arg, "We've run out of free low memory\n"); 627 status = EFI_INVALID_PARAMETER; 628 goto free_file_total; 629 } 630 631 addr = file_addr; 632 for (j = 0; j < nr_files; j++) { 633 unsigned long size; 634 635 size = files[j].size; 636 while (size) { 637 unsigned long chunksize; 638 639 if (IS_ENABLED(CONFIG_X86) && size > __chunk_size) 640 chunksize = __chunk_size; 641 else 642 chunksize = size; 643 644 status = efi_file_read(files[j].handle, 645 &chunksize, 646 (void *)addr); 647 if (status != EFI_SUCCESS) { 648 pr_efi_err(sys_table_arg, "Failed to read file\n"); 649 goto free_file_total; 650 } 651 addr += chunksize; 652 size -= chunksize; 653 } 654 655 efi_file_close(files[j].handle); 656 } 657 658 } 659 660 efi_call_early(free_pool, files); 661 662 *load_addr = file_addr; 663 *load_size = file_size_total; 664 665 return status; 666 667 free_file_total: 668 efi_free(sys_table_arg, file_size_total, file_addr); 669 670 close_handles: 671 for (k = j; k < i; k++) 672 efi_file_close(files[k].handle); 673 free_files: 674 efi_call_early(free_pool, files); 675 fail: 676 *load_addr = 0; 677 *load_size = 0; 678 679 return status; 680 } 681 /* 682 * Relocate a kernel image, either compressed or uncompressed. 683 * In the ARM64 case, all kernel images are currently 684 * uncompressed, and as such when we relocate it we need to 685 * allocate additional space for the BSS segment. Any low 686 * memory that this function should avoid needs to be 687 * unavailable in the EFI memory map, as if the preferred 688 * address is not available the lowest available address will 689 * be used. 690 */ 691 efi_status_t efi_relocate_kernel(efi_system_table_t *sys_table_arg, 692 unsigned long *image_addr, 693 unsigned long image_size, 694 unsigned long alloc_size, 695 unsigned long preferred_addr, 696 unsigned long alignment, 697 unsigned long min_addr) 698 { 699 unsigned long cur_image_addr; 700 unsigned long new_addr = 0; 701 efi_status_t status; 702 unsigned long nr_pages; 703 efi_physical_addr_t efi_addr = preferred_addr; 704 705 if (!image_addr || !image_size || !alloc_size) 706 return EFI_INVALID_PARAMETER; 707 if (alloc_size < image_size) 708 return EFI_INVALID_PARAMETER; 709 710 cur_image_addr = *image_addr; 711 712 /* 713 * The EFI firmware loader could have placed the kernel image 714 * anywhere in memory, but the kernel has restrictions on the 715 * max physical address it can run at. Some architectures 716 * also have a prefered address, so first try to relocate 717 * to the preferred address. If that fails, allocate as low 718 * as possible while respecting the required alignment. 719 */ 720 nr_pages = round_up(alloc_size, EFI_ALLOC_ALIGN) / EFI_PAGE_SIZE; 721 status = efi_call_early(allocate_pages, 722 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA, 723 nr_pages, &efi_addr); 724 new_addr = efi_addr; 725 /* 726 * If preferred address allocation failed allocate as low as 727 * possible. 728 */ 729 if (status != EFI_SUCCESS) { 730 status = efi_low_alloc_above(sys_table_arg, alloc_size, 731 alignment, &new_addr, min_addr); 732 } 733 if (status != EFI_SUCCESS) { 734 pr_efi_err(sys_table_arg, "Failed to allocate usable memory for kernel.\n"); 735 return status; 736 } 737 738 /* 739 * We know source/dest won't overlap since both memory ranges 740 * have been allocated by UEFI, so we can safely use memcpy. 741 */ 742 memcpy((void *)new_addr, (void *)cur_image_addr, image_size); 743 744 /* Return the new address of the relocated image. */ 745 *image_addr = new_addr; 746 747 return status; 748 } 749 750 /* 751 * Get the number of UTF-8 bytes corresponding to an UTF-16 character. 752 * This overestimates for surrogates, but that is okay. 753 */ 754 static int efi_utf8_bytes(u16 c) 755 { 756 return 1 + (c >= 0x80) + (c >= 0x800); 757 } 758 759 /* 760 * Convert an UTF-16 string, not necessarily null terminated, to UTF-8. 761 */ 762 static u8 *efi_utf16_to_utf8(u8 *dst, const u16 *src, int n) 763 { 764 unsigned int c; 765 766 while (n--) { 767 c = *src++; 768 if (n && c >= 0xd800 && c <= 0xdbff && 769 *src >= 0xdc00 && *src <= 0xdfff) { 770 c = 0x10000 + ((c & 0x3ff) << 10) + (*src & 0x3ff); 771 src++; 772 n--; 773 } 774 if (c >= 0xd800 && c <= 0xdfff) 775 c = 0xfffd; /* Unmatched surrogate */ 776 if (c < 0x80) { 777 *dst++ = c; 778 continue; 779 } 780 if (c < 0x800) { 781 *dst++ = 0xc0 + (c >> 6); 782 goto t1; 783 } 784 if (c < 0x10000) { 785 *dst++ = 0xe0 + (c >> 12); 786 goto t2; 787 } 788 *dst++ = 0xf0 + (c >> 18); 789 *dst++ = 0x80 + ((c >> 12) & 0x3f); 790 t2: 791 *dst++ = 0x80 + ((c >> 6) & 0x3f); 792 t1: 793 *dst++ = 0x80 + (c & 0x3f); 794 } 795 796 return dst; 797 } 798 799 #ifndef MAX_CMDLINE_ADDRESS 800 #define MAX_CMDLINE_ADDRESS ULONG_MAX 801 #endif 802 803 /* 804 * Convert the unicode UEFI command line to ASCII to pass to kernel. 805 * Size of memory allocated return in *cmd_line_len. 806 * Returns NULL on error. 807 */ 808 char *efi_convert_cmdline(efi_system_table_t *sys_table_arg, 809 efi_loaded_image_t *image, 810 int *cmd_line_len) 811 { 812 const u16 *s2; 813 u8 *s1 = NULL; 814 unsigned long cmdline_addr = 0; 815 int load_options_chars = image->load_options_size / 2; /* UTF-16 */ 816 const u16 *options = image->load_options; 817 int options_bytes = 0; /* UTF-8 bytes */ 818 int options_chars = 0; /* UTF-16 chars */ 819 efi_status_t status; 820 u16 zero = 0; 821 822 if (options) { 823 s2 = options; 824 while (*s2 && *s2 != '\n' 825 && options_chars < load_options_chars) { 826 options_bytes += efi_utf8_bytes(*s2++); 827 options_chars++; 828 } 829 } 830 831 if (!options_chars) { 832 /* No command line options, so return empty string*/ 833 options = &zero; 834 } 835 836 options_bytes++; /* NUL termination */ 837 838 status = efi_high_alloc(sys_table_arg, options_bytes, 0, 839 &cmdline_addr, MAX_CMDLINE_ADDRESS); 840 if (status != EFI_SUCCESS) 841 return NULL; 842 843 s1 = (u8 *)cmdline_addr; 844 s2 = (const u16 *)options; 845 846 s1 = efi_utf16_to_utf8(s1, s2, options_chars); 847 *s1 = '\0'; 848 849 *cmd_line_len = options_bytes; 850 return (char *)cmdline_addr; 851 } 852 853 /* 854 * Handle calling ExitBootServices according to the requirements set out by the 855 * spec. Obtains the current memory map, and returns that info after calling 856 * ExitBootServices. The client must specify a function to perform any 857 * processing of the memory map data prior to ExitBootServices. A client 858 * specific structure may be passed to the function via priv. The client 859 * function may be called multiple times. 860 */ 861 efi_status_t efi_exit_boot_services(efi_system_table_t *sys_table_arg, 862 void *handle, 863 struct efi_boot_memmap *map, 864 void *priv, 865 efi_exit_boot_map_processing priv_func) 866 { 867 efi_status_t status; 868 869 status = efi_get_memory_map(sys_table_arg, map); 870 871 if (status != EFI_SUCCESS) 872 goto fail; 873 874 status = priv_func(sys_table_arg, map, priv); 875 if (status != EFI_SUCCESS) 876 goto free_map; 877 878 status = efi_call_early(exit_boot_services, handle, *map->key_ptr); 879 880 if (status == EFI_INVALID_PARAMETER) { 881 /* 882 * The memory map changed between efi_get_memory_map() and 883 * exit_boot_services(). Per the UEFI Spec v2.6, Section 6.4: 884 * EFI_BOOT_SERVICES.ExitBootServices we need to get the 885 * updated map, and try again. The spec implies one retry 886 * should be sufficent, which is confirmed against the EDK2 887 * implementation. Per the spec, we can only invoke 888 * get_memory_map() and exit_boot_services() - we cannot alloc 889 * so efi_get_memory_map() cannot be used, and we must reuse 890 * the buffer. For all practical purposes, the headroom in the 891 * buffer should account for any changes in the map so the call 892 * to get_memory_map() is expected to succeed here. 893 */ 894 *map->map_size = *map->buff_size; 895 status = efi_call_early(get_memory_map, 896 map->map_size, 897 *map->map, 898 map->key_ptr, 899 map->desc_size, 900 map->desc_ver); 901 902 /* exit_boot_services() was called, thus cannot free */ 903 if (status != EFI_SUCCESS) 904 goto fail; 905 906 status = priv_func(sys_table_arg, map, priv); 907 /* exit_boot_services() was called, thus cannot free */ 908 if (status != EFI_SUCCESS) 909 goto fail; 910 911 status = efi_call_early(exit_boot_services, handle, *map->key_ptr); 912 } 913 914 /* exit_boot_services() was called, thus cannot free */ 915 if (status != EFI_SUCCESS) 916 goto fail; 917 918 return EFI_SUCCESS; 919 920 free_map: 921 efi_call_early(free_pool, *map->map); 922 fail: 923 return status; 924 } 925 926 #define GET_EFI_CONFIG_TABLE(bits) \ 927 static void *get_efi_config_table##bits(efi_system_table_t *_sys_table, \ 928 efi_guid_t guid) \ 929 { \ 930 efi_system_table_##bits##_t *sys_table; \ 931 efi_config_table_##bits##_t *tables; \ 932 int i; \ 933 \ 934 sys_table = (typeof(sys_table))_sys_table; \ 935 tables = (typeof(tables))(unsigned long)sys_table->tables; \ 936 \ 937 for (i = 0; i < sys_table->nr_tables; i++) { \ 938 if (efi_guidcmp(tables[i].guid, guid) != 0) \ 939 continue; \ 940 \ 941 return (void *)(unsigned long)tables[i].table; \ 942 } \ 943 \ 944 return NULL; \ 945 } 946 GET_EFI_CONFIG_TABLE(32) 947 GET_EFI_CONFIG_TABLE(64) 948 949 void *get_efi_config_table(efi_system_table_t *sys_table, efi_guid_t guid) 950 { 951 if (efi_is_64bit()) 952 return get_efi_config_table64(sys_table, guid); 953 else 954 return get_efi_config_table32(sys_table, guid); 955 } 956