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