drivers/firmware/efi/efi-stub-helper.c

   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 #define EFI_READ_CHUNK_SIZE     (1024 * 1024)
  13
  14 struct initrd {
  15         efi_file_handle_t *handle;
  16         u64 size;
  17 };
  18
  19
  20
  21
  22 static void efi_char16_printk(efi_system_table_t *sys_table_arg,
  23                               efi_char16_t *str)
  24 {
  25         struct efi_simple_text_output_protocol *out;
  26
  27         out = (struct efi_simple_text_output_protocol *)sys_table_arg->con_out;
  28         efi_call_phys2(out->output_string, out, str);
  29 }
  30
  31 static void efi_printk(efi_system_table_t *sys_table_arg, char *str)
  32 {
  33         char *s8;
  34
  35         for (s8 = str; *s8; s8++) {
  36                 efi_char16_t ch[2] = { 0 };
  37
  38                 ch[0] = *s8;
  39                 if (*s8 == '\n') {
  40                         efi_char16_t nl[2] = { '\r', 0 };
  41                         efi_char16_printk(sys_table_arg, nl);
  42                 }
  43
  44                 efi_char16_printk(sys_table_arg, ch);
  45         }
  46 }
  47
  48
  49 static efi_status_t efi_get_memory_map(efi_system_table_t *sys_table_arg,
  50                                        efi_memory_desc_t **map,
  51                                        unsigned long *map_size,
  52                                        unsigned long *desc_size,
  53                                        u32 *desc_ver,
  54                                        unsigned long *key_ptr)
  55 {
  56         efi_memory_desc_t *m = NULL;
  57         efi_status_t status;
  58         unsigned long key;
  59         u32 desc_version;
  60
  61         *map_size = sizeof(*m) * 32;
  62 again:
  63         /*
  64          * Add an additional efi_memory_desc_t because we're doing an
  65          * allocation which may be in a new descriptor region.
  66          */
  67         *map_size += sizeof(*m);
  68         status = efi_call_phys3(sys_table_arg->boottime->allocate_pool,
  69                                 EFI_LOADER_DATA, *map_size, (void **)&m);
  70         if (status != EFI_SUCCESS)
  71                 goto fail;
  72
  73         status = efi_call_phys5(sys_table_arg->boottime->get_memory_map,
  74                                 map_size, m, &key, desc_size, &desc_version);
  75         if (status == EFI_BUFFER_TOO_SMALL) {
  76                 efi_call_phys1(sys_table_arg->boottime->free_pool, m);
  77                 goto again;
  78         }
  79
  80         if (status != EFI_SUCCESS)
  81                 efi_call_phys1(sys_table_arg->boottime->free_pool, m);
  82         if (key_ptr && status == EFI_SUCCESS)
  83                 *key_ptr = key;
  84         if (desc_ver && status == EFI_SUCCESS)
  85                 *desc_ver = desc_version;
  86
  87 fail:
  88         *map = m;
  89         return status;
  90 }
  91
  92 /*
  93  * Allocate at the highest possible address that is not above 'max'.
  94  */
  95 static efi_status_t efi_high_alloc(efi_system_table_t *sys_table_arg,
  96                                unsigned long size, unsigned long align,
  97                                unsigned long *addr, unsigned long max)
  98 {
  99         unsigned long map_size, desc_size;
 100         efi_memory_desc_t *map;
 101         efi_status_t status;
 102         unsigned long nr_pages;
 103         u64 max_addr = 0;
 104         int i;
 105
 106         status = efi_get_memory_map(sys_table_arg, &map, &map_size, &desc_size,
 107                                     NULL, NULL);
 108         if (status != EFI_SUCCESS)
 109                 goto fail;
 110
 111         /*
 112          * Enforce minimum alignment that EFI requires when requesting
 113          * a specific address.  We are doing page-based allocations,
 114          * so we must be aligned to a page.
 115          */
 116         if (align < EFI_PAGE_SIZE)
 117                 align = EFI_PAGE_SIZE;
 118
 119         nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
 120 again:
 121         for (i = 0; i < map_size / desc_size; i++) {
 122                 efi_memory_desc_t *desc;
 123                 unsigned long m = (unsigned long)map;
 124                 u64 start, end;
 125
 126                 desc = (efi_memory_desc_t *)(m + (i * desc_size));
 127                 if (desc->type != EFI_CONVENTIONAL_MEMORY)
 128                         continue;
 129
 130                 if (desc->num_pages < nr_pages)
 131                         continue;
 132
 133                 start = desc->phys_addr;
 134                 end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
 135
 136                 if ((start + size) > end || (start + size) > max)
 137                         continue;
 138
 139                 if (end - size > max)
 140                         end = max;
 141
 142                 if (round_down(end - size, align) < start)
 143                         continue;
 144
 145                 start = round_down(end - size, align);
 146
 147                 /*
 148                  * Don't allocate at 0x0. It will confuse code that
 149                  * checks pointers against NULL.
 150                  */
 151                 if (start == 0x0)
 152                         continue;
 153
 154                 if (start > max_addr)
 155                         max_addr = start;
 156         }
 157
 158         if (!max_addr)
 159                 status = EFI_NOT_FOUND;
 160         else {
 161                 status = efi_call_phys4(sys_table_arg->boottime->allocate_pages,
 162                                         EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
 163                                         nr_pages, &max_addr);
 164                 if (status != EFI_SUCCESS) {
 165                         max = max_addr;
 166                         max_addr = 0;
 167                         goto again;
 168                 }
 169
 170                 *addr = max_addr;
 171         }
 172
 173 free_pool:
 174         efi_call_phys1(sys_table_arg->boottime->free_pool, map);
 175
 176 fail:
 177         return status;
 178 }
 179
 180 /*
 181  * Allocate at the lowest possible address.
 182  */
 183 static efi_status_t efi_low_alloc(efi_system_table_t *sys_table_arg,
 184                               unsigned long size, unsigned long align,
 185                               unsigned long *addr)
 186 {
 187         unsigned long map_size, desc_size;
 188         efi_memory_desc_t *map;
 189         efi_status_t status;
 190         unsigned long nr_pages;
 191         int i;
 192
 193         status = efi_get_memory_map(sys_table_arg, &map, &map_size, &desc_size,
 194                                     NULL, NULL);
 195         if (status != EFI_SUCCESS)
 196                 goto fail;
 197
 198         /*
 199          * Enforce minimum alignment that EFI requires when requesting
 200          * a specific address.  We are doing page-based allocations,
 201          * so we must be aligned to a page.
 202          */
 203         if (align < EFI_PAGE_SIZE)
 204                 align = EFI_PAGE_SIZE;
 205
 206         nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
 207         for (i = 0; i < map_size / desc_size; i++) {
 208                 efi_memory_desc_t *desc;
 209                 unsigned long m = (unsigned long)map;
 210                 u64 start, end;
 211
 212                 desc = (efi_memory_desc_t *)(m + (i * desc_size));
 213
 214                 if (desc->type != EFI_CONVENTIONAL_MEMORY)
 215                         continue;
 216
 217                 if (desc->num_pages < nr_pages)
 218                         continue;
 219
 220                 start = desc->phys_addr;
 221                 end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
 222
 223                 /*
 224                  * Don't allocate at 0x0. It will confuse code that
 225                  * checks pointers against NULL. Skip the first 8
 226                  * bytes so we start at a nice even number.
 227                  */
 228                 if (start == 0x0)
 229                         start += 8;
 230
 231                 start = round_up(start, align);
 232                 if ((start + size) > end)
 233                         continue;
 234
 235                 status = efi_call_phys4(sys_table_arg->boottime->allocate_pages,
 236                                         EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
 237                                         nr_pages, &start);
 238                 if (status == EFI_SUCCESS) {
 239                         *addr = start;
 240                         break;
 241                 }
 242         }
 243
 244         if (i == map_size / desc_size)
 245                 status = EFI_NOT_FOUND;
 246
 247 free_pool:
 248         efi_call_phys1(sys_table_arg->boottime->free_pool, map);
 249 fail:
 250         return status;
 251 }
 252
 253 static void efi_free(efi_system_table_t *sys_table_arg, unsigned long size,
 254                      unsigned long addr)
 255 {
 256         unsigned long nr_pages;
 257
 258         if (!size)
 259                 return;
 260
 261         nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
 262         efi_call_phys2(sys_table_arg->boottime->free_pages, addr, nr_pages);
 263 }
 264
 265
 266 /*
 267  * Check the cmdline for a LILO-style initrd= arguments.
 268  *
 269  * We only support loading an initrd from the same filesystem as the
 270  * kernel image.
 271  */
 272 static efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
 273                                          efi_loaded_image_t *image,
 274                                          char *cmd_line, char *option_string,
 275                                          unsigned long max_addr,
 276                                          unsigned long *load_addr,
 277                                          unsigned long *load_size)
 278 {
 279         struct initrd *initrds;
 280         unsigned long initrd_addr;
 281         efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
 282         u64 initrd_total;
 283         efi_file_io_interface_t *io;
 284         efi_file_handle_t *fh;
 285         efi_status_t status;
 286         int nr_initrds;
 287         char *str;
 288         int i, j, k;
 289
 290         initrd_addr = 0;
 291         initrd_total = 0;
 292
 293         str = cmd_line;
 294
 295         j = 0;                  /* See close_handles */
 296
 297         if (!load_addr || !load_size)
 298                 return EFI_INVALID_PARAMETER;
 299
 300         *load_addr = 0;
 301         *load_size = 0;
 302
 303         if (!str || !*str)
 304                 return EFI_SUCCESS;
 305
 306         for (nr_initrds = 0; *str; nr_initrds++) {
 307                 str = strstr(str, option_string);
 308                 if (!str)
 309                         break;
 310
 311                 str += strlen(option_string);
 312
 313                 /* Skip any leading slashes */
 314                 while (*str == '/' || *str == '\\')
 315                         str++;
 316
 317                 while (*str && *str != ' ' && *str != '\n')
 318                         str++;
 319         }
 320
 321         if (!nr_initrds)
 322                 return EFI_SUCCESS;
 323
 324         status = efi_call_phys3(sys_table_arg->boottime->allocate_pool,
 325                                 EFI_LOADER_DATA,
 326                                 nr_initrds * sizeof(*initrds),
 327                                 &initrds);
 328         if (status != EFI_SUCCESS) {
 329                 efi_printk(sys_table_arg, "Failed to alloc mem for file load\n");
 330                 goto fail;
 331         }
 332
 333         str = cmd_line;
 334         for (i = 0; i < nr_initrds; i++) {
 335                 struct initrd *initrd;
 336                 efi_file_handle_t *h;
 337                 efi_file_info_t *info;
 338                 efi_char16_t filename_16[256];
 339                 unsigned long info_sz;
 340                 efi_guid_t info_guid = EFI_FILE_INFO_ID;
 341                 efi_char16_t *p;
 342                 u64 file_sz;
 343
 344                 str = strstr(str, option_string);
 345                 if (!str)
 346                         break;
 347
 348                 str += strlen(option_string);
 349
 350                 initrd = &initrds[i];
 351                 p = filename_16;
 352
 353                 /* Skip any leading slashes */
 354                 while (*str == '/' || *str == '\\')
 355                         str++;
 356
 357                 while (*str && *str != ' ' && *str != '\n') {
 358                         if ((u8 *)p >= (u8 *)filename_16 + sizeof(filename_16))
 359                                 break;
 360
 361                         if (*str == '/') {
 362                                 *p++ = '\\';
 363                                 *str++;
 364                         } else {
 365                                 *p++ = *str++;
 366                         }
 367                 }
 368
 369                 *p = '\0';
 370
 371                 /* Only open the volume once. */
 372                 if (!i) {
 373                         efi_boot_services_t *boottime;
 374
 375                         boottime = sys_table_arg->boottime;
 376
 377                         status = efi_call_phys3(boottime->handle_protocol,
 378                                         image->device_handle, &fs_proto, &io);
 379                         if (status != EFI_SUCCESS) {
 380                                 efi_printk(sys_table_arg, "Failed to handle fs_proto\n");
 381                                 goto free_initrds;
 382                         }
 383
 384                         status = efi_call_phys2(io->open_volume, io, &fh);
 385                         if (status != EFI_SUCCESS) {
 386                                 efi_printk(sys_table_arg, "Failed to open volume\n");
 387                                 goto free_initrds;
 388                         }
 389                 }
 390
 391                 status = efi_call_phys5(fh->open, fh, &h, filename_16,
 392                                         EFI_FILE_MODE_READ, (u64)0);
 393                 if (status != EFI_SUCCESS) {
 394                         efi_printk(sys_table_arg, "Failed to open file: ");
 395                         efi_char16_printk(sys_table_arg, filename_16);
 396                         efi_printk(sys_table_arg, "\n");
 397                         goto close_handles;
 398                 }
 399
 400                 initrd->handle = h;
 401
 402                 info_sz = 0;
 403                 status = efi_call_phys4(h->get_info, h, &info_guid,
 404                                         &info_sz, NULL);
 405                 if (status != EFI_BUFFER_TOO_SMALL) {
 406                         efi_printk(sys_table_arg, "Failed to get file info size\n");
 407                         goto close_handles;
 408                 }
 409
 410 grow:
 411                 status = efi_call_phys3(sys_table_arg->boottime->allocate_pool,
 412                                         EFI_LOADER_DATA, info_sz, &info);
 413                 if (status != EFI_SUCCESS) {
 414                         efi_printk(sys_table_arg, "Failed to alloc mem for file info\n");
 415                         goto close_handles;
 416                 }
 417
 418                 status = efi_call_phys4(h->get_info, h, &info_guid,
 419                                         &info_sz, info);
 420                 if (status == EFI_BUFFER_TOO_SMALL) {
 421                         efi_call_phys1(sys_table_arg->boottime->free_pool,
 422                                        info);
 423                         goto grow;
 424                 }
 425
 426                 file_sz = info->file_size;
 427                 efi_call_phys1(sys_table_arg->boottime->free_pool, info);
 428
 429                 if (status != EFI_SUCCESS) {
 430                         efi_printk(sys_table_arg, "Failed to get file info\n");
 431                         goto close_handles;
 432                 }
 433
 434                 initrd->size = file_sz;
 435                 initrd_total += file_sz;
 436         }
 437
 438         if (initrd_total) {
 439                 unsigned long addr;
 440
 441                 /*
 442                  * Multiple initrd's need to be at consecutive
 443                  * addresses in memory, so allocate enough memory for
 444                  * all the initrd's.
 445                  */
 446                 status = efi_high_alloc(sys_table_arg, initrd_total, 0x1000,
 447                                     &initrd_addr, max_addr);
 448                 if (status != EFI_SUCCESS) {
 449                         efi_printk(sys_table_arg, "Failed to alloc highmem for initrds\n");
 450                         goto close_handles;
 451                 }
 452
 453                 /* We've run out of free low memory. */
 454                 if (initrd_addr > max_addr) {
 455                         efi_printk(sys_table_arg, "We've run out of free low memory\n");
 456                         status = EFI_INVALID_PARAMETER;
 457                         goto free_initrd_total;
 458                 }
 459
 460                 addr = initrd_addr;
 461                 for (j = 0; j < nr_initrds; j++) {
 462                         u64 size;
 463
 464                         size = initrds[j].size;
 465                         while (size) {
 466                                 u64 chunksize;
 467                                 if (size > EFI_READ_CHUNK_SIZE)
 468                                         chunksize = EFI_READ_CHUNK_SIZE;
 469                                 else
 470                                         chunksize = size;
 471                                 status = efi_call_phys3(fh->read,
 472                                                         initrds[j].handle,
 473                                                         &chunksize, addr);
 474                                 if (status != EFI_SUCCESS) {
 475                                         efi_printk(sys_table_arg, "Failed to read file\n");
 476                                         goto free_initrd_total;
 477                                 }
 478                                 addr += chunksize;
 479                                 size -= chunksize;
 480                         }
 481
 482                         efi_call_phys1(fh->close, initrds[j].handle);
 483                 }
 484
 485         }
 486
 487         efi_call_phys1(sys_table_arg->boottime->free_pool, initrds);
 488
 489         *load_addr = initrd_addr;
 490         *load_size = initrd_total;
 491
 492         return status;
 493
 494 free_initrd_total:
 495         efi_free(sys_table_arg, initrd_total, initrd_addr);
 496
 497 close_handles:
 498         for (k = j; k < i; k++)
 499                 efi_call_phys1(fh->close, initrds[k].handle);
 500 free_initrds:
 501         efi_call_phys1(sys_table_arg->boottime->free_pool, initrds);
 502 fail:
 503         *load_addr = 0;
 504         *load_size = 0;
 505
 506         return status;
 507 }
 508 /*
 509  * Relocate a kernel image, either compressed or uncompressed.
 510  * In the ARM64 case, all kernel images are currently
 511  * uncompressed, and as such when we relocate it we need to
 512  * allocate additional space for the BSS segment. Any low
 513  * memory that this function should avoid needs to be
 514  * unavailable in the EFI memory map, as if the preferred
 515  * address is not available the lowest available address will
 516  * be used.
 517  */
 518 static efi_status_t efi_relocate_kernel(efi_system_table_t *sys_table_arg,
 519                                         unsigned long *image_addr,
 520                                         unsigned long image_size,
 521                                         unsigned long alloc_size,
 522                                         unsigned long preferred_addr,
 523                                         unsigned long alignment)
 524 {
 525         unsigned long cur_image_addr;
 526         unsigned long new_addr = 0;
 527         efi_status_t status;
 528         unsigned long nr_pages;
 529         efi_physical_addr_t efi_addr = preferred_addr;
 530
 531         if (!image_addr || !image_size || !alloc_size)
 532                 return EFI_INVALID_PARAMETER;
 533         if (alloc_size < image_size)
 534                 return EFI_INVALID_PARAMETER;
 535
 536         cur_image_addr = *image_addr;
 537
 538         /*
 539          * The EFI firmware loader could have placed the kernel image
 540          * anywhere in memory, but the kernel has restrictions on the
 541          * max physical address it can run at.  Some architectures
 542          * also have a prefered address, so first try to relocate
 543          * to the preferred address.  If that fails, allocate as low
 544          * as possible while respecting the required alignment.
 545          */
 546         nr_pages = round_up(alloc_size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
 547         status = efi_call_phys4(sys_table_arg->boottime->allocate_pages,
 548                                 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
 549                                 nr_pages, &efi_addr);
 550         new_addr = efi_addr;
 551         /*
 552          * If preferred address allocation failed allocate as low as
 553          * possible.
 554          */
 555         if (status != EFI_SUCCESS) {
 556                 status = efi_low_alloc(sys_table_arg, alloc_size, alignment,
 557                                        &new_addr);
 558         }
 559         if (status != EFI_SUCCESS) {
 560                 efi_printk(sys_table_arg, "ERROR: Failed to allocate usable memory for kernel.\n");
 561                 return status;
 562         }
 563
 564         /*
 565          * We know source/dest won't overlap since both memory ranges
 566          * have been allocated by UEFI, so we can safely use memcpy.
 567          */
 568         memcpy((void *)new_addr, (void *)cur_image_addr, image_size);
 569         /* Zero any extra space we may have allocated for BSS. */
 570         memset((void *)(new_addr + image_size), alloc_size - image_size, 0);
 571
 572         /* Return the new address of the relocated image. */
 573         *image_addr = new_addr;
 574
 575         return status;
 576 }
 577
 578 /*
 579  * Convert the unicode UEFI command line to ASCII to pass to kernel.
 580  * Size of memory allocated return in *cmd_line_len.
 581  * Returns NULL on error.
 582  */
 583 static char *efi_convert_cmdline_to_ascii(efi_system_table_t *sys_table_arg,
 584                                       efi_loaded_image_t *image,
 585                                       int *cmd_line_len)
 586 {
 587         u16 *s2;
 588         u8 *s1 = NULL;
 589         unsigned long cmdline_addr = 0;
 590         int load_options_size = image->load_options_size / 2; /* ASCII */
 591         void *options = image->load_options;
 592         int options_size = 0;
 593         efi_status_t status;
 594         int i;
 595         u16 zero = 0;
 596
 597         if (options) {
 598                 s2 = options;
 599                 while (*s2 && *s2 != '\n' && options_size < load_options_size) {
 600                         s2++;
 601                         options_size++;
 602                 }
 603         }
 604
 605         if (options_size == 0) {
 606                 /* No command line options, so return empty string*/
 607                 options_size = 1;
 608                 options = &zero;
 609         }
 610
 611         options_size++;  /* NUL termination */
 612 #ifdef CONFIG_ARM
 613         /*
 614          * For ARM, allocate at a high address to avoid reserved
 615          * regions at low addresses that we don't know the specfics of
 616          * at the time we are processing the command line.
 617          */
 618         status = efi_high_alloc(sys_table_arg, options_size, 0,
 619                             &cmdline_addr, 0xfffff000);
 620 #else
 621         status = efi_low_alloc(sys_table_arg, options_size, 0,
 622                             &cmdline_addr);
 623 #endif
 624         if (status != EFI_SUCCESS)
 625                 return NULL;
 626
 627         s1 = (u8 *)cmdline_addr;
 628         s2 = (u16 *)options;
 629
 630         for (i = 0; i < options_size - 1; i++)
 631                 *s1++ = *s2++;
 632
 633         *s1 = '\0';
 634
 635         *cmd_line_len = options_size;
 636         return (char *)cmdline_addr;
 637 }