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_ramdisks(efi_system_table_t *sys_table_arg,
 273                                     efi_loaded_image_t *image,
 274                                     struct setup_header *hdr)
 275 {
 276         struct initrd *initrds;
 277         unsigned long initrd_addr;
 278         efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
 279         u64 initrd_total;
 280         efi_file_io_interface_t *io;
 281         efi_file_handle_t *fh;
 282         efi_status_t status;
 283         int nr_initrds;
 284         char *str;
 285         int i, j, k;
 286
 287         initrd_addr = 0;
 288         initrd_total = 0;
 289
 290         str = (char *)(unsigned long)hdr->cmd_line_ptr;
 291
 292         j = 0;                  /* See close_handles */
 293
 294         if (!str || !*str)
 295                 return EFI_SUCCESS;
 296
 297         for (nr_initrds = 0; *str; nr_initrds++) {
 298                 str = strstr(str, "initrd=");
 299                 if (!str)
 300                         break;
 301
 302                 str += 7;
 303
 304                 /* Skip any leading slashes */
 305                 while (*str == '/' || *str == '\\')
 306                         str++;
 307
 308                 while (*str && *str != ' ' && *str != '\n')
 309                         str++;
 310         }
 311
 312         if (!nr_initrds)
 313                 return EFI_SUCCESS;
 314
 315         status = efi_call_phys3(sys_table_arg->boottime->allocate_pool,
 316                                 EFI_LOADER_DATA,
 317                                 nr_initrds * sizeof(*initrds),
 318                                 &initrds);
 319         if (status != EFI_SUCCESS) {
 320                 efi_printk(sys_table_arg, "Failed to alloc mem for initrds\n");
 321                 goto fail;
 322         }
 323
 324         str = (char *)(unsigned long)hdr->cmd_line_ptr;
 325         for (i = 0; i < nr_initrds; i++) {
 326                 struct initrd *initrd;
 327                 efi_file_handle_t *h;
 328                 efi_file_info_t *info;
 329                 efi_char16_t filename_16[256];
 330                 unsigned long info_sz;
 331                 efi_guid_t info_guid = EFI_FILE_INFO_ID;
 332                 efi_char16_t *p;
 333                 u64 file_sz;
 334
 335                 str = strstr(str, "initrd=");
 336                 if (!str)
 337                         break;
 338
 339                 str += 7;
 340
 341                 initrd = &initrds[i];
 342                 p = filename_16;
 343
 344                 /* Skip any leading slashes */
 345                 while (*str == '/' || *str == '\\')
 346                         str++;
 347
 348                 while (*str && *str != ' ' && *str != '\n') {
 349                         if ((u8 *)p >= (u8 *)filename_16 + sizeof(filename_16))
 350                                 break;
 351
 352                         if (*str == '/') {
 353                                 *p++ = '\\';
 354                                 *str++;
 355                         } else {
 356                                 *p++ = *str++;
 357                         }
 358                 }
 359
 360                 *p = '\0';
 361
 362                 /* Only open the volume once. */
 363                 if (!i) {
 364                         efi_boot_services_t *boottime;
 365
 366                         boottime = sys_table_arg->boottime;
 367
 368                         status = efi_call_phys3(boottime->handle_protocol,
 369                                         image->device_handle, &fs_proto, &io);
 370                         if (status != EFI_SUCCESS) {
 371                                 efi_printk(sys_table_arg, "Failed to handle fs_proto\n");
 372                                 goto free_initrds;
 373                         }
 374
 375                         status = efi_call_phys2(io->open_volume, io, &fh);
 376                         if (status != EFI_SUCCESS) {
 377                                 efi_printk(sys_table_arg, "Failed to open volume\n");
 378                                 goto free_initrds;
 379                         }
 380                 }
 381
 382                 status = efi_call_phys5(fh->open, fh, &h, filename_16,
 383                                         EFI_FILE_MODE_READ, (u64)0);
 384                 if (status != EFI_SUCCESS) {
 385                         efi_printk(sys_table_arg, "Failed to open initrd file: ");
 386                         efi_char16_printk(sys_table_arg, filename_16);
 387                         efi_printk(sys_table_arg, "\n");
 388                         goto close_handles;
 389                 }
 390
 391                 initrd->handle = h;
 392
 393                 info_sz = 0;
 394                 status = efi_call_phys4(h->get_info, h, &info_guid,
 395                                         &info_sz, NULL);
 396                 if (status != EFI_BUFFER_TOO_SMALL) {
 397                         efi_printk(sys_table_arg, "Failed to get initrd info size\n");
 398                         goto close_handles;
 399                 }
 400
 401 grow:
 402                 status = efi_call_phys3(sys_table_arg->boottime->allocate_pool,
 403                                         EFI_LOADER_DATA, info_sz, &info);
 404                 if (status != EFI_SUCCESS) {
 405                         efi_printk(sys_table_arg, "Failed to alloc mem for initrd info\n");
 406                         goto close_handles;
 407                 }
 408
 409                 status = efi_call_phys4(h->get_info, h, &info_guid,
 410                                         &info_sz, info);
 411                 if (status == EFI_BUFFER_TOO_SMALL) {
 412                         efi_call_phys1(sys_table_arg->boottime->free_pool,
 413                                        info);
 414                         goto grow;
 415                 }
 416
 417                 file_sz = info->file_size;
 418                 efi_call_phys1(sys_table_arg->boottime->free_pool, info);
 419
 420                 if (status != EFI_SUCCESS) {
 421                         efi_printk(sys_table_arg, "Failed to get initrd info\n");
 422                         goto close_handles;
 423                 }
 424
 425                 initrd->size = file_sz;
 426                 initrd_total += file_sz;
 427         }
 428
 429         if (initrd_total) {
 430                 unsigned long addr;
 431
 432                 /*
 433                  * Multiple initrd's need to be at consecutive
 434                  * addresses in memory, so allocate enough memory for
 435                  * all the initrd's.
 436                  */
 437                 status = efi_high_alloc(sys_table_arg, initrd_total, 0x1000,
 438                                     &initrd_addr, hdr->initrd_addr_max);
 439                 if (status != EFI_SUCCESS) {
 440                         efi_printk(sys_table_arg, "Failed to alloc highmem for initrds\n");
 441                         goto close_handles;
 442                 }
 443
 444                 /* We've run out of free low memory. */
 445                 if (initrd_addr > hdr->initrd_addr_max) {
 446                         efi_printk(sys_table_arg, "We've run out of free low memory\n");
 447                         status = EFI_INVALID_PARAMETER;
 448                         goto free_initrd_total;
 449                 }
 450
 451                 addr = initrd_addr;
 452                 for (j = 0; j < nr_initrds; j++) {
 453                         u64 size;
 454
 455                         size = initrds[j].size;
 456                         while (size) {
 457                                 u64 chunksize;
 458                                 if (size > EFI_READ_CHUNK_SIZE)
 459                                         chunksize = EFI_READ_CHUNK_SIZE;
 460                                 else
 461                                         chunksize = size;
 462                                 status = efi_call_phys3(fh->read,
 463                                                         initrds[j].handle,
 464                                                         &chunksize, addr);
 465                                 if (status != EFI_SUCCESS) {
 466                                         efi_printk(sys_table_arg, "Failed to read initrd\n");
 467                                         goto free_initrd_total;
 468                                 }
 469                                 addr += chunksize;
 470                                 size -= chunksize;
 471                         }
 472
 473                         efi_call_phys1(fh->close, initrds[j].handle);
 474                 }
 475
 476         }
 477
 478         efi_call_phys1(sys_table_arg->boottime->free_pool, initrds);
 479
 480         hdr->ramdisk_image = initrd_addr;
 481         hdr->ramdisk_size = initrd_total;
 482
 483         return status;
 484
 485 free_initrd_total:
 486         efi_free(sys_table_arg, initrd_total, initrd_addr);
 487
 488 close_handles:
 489         for (k = j; k < i; k++)
 490                 efi_call_phys1(fh->close, initrds[k].handle);
 491 free_initrds:
 492         efi_call_phys1(sys_table_arg->boottime->free_pool, initrds);
 493 fail:
 494         hdr->ramdisk_image = 0;
 495         hdr->ramdisk_size = 0;
 496
 497         return status;
 498 }
 499 /*
 500  * Relocate a kernel image, either compressed or uncompressed.
 501  * In the ARM64 case, all kernel images are currently
 502  * uncompressed, and as such when we relocate it we need to
 503  * allocate additional space for the BSS segment. Any low
 504  * memory that this function should avoid needs to be
 505  * unavailable in the EFI memory map, as if the preferred
 506  * address is not available the lowest available address will
 507  * be used.
 508  */
 509 static efi_status_t efi_relocate_kernel(efi_system_table_t *sys_table_arg,
 510                                         unsigned long *image_addr,
 511                                         unsigned long image_size,
 512                                         unsigned long alloc_size,
 513                                         unsigned long preferred_addr,
 514                                         unsigned long alignment)
 515 {
 516         unsigned long cur_image_addr;
 517         unsigned long new_addr = 0;
 518         efi_status_t status;
 519         unsigned long nr_pages;
 520         efi_physical_addr_t efi_addr = preferred_addr;
 521
 522         if (!image_addr || !image_size || !alloc_size)
 523                 return EFI_INVALID_PARAMETER;
 524         if (alloc_size < image_size)
 525                 return EFI_INVALID_PARAMETER;
 526
 527         cur_image_addr = *image_addr;
 528
 529         /*
 530          * The EFI firmware loader could have placed the kernel image
 531          * anywhere in memory, but the kernel has restrictions on the
 532          * max physical address it can run at.  Some architectures
 533          * also have a prefered address, so first try to relocate
 534          * to the preferred address.  If that fails, allocate as low
 535          * as possible while respecting the required alignment.
 536          */
 537         nr_pages = round_up(alloc_size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
 538         status = efi_call_phys4(sys_table_arg->boottime->allocate_pages,
 539                                 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
 540                                 nr_pages, &efi_addr);
 541         new_addr = efi_addr;
 542         /*
 543          * If preferred address allocation failed allocate as low as
 544          * possible.
 545          */
 546         if (status != EFI_SUCCESS) {
 547                 status = efi_low_alloc(sys_table_arg, alloc_size, alignment,
 548                                        &new_addr);
 549         }
 550         if (status != EFI_SUCCESS) {
 551                 efi_printk(sys_table_arg, "ERROR: Failed to allocate usable memory for kernel.\n");
 552                 return status;
 553         }
 554
 555         /*
 556          * We know source/dest won't overlap since both memory ranges
 557          * have been allocated by UEFI, so we can safely use memcpy.
 558          */
 559         memcpy((void *)new_addr, (void *)cur_image_addr, image_size);
 560         /* Zero any extra space we may have allocated for BSS. */
 561         memset((void *)(new_addr + image_size), alloc_size - image_size, 0);
 562
 563         /* Return the new address of the relocated image. */
 564         *image_addr = new_addr;
 565
 566         return status;
 567 }
 568
 569 /*
 570  * Convert the unicode UEFI command line to ASCII to pass to kernel.
 571  * Size of memory allocated return in *cmd_line_len.
 572  * Returns NULL on error.
 573  */
 574 static char *efi_convert_cmdline_to_ascii(efi_system_table_t *sys_table_arg,
 575                                       efi_loaded_image_t *image,
 576                                       int *cmd_line_len)
 577 {
 578         u16 *s2;
 579         u8 *s1 = NULL;
 580         unsigned long cmdline_addr = 0;
 581         int load_options_size = image->load_options_size / 2; /* ASCII */
 582         void *options = image->load_options;
 583         int options_size = 0;
 584         efi_status_t status;
 585         int i;
 586         u16 zero = 0;
 587
 588         if (options) {
 589                 s2 = options;
 590                 while (*s2 && *s2 != '\n' && options_size < load_options_size) {
 591                         s2++;
 592                         options_size++;
 593                 }
 594         }
 595
 596         if (options_size == 0) {
 597                 /* No command line options, so return empty string*/
 598                 options_size = 1;
 599                 options = &zero;
 600         }
 601
 602         options_size++;  /* NUL termination */
 603 #ifdef CONFIG_ARM
 604         /*
 605          * For ARM, allocate at a high address to avoid reserved
 606          * regions at low addresses that we don't know the specfics of
 607          * at the time we are processing the command line.
 608          */
 609         status = efi_high_alloc(sys_table_arg, options_size, 0,
 610                             &cmdline_addr, 0xfffff000);
 611 #else
 612         status = efi_low_alloc(sys_table_arg, options_size, 0,
 613                             &cmdline_addr);
 614 #endif
 615         if (status != EFI_SUCCESS)
 616                 return NULL;
 617
 618         s1 = (u8 *)cmdline_addr;
 619         s2 = (u16 *)options;
 620
 621         for (i = 0; i < options_size - 1; i++)
 622                 *s1++ = *s2++;
 623
 624         *s1 = '\0';
 625
 626         *cmd_line_len = options_size;
 627         return (char *)cmdline_addr;
 628 }