|
@@ -19,214 +19,10 @@
|
|
|
|
|
|
static efi_system_table_t *sys_table;
|
|
|
|
|
|
-static void efi_char16_printk(efi_char16_t *str)
|
|
|
-{
|
|
|
- struct efi_simple_text_output_protocol *out;
|
|
|
-
|
|
|
- out = (struct efi_simple_text_output_protocol *)sys_table->con_out;
|
|
|
- efi_call_phys2(out->output_string, out, str);
|
|
|
-}
|
|
|
-
|
|
|
-static void efi_printk(char *str)
|
|
|
-{
|
|
|
- char *s8;
|
|
|
-
|
|
|
- for (s8 = str; *s8; s8++) {
|
|
|
- efi_char16_t ch[2] = { 0 };
|
|
|
-
|
|
|
- ch[0] = *s8;
|
|
|
- if (*s8 == '\n') {
|
|
|
- efi_char16_t nl[2] = { '\r', 0 };
|
|
|
- efi_char16_printk(nl);
|
|
|
- }
|
|
|
-
|
|
|
- efi_char16_printk(ch);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-static efi_status_t __get_map(efi_memory_desc_t **map, unsigned long *map_size,
|
|
|
- unsigned long *desc_size)
|
|
|
-{
|
|
|
- efi_memory_desc_t *m = NULL;
|
|
|
- efi_status_t status;
|
|
|
- unsigned long key;
|
|
|
- u32 desc_version;
|
|
|
-
|
|
|
- *map_size = sizeof(*m) * 32;
|
|
|
-again:
|
|
|
- /*
|
|
|
- * Add an additional efi_memory_desc_t because we're doing an
|
|
|
- * allocation which may be in a new descriptor region.
|
|
|
- */
|
|
|
- *map_size += sizeof(*m);
|
|
|
- status = efi_call_phys3(sys_table->boottime->allocate_pool,
|
|
|
- EFI_LOADER_DATA, *map_size, (void **)&m);
|
|
|
- if (status != EFI_SUCCESS)
|
|
|
- goto fail;
|
|
|
-
|
|
|
- status = efi_call_phys5(sys_table->boottime->get_memory_map, map_size,
|
|
|
- m, &key, desc_size, &desc_version);
|
|
|
- if (status == EFI_BUFFER_TOO_SMALL) {
|
|
|
- efi_call_phys1(sys_table->boottime->free_pool, m);
|
|
|
- goto again;
|
|
|
- }
|
|
|
-
|
|
|
- if (status != EFI_SUCCESS)
|
|
|
- efi_call_phys1(sys_table->boottime->free_pool, m);
|
|
|
|
|
|
-fail:
|
|
|
- *map = m;
|
|
|
- return status;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * Allocate at the highest possible address that is not above 'max'.
|
|
|
- */
|
|
|
-static efi_status_t high_alloc(unsigned long size, unsigned long align,
|
|
|
- unsigned long *addr, unsigned long max)
|
|
|
-{
|
|
|
- unsigned long map_size, desc_size;
|
|
|
- efi_memory_desc_t *map;
|
|
|
- efi_status_t status;
|
|
|
- unsigned long nr_pages;
|
|
|
- u64 max_addr = 0;
|
|
|
- int i;
|
|
|
-
|
|
|
- status = __get_map(&map, &map_size, &desc_size);
|
|
|
- if (status != EFI_SUCCESS)
|
|
|
- goto fail;
|
|
|
-
|
|
|
- nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
|
|
|
-again:
|
|
|
- for (i = 0; i < map_size / desc_size; i++) {
|
|
|
- efi_memory_desc_t *desc;
|
|
|
- unsigned long m = (unsigned long)map;
|
|
|
- u64 start, end;
|
|
|
-
|
|
|
- desc = (efi_memory_desc_t *)(m + (i * desc_size));
|
|
|
- if (desc->type != EFI_CONVENTIONAL_MEMORY)
|
|
|
- continue;
|
|
|
-
|
|
|
- if (desc->num_pages < nr_pages)
|
|
|
- continue;
|
|
|
+#include "../../../../drivers/firmware/efi/efi-stub-helper.c"
|
|
|
|
|
|
- start = desc->phys_addr;
|
|
|
- end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
|
|
|
|
|
|
- if ((start + size) > end || (start + size) > max)
|
|
|
- continue;
|
|
|
-
|
|
|
- if (end - size > max)
|
|
|
- end = max;
|
|
|
-
|
|
|
- if (round_down(end - size, align) < start)
|
|
|
- continue;
|
|
|
-
|
|
|
- start = round_down(end - size, align);
|
|
|
-
|
|
|
- /*
|
|
|
- * Don't allocate at 0x0. It will confuse code that
|
|
|
- * checks pointers against NULL.
|
|
|
- */
|
|
|
- if (start == 0x0)
|
|
|
- continue;
|
|
|
-
|
|
|
- if (start > max_addr)
|
|
|
- max_addr = start;
|
|
|
- }
|
|
|
-
|
|
|
- if (!max_addr)
|
|
|
- status = EFI_NOT_FOUND;
|
|
|
- else {
|
|
|
- status = efi_call_phys4(sys_table->boottime->allocate_pages,
|
|
|
- EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
|
|
|
- nr_pages, &max_addr);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- max = max_addr;
|
|
|
- max_addr = 0;
|
|
|
- goto again;
|
|
|
- }
|
|
|
-
|
|
|
- *addr = max_addr;
|
|
|
- }
|
|
|
-
|
|
|
-free_pool:
|
|
|
- efi_call_phys1(sys_table->boottime->free_pool, map);
|
|
|
-
|
|
|
-fail:
|
|
|
- return status;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * Allocate at the lowest possible address.
|
|
|
- */
|
|
|
-static efi_status_t low_alloc(unsigned long size, unsigned long align,
|
|
|
- unsigned long *addr)
|
|
|
-{
|
|
|
- unsigned long map_size, desc_size;
|
|
|
- efi_memory_desc_t *map;
|
|
|
- efi_status_t status;
|
|
|
- unsigned long nr_pages;
|
|
|
- int i;
|
|
|
-
|
|
|
- status = __get_map(&map, &map_size, &desc_size);
|
|
|
- if (status != EFI_SUCCESS)
|
|
|
- goto fail;
|
|
|
-
|
|
|
- nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
|
|
|
- for (i = 0; i < map_size / desc_size; i++) {
|
|
|
- efi_memory_desc_t *desc;
|
|
|
- unsigned long m = (unsigned long)map;
|
|
|
- u64 start, end;
|
|
|
-
|
|
|
- desc = (efi_memory_desc_t *)(m + (i * desc_size));
|
|
|
-
|
|
|
- if (desc->type != EFI_CONVENTIONAL_MEMORY)
|
|
|
- continue;
|
|
|
-
|
|
|
- if (desc->num_pages < nr_pages)
|
|
|
- continue;
|
|
|
-
|
|
|
- start = desc->phys_addr;
|
|
|
- end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
|
|
|
-
|
|
|
- /*
|
|
|
- * Don't allocate at 0x0. It will confuse code that
|
|
|
- * checks pointers against NULL. Skip the first 8
|
|
|
- * bytes so we start at a nice even number.
|
|
|
- */
|
|
|
- if (start == 0x0)
|
|
|
- start += 8;
|
|
|
-
|
|
|
- start = round_up(start, align);
|
|
|
- if ((start + size) > end)
|
|
|
- continue;
|
|
|
-
|
|
|
- status = efi_call_phys4(sys_table->boottime->allocate_pages,
|
|
|
- EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
|
|
|
- nr_pages, &start);
|
|
|
- if (status == EFI_SUCCESS) {
|
|
|
- *addr = start;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (i == map_size / desc_size)
|
|
|
- status = EFI_NOT_FOUND;
|
|
|
-
|
|
|
-free_pool:
|
|
|
- efi_call_phys1(sys_table->boottime->free_pool, map);
|
|
|
-fail:
|
|
|
- return status;
|
|
|
-}
|
|
|
-
|
|
|
-static void low_free(unsigned long size, unsigned long addr)
|
|
|
-{
|
|
|
- unsigned long nr_pages;
|
|
|
-
|
|
|
- nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
|
|
|
- efi_call_phys2(sys_table->boottime->free_pages, addr, nr_pages);
|
|
|
-}
|
|
|
|
|
|
static void find_bits(unsigned long mask, u8 *pos, u8 *size)
|
|
|
{
|
|
@@ -624,242 +420,6 @@ void setup_graphics(struct boot_params *boot_params)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-struct initrd {
|
|
|
- efi_file_handle_t *handle;
|
|
|
- u64 size;
|
|
|
-};
|
|
|
-
|
|
|
-/*
|
|
|
- * Check the cmdline for a LILO-style initrd= arguments.
|
|
|
- *
|
|
|
- * We only support loading an initrd from the same filesystem as the
|
|
|
- * kernel image.
|
|
|
- */
|
|
|
-static efi_status_t handle_ramdisks(efi_loaded_image_t *image,
|
|
|
- struct setup_header *hdr)
|
|
|
-{
|
|
|
- struct initrd *initrds;
|
|
|
- unsigned long initrd_addr;
|
|
|
- efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
|
|
|
- u64 initrd_total;
|
|
|
- efi_file_io_interface_t *io;
|
|
|
- efi_file_handle_t *fh;
|
|
|
- efi_status_t status;
|
|
|
- int nr_initrds;
|
|
|
- char *str;
|
|
|
- int i, j, k;
|
|
|
-
|
|
|
- initrd_addr = 0;
|
|
|
- initrd_total = 0;
|
|
|
-
|
|
|
- str = (char *)(unsigned long)hdr->cmd_line_ptr;
|
|
|
-
|
|
|
- j = 0; /* See close_handles */
|
|
|
-
|
|
|
- if (!str || !*str)
|
|
|
- return EFI_SUCCESS;
|
|
|
-
|
|
|
- for (nr_initrds = 0; *str; nr_initrds++) {
|
|
|
- str = strstr(str, "initrd=");
|
|
|
- if (!str)
|
|
|
- break;
|
|
|
-
|
|
|
- str += 7;
|
|
|
-
|
|
|
- /* Skip any leading slashes */
|
|
|
- while (*str == '/' || *str == '\\')
|
|
|
- str++;
|
|
|
-
|
|
|
- while (*str && *str != ' ' && *str != '\n')
|
|
|
- str++;
|
|
|
- }
|
|
|
-
|
|
|
- if (!nr_initrds)
|
|
|
- return EFI_SUCCESS;
|
|
|
-
|
|
|
- status = efi_call_phys3(sys_table->boottime->allocate_pool,
|
|
|
- EFI_LOADER_DATA,
|
|
|
- nr_initrds * sizeof(*initrds),
|
|
|
- &initrds);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to alloc mem for initrds\n");
|
|
|
- goto fail;
|
|
|
- }
|
|
|
-
|
|
|
- str = (char *)(unsigned long)hdr->cmd_line_ptr;
|
|
|
- for (i = 0; i < nr_initrds; i++) {
|
|
|
- struct initrd *initrd;
|
|
|
- efi_file_handle_t *h;
|
|
|
- efi_file_info_t *info;
|
|
|
- efi_char16_t filename_16[256];
|
|
|
- unsigned long info_sz;
|
|
|
- efi_guid_t info_guid = EFI_FILE_INFO_ID;
|
|
|
- efi_char16_t *p;
|
|
|
- u64 file_sz;
|
|
|
-
|
|
|
- str = strstr(str, "initrd=");
|
|
|
- if (!str)
|
|
|
- break;
|
|
|
-
|
|
|
- str += 7;
|
|
|
-
|
|
|
- initrd = &initrds[i];
|
|
|
- p = filename_16;
|
|
|
-
|
|
|
- /* Skip any leading slashes */
|
|
|
- while (*str == '/' || *str == '\\')
|
|
|
- str++;
|
|
|
-
|
|
|
- while (*str && *str != ' ' && *str != '\n') {
|
|
|
- if ((u8 *)p >= (u8 *)filename_16 + sizeof(filename_16))
|
|
|
- break;
|
|
|
-
|
|
|
- if (*str == '/') {
|
|
|
- *p++ = '\\';
|
|
|
- *str++;
|
|
|
- } else {
|
|
|
- *p++ = *str++;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- *p = '\0';
|
|
|
-
|
|
|
- /* Only open the volume once. */
|
|
|
- if (!i) {
|
|
|
- efi_boot_services_t *boottime;
|
|
|
-
|
|
|
- boottime = sys_table->boottime;
|
|
|
-
|
|
|
- status = efi_call_phys3(boottime->handle_protocol,
|
|
|
- image->device_handle, &fs_proto, &io);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to handle fs_proto\n");
|
|
|
- goto free_initrds;
|
|
|
- }
|
|
|
-
|
|
|
- status = efi_call_phys2(io->open_volume, io, &fh);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to open volume\n");
|
|
|
- goto free_initrds;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- status = efi_call_phys5(fh->open, fh, &h, filename_16,
|
|
|
- EFI_FILE_MODE_READ, (u64)0);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to open initrd file: ");
|
|
|
- efi_char16_printk(filename_16);
|
|
|
- efi_printk("\n");
|
|
|
- goto close_handles;
|
|
|
- }
|
|
|
-
|
|
|
- initrd->handle = h;
|
|
|
-
|
|
|
- info_sz = 0;
|
|
|
- status = efi_call_phys4(h->get_info, h, &info_guid,
|
|
|
- &info_sz, NULL);
|
|
|
- if (status != EFI_BUFFER_TOO_SMALL) {
|
|
|
- efi_printk("Failed to get initrd info size\n");
|
|
|
- goto close_handles;
|
|
|
- }
|
|
|
-
|
|
|
-grow:
|
|
|
- status = efi_call_phys3(sys_table->boottime->allocate_pool,
|
|
|
- EFI_LOADER_DATA, info_sz, &info);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to alloc mem for initrd info\n");
|
|
|
- goto close_handles;
|
|
|
- }
|
|
|
-
|
|
|
- status = efi_call_phys4(h->get_info, h, &info_guid,
|
|
|
- &info_sz, info);
|
|
|
- if (status == EFI_BUFFER_TOO_SMALL) {
|
|
|
- efi_call_phys1(sys_table->boottime->free_pool, info);
|
|
|
- goto grow;
|
|
|
- }
|
|
|
-
|
|
|
- file_sz = info->file_size;
|
|
|
- efi_call_phys1(sys_table->boottime->free_pool, info);
|
|
|
-
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to get initrd info\n");
|
|
|
- goto close_handles;
|
|
|
- }
|
|
|
-
|
|
|
- initrd->size = file_sz;
|
|
|
- initrd_total += file_sz;
|
|
|
- }
|
|
|
-
|
|
|
- if (initrd_total) {
|
|
|
- unsigned long addr;
|
|
|
-
|
|
|
- /*
|
|
|
- * Multiple initrd's need to be at consecutive
|
|
|
- * addresses in memory, so allocate enough memory for
|
|
|
- * all the initrd's.
|
|
|
- */
|
|
|
- status = high_alloc(initrd_total, 0x1000,
|
|
|
- &initrd_addr, hdr->initrd_addr_max);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to alloc highmem for initrds\n");
|
|
|
- goto close_handles;
|
|
|
- }
|
|
|
-
|
|
|
- /* We've run out of free low memory. */
|
|
|
- if (initrd_addr > hdr->initrd_addr_max) {
|
|
|
- efi_printk("We've run out of free low memory\n");
|
|
|
- status = EFI_INVALID_PARAMETER;
|
|
|
- goto free_initrd_total;
|
|
|
- }
|
|
|
-
|
|
|
- addr = initrd_addr;
|
|
|
- for (j = 0; j < nr_initrds; j++) {
|
|
|
- u64 size;
|
|
|
-
|
|
|
- size = initrds[j].size;
|
|
|
- while (size) {
|
|
|
- u64 chunksize;
|
|
|
- if (size > EFI_READ_CHUNK_SIZE)
|
|
|
- chunksize = EFI_READ_CHUNK_SIZE;
|
|
|
- else
|
|
|
- chunksize = size;
|
|
|
- status = efi_call_phys3(fh->read,
|
|
|
- initrds[j].handle,
|
|
|
- &chunksize, addr);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to read initrd\n");
|
|
|
- goto free_initrd_total;
|
|
|
- }
|
|
|
- addr += chunksize;
|
|
|
- size -= chunksize;
|
|
|
- }
|
|
|
-
|
|
|
- efi_call_phys1(fh->close, initrds[j].handle);
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- efi_call_phys1(sys_table->boottime->free_pool, initrds);
|
|
|
-
|
|
|
- hdr->ramdisk_image = initrd_addr;
|
|
|
- hdr->ramdisk_size = initrd_total;
|
|
|
-
|
|
|
- return status;
|
|
|
-
|
|
|
-free_initrd_total:
|
|
|
- low_free(initrd_total, initrd_addr);
|
|
|
-
|
|
|
-close_handles:
|
|
|
- for (k = j; k < i; k++)
|
|
|
- efi_call_phys1(fh->close, initrds[k].handle);
|
|
|
-free_initrds:
|
|
|
- efi_call_phys1(sys_table->boottime->free_pool, initrds);
|
|
|
-fail:
|
|
|
- hdr->ramdisk_image = 0;
|
|
|
- hdr->ramdisk_size = 0;
|
|
|
-
|
|
|
- return status;
|
|
|
-}
|
|
|
|
|
|
/*
|
|
|
* Because the x86 boot code expects to be passed a boot_params we
|
|
@@ -875,14 +435,15 @@ struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
|
|
|
struct efi_info *efi;
|
|
|
efi_loaded_image_t *image;
|
|
|
void *options;
|
|
|
- u32 load_options_size;
|
|
|
efi_guid_t proto = LOADED_IMAGE_PROTOCOL_GUID;
|
|
|
int options_size = 0;
|
|
|
efi_status_t status;
|
|
|
- unsigned long cmdline;
|
|
|
+ char *cmdline_ptr;
|
|
|
u16 *s2;
|
|
|
u8 *s1;
|
|
|
int i;
|
|
|
+ unsigned long ramdisk_addr;
|
|
|
+ unsigned long ramdisk_size;
|
|
|
|
|
|
sys_table = _table;
|
|
|
|
|
@@ -893,13 +454,14 @@ struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
|
|
|
status = efi_call_phys3(sys_table->boottime->handle_protocol,
|
|
|
handle, &proto, (void *)&image);
|
|
|
if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to get handle for LOADED_IMAGE_PROTOCOL\n");
|
|
|
+ efi_printk(sys_table, "Failed to get handle for LOADED_IMAGE_PROTOCOL\n");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
- status = low_alloc(0x4000, 1, (unsigned long *)&boot_params);
|
|
|
+ status = efi_low_alloc(sys_table, 0x4000, 1,
|
|
|
+ (unsigned long *)&boot_params);
|
|
|
if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to alloc lowmem for boot params\n");
|
|
|
+ efi_printk(sys_table, "Failed to alloc lowmem for boot params\n");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
@@ -926,40 +488,11 @@ struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
|
|
|
hdr->type_of_loader = 0x21;
|
|
|
|
|
|
/* Convert unicode cmdline to ascii */
|
|
|
- options = image->load_options;
|
|
|
- load_options_size = image->load_options_size / 2; /* ASCII */
|
|
|
- cmdline = 0;
|
|
|
- s2 = (u16 *)options;
|
|
|
-
|
|
|
- if (s2) {
|
|
|
- while (*s2 && *s2 != '\n' && options_size < load_options_size) {
|
|
|
- s2++;
|
|
|
- options_size++;
|
|
|
- }
|
|
|
-
|
|
|
- if (options_size) {
|
|
|
- if (options_size > hdr->cmdline_size)
|
|
|
- options_size = hdr->cmdline_size;
|
|
|
-
|
|
|
- options_size++; /* NUL termination */
|
|
|
-
|
|
|
- status = low_alloc(options_size, 1, &cmdline);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to alloc mem for cmdline\n");
|
|
|
- goto fail;
|
|
|
- }
|
|
|
-
|
|
|
- s1 = (u8 *)(unsigned long)cmdline;
|
|
|
- s2 = (u16 *)options;
|
|
|
-
|
|
|
- for (i = 0; i < options_size - 1; i++)
|
|
|
- *s1++ = *s2++;
|
|
|
-
|
|
|
- *s1 = '\0';
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- hdr->cmd_line_ptr = cmdline;
|
|
|
+ cmdline_ptr = efi_convert_cmdline_to_ascii(sys_table, image,
|
|
|
+ &options_size);
|
|
|
+ if (!cmdline_ptr)
|
|
|
+ goto fail;
|
|
|
+ hdr->cmd_line_ptr = (unsigned long)cmdline_ptr;
|
|
|
|
|
|
hdr->ramdisk_image = 0;
|
|
|
hdr->ramdisk_size = 0;
|
|
@@ -969,96 +502,64 @@ struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
|
|
|
|
|
|
memset(sdt, 0, sizeof(*sdt));
|
|
|
|
|
|
- status = handle_ramdisks(image, hdr);
|
|
|
+ status = handle_cmdline_files(sys_table, image,
|
|
|
+ (char *)(unsigned long)hdr->cmd_line_ptr,
|
|
|
+ "initrd=", hdr->initrd_addr_max,
|
|
|
+ &ramdisk_addr, &ramdisk_size);
|
|
|
if (status != EFI_SUCCESS)
|
|
|
goto fail2;
|
|
|
+ hdr->ramdisk_image = ramdisk_addr;
|
|
|
+ hdr->ramdisk_size = ramdisk_size;
|
|
|
|
|
|
return boot_params;
|
|
|
fail2:
|
|
|
- if (options_size)
|
|
|
- low_free(options_size, hdr->cmd_line_ptr);
|
|
|
+ efi_free(sys_table, options_size, hdr->cmd_line_ptr);
|
|
|
fail:
|
|
|
- low_free(0x4000, (unsigned long)boot_params);
|
|
|
+ efi_free(sys_table, 0x4000, (unsigned long)boot_params);
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
-static efi_status_t exit_boot(struct boot_params *boot_params,
|
|
|
- void *handle)
|
|
|
+static void add_e820ext(struct boot_params *params,
|
|
|
+ struct setup_data *e820ext, u32 nr_entries)
|
|
|
{
|
|
|
- struct efi_info *efi = &boot_params->efi_info;
|
|
|
- struct e820entry *e820_map = &boot_params->e820_map[0];
|
|
|
- struct e820entry *prev = NULL;
|
|
|
- unsigned long size, key, desc_size, _size;
|
|
|
- efi_memory_desc_t *mem_map;
|
|
|
+ struct setup_data *data;
|
|
|
efi_status_t status;
|
|
|
- __u32 desc_version;
|
|
|
- bool called_exit = false;
|
|
|
- u8 nr_entries;
|
|
|
- int i;
|
|
|
-
|
|
|
- size = sizeof(*mem_map) * 32;
|
|
|
-
|
|
|
-again:
|
|
|
- size += sizeof(*mem_map) * 2;
|
|
|
- _size = size;
|
|
|
- status = low_alloc(size, 1, (unsigned long *)&mem_map);
|
|
|
- if (status != EFI_SUCCESS)
|
|
|
- return status;
|
|
|
-
|
|
|
-get_map:
|
|
|
- status = efi_call_phys5(sys_table->boottime->get_memory_map, &size,
|
|
|
- mem_map, &key, &desc_size, &desc_version);
|
|
|
- if (status == EFI_BUFFER_TOO_SMALL) {
|
|
|
- low_free(_size, (unsigned long)mem_map);
|
|
|
- goto again;
|
|
|
- }
|
|
|
+ unsigned long size;
|
|
|
|
|
|
- if (status != EFI_SUCCESS)
|
|
|
- goto free_mem_map;
|
|
|
+ e820ext->type = SETUP_E820_EXT;
|
|
|
+ e820ext->len = nr_entries * sizeof(struct e820entry);
|
|
|
+ e820ext->next = 0;
|
|
|
|
|
|
- memcpy(&efi->efi_loader_signature, EFI_LOADER_SIGNATURE, sizeof(__u32));
|
|
|
- efi->efi_systab = (unsigned long)sys_table;
|
|
|
- efi->efi_memdesc_size = desc_size;
|
|
|
- efi->efi_memdesc_version = desc_version;
|
|
|
- efi->efi_memmap = (unsigned long)mem_map;
|
|
|
- efi->efi_memmap_size = size;
|
|
|
-
|
|
|
-#ifdef CONFIG_X86_64
|
|
|
- efi->efi_systab_hi = (unsigned long)sys_table >> 32;
|
|
|
- efi->efi_memmap_hi = (unsigned long)mem_map >> 32;
|
|
|
-#endif
|
|
|
+ data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
|
|
|
|
|
|
- /* Might as well exit boot services now */
|
|
|
- status = efi_call_phys2(sys_table->boottime->exit_boot_services,
|
|
|
- handle, key);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- /*
|
|
|
- * ExitBootServices() will fail if any of the event
|
|
|
- * handlers change the memory map. In which case, we
|
|
|
- * must be prepared to retry, but only once so that
|
|
|
- * we're guaranteed to exit on repeated failures instead
|
|
|
- * of spinning forever.
|
|
|
- */
|
|
|
- if (called_exit)
|
|
|
- goto free_mem_map;
|
|
|
+ while (data && data->next)
|
|
|
+ data = (struct setup_data *)(unsigned long)data->next;
|
|
|
|
|
|
- called_exit = true;
|
|
|
- goto get_map;
|
|
|
- }
|
|
|
+ if (data)
|
|
|
+ data->next = (unsigned long)e820ext;
|
|
|
+ else
|
|
|
+ params->hdr.setup_data = (unsigned long)e820ext;
|
|
|
+}
|
|
|
|
|
|
- /* Historic? */
|
|
|
- boot_params->alt_mem_k = 32 * 1024;
|
|
|
+static efi_status_t setup_e820(struct boot_params *params,
|
|
|
+ struct setup_data *e820ext, u32 e820ext_size)
|
|
|
+{
|
|
|
+ struct e820entry *e820_map = ¶ms->e820_map[0];
|
|
|
+ struct efi_info *efi = ¶ms->efi_info;
|
|
|
+ struct e820entry *prev = NULL;
|
|
|
+ u32 nr_entries;
|
|
|
+ u32 nr_desc;
|
|
|
+ int i;
|
|
|
|
|
|
- /*
|
|
|
- * Convert the EFI memory map to E820.
|
|
|
- */
|
|
|
nr_entries = 0;
|
|
|
- for (i = 0; i < size / desc_size; i++) {
|
|
|
+ nr_desc = efi->efi_memmap_size / efi->efi_memdesc_size;
|
|
|
+
|
|
|
+ for (i = 0; i < nr_desc; i++) {
|
|
|
efi_memory_desc_t *d;
|
|
|
unsigned int e820_type = 0;
|
|
|
- unsigned long m = (unsigned long)mem_map;
|
|
|
+ unsigned long m = efi->efi_memmap;
|
|
|
|
|
|
- d = (efi_memory_desc_t *)(m + (i * desc_size));
|
|
|
+ d = (efi_memory_desc_t *)(m + (i * efi->efi_memdesc_size));
|
|
|
switch (d->type) {
|
|
|
case EFI_RESERVED_TYPE:
|
|
|
case EFI_RUNTIME_SERVICES_CODE:
|
|
@@ -1095,61 +596,151 @@ get_map:
|
|
|
|
|
|
/* Merge adjacent mappings */
|
|
|
if (prev && prev->type == e820_type &&
|
|
|
- (prev->addr + prev->size) == d->phys_addr)
|
|
|
+ (prev->addr + prev->size) == d->phys_addr) {
|
|
|
prev->size += d->num_pages << 12;
|
|
|
- else {
|
|
|
- e820_map->addr = d->phys_addr;
|
|
|
- e820_map->size = d->num_pages << 12;
|
|
|
- e820_map->type = e820_type;
|
|
|
- prev = e820_map++;
|
|
|
- nr_entries++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (nr_entries == ARRAY_SIZE(params->e820_map)) {
|
|
|
+ u32 need = (nr_desc - i) * sizeof(struct e820entry) +
|
|
|
+ sizeof(struct setup_data);
|
|
|
+
|
|
|
+ if (!e820ext || e820ext_size < need)
|
|
|
+ return EFI_BUFFER_TOO_SMALL;
|
|
|
+
|
|
|
+ /* boot_params map full, switch to e820 extended */
|
|
|
+ e820_map = (struct e820entry *)e820ext->data;
|
|
|
}
|
|
|
+
|
|
|
+ e820_map->addr = d->phys_addr;
|
|
|
+ e820_map->size = d->num_pages << PAGE_SHIFT;
|
|
|
+ e820_map->type = e820_type;
|
|
|
+ prev = e820_map++;
|
|
|
+ nr_entries++;
|
|
|
}
|
|
|
|
|
|
- boot_params->e820_entries = nr_entries;
|
|
|
+ if (nr_entries > ARRAY_SIZE(params->e820_map)) {
|
|
|
+ u32 nr_e820ext = nr_entries - ARRAY_SIZE(params->e820_map);
|
|
|
+
|
|
|
+ add_e820ext(params, e820ext, nr_e820ext);
|
|
|
+ nr_entries -= nr_e820ext;
|
|
|
+ }
|
|
|
+
|
|
|
+ params->e820_entries = (u8)nr_entries;
|
|
|
|
|
|
return EFI_SUCCESS;
|
|
|
+}
|
|
|
+
|
|
|
+static efi_status_t alloc_e820ext(u32 nr_desc, struct setup_data **e820ext,
|
|
|
+ u32 *e820ext_size)
|
|
|
+{
|
|
|
+ efi_status_t status;
|
|
|
+ unsigned long size;
|
|
|
+
|
|
|
+ size = sizeof(struct setup_data) +
|
|
|
+ sizeof(struct e820entry) * nr_desc;
|
|
|
+
|
|
|
+ if (*e820ext) {
|
|
|
+ efi_call_phys1(sys_table->boottime->free_pool, *e820ext);
|
|
|
+ *e820ext = NULL;
|
|
|
+ *e820ext_size = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ status = efi_call_phys3(sys_table->boottime->allocate_pool,
|
|
|
+ EFI_LOADER_DATA, size, e820ext);
|
|
|
+
|
|
|
+ if (status == EFI_SUCCESS)
|
|
|
+ *e820ext_size = size;
|
|
|
|
|
|
-free_mem_map:
|
|
|
- low_free(_size, (unsigned long)mem_map);
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
-static efi_status_t relocate_kernel(struct setup_header *hdr)
|
|
|
+static efi_status_t exit_boot(struct boot_params *boot_params,
|
|
|
+ void *handle)
|
|
|
{
|
|
|
- unsigned long start, nr_pages;
|
|
|
+ struct efi_info *efi = &boot_params->efi_info;
|
|
|
+ unsigned long map_sz, key, desc_size;
|
|
|
+ efi_memory_desc_t *mem_map;
|
|
|
+ struct setup_data *e820ext;
|
|
|
+ __u32 e820ext_size;
|
|
|
+ __u32 nr_desc, prev_nr_desc;
|
|
|
efi_status_t status;
|
|
|
+ __u32 desc_version;
|
|
|
+ bool called_exit = false;
|
|
|
+ u8 nr_entries;
|
|
|
+ int i;
|
|
|
|
|
|
- /*
|
|
|
- * The EFI firmware loader could have placed the kernel image
|
|
|
- * anywhere in memory, but the kernel has various restrictions
|
|
|
- * on the max physical address it can run at. Attempt to move
|
|
|
- * the kernel to boot_params.pref_address, or as low as
|
|
|
- * possible.
|
|
|
- */
|
|
|
- start = hdr->pref_address;
|
|
|
- nr_pages = round_up(hdr->init_size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
|
|
|
+ nr_desc = 0;
|
|
|
+ e820ext = NULL;
|
|
|
+ e820ext_size = 0;
|
|
|
|
|
|
- status = efi_call_phys4(sys_table->boottime->allocate_pages,
|
|
|
- EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
|
|
|
- nr_pages, &start);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- status = low_alloc(hdr->init_size, hdr->kernel_alignment,
|
|
|
- &start);
|
|
|
+get_map:
|
|
|
+ status = efi_get_memory_map(sys_table, &mem_map, &map_sz, &desc_size,
|
|
|
+ &desc_version, &key);
|
|
|
+
|
|
|
+ if (status != EFI_SUCCESS)
|
|
|
+ return status;
|
|
|
+
|
|
|
+ prev_nr_desc = nr_desc;
|
|
|
+ nr_desc = map_sz / desc_size;
|
|
|
+ if (nr_desc > prev_nr_desc &&
|
|
|
+ nr_desc > ARRAY_SIZE(boot_params->e820_map)) {
|
|
|
+ u32 nr_e820ext = nr_desc - ARRAY_SIZE(boot_params->e820_map);
|
|
|
+
|
|
|
+ status = alloc_e820ext(nr_e820ext, &e820ext, &e820ext_size);
|
|
|
if (status != EFI_SUCCESS)
|
|
|
- efi_printk("Failed to alloc mem for kernel\n");
|
|
|
+ goto free_mem_map;
|
|
|
+
|
|
|
+ efi_call_phys1(sys_table->boottime->free_pool, mem_map);
|
|
|
+ goto get_map; /* Allocated memory, get map again */
|
|
|
}
|
|
|
|
|
|
- if (status == EFI_SUCCESS)
|
|
|
- memcpy((void *)start, (void *)(unsigned long)hdr->code32_start,
|
|
|
- hdr->init_size);
|
|
|
+ memcpy(&efi->efi_loader_signature, EFI_LOADER_SIGNATURE, sizeof(__u32));
|
|
|
+ efi->efi_systab = (unsigned long)sys_table;
|
|
|
+ efi->efi_memdesc_size = desc_size;
|
|
|
+ efi->efi_memdesc_version = desc_version;
|
|
|
+ efi->efi_memmap = (unsigned long)mem_map;
|
|
|
+ efi->efi_memmap_size = map_sz;
|
|
|
+
|
|
|
+#ifdef CONFIG_X86_64
|
|
|
+ efi->efi_systab_hi = (unsigned long)sys_table >> 32;
|
|
|
+ efi->efi_memmap_hi = (unsigned long)mem_map >> 32;
|
|
|
+#endif
|
|
|
|
|
|
- hdr->pref_address = hdr->code32_start;
|
|
|
- hdr->code32_start = (__u32)start;
|
|
|
+ /* Might as well exit boot services now */
|
|
|
+ status = efi_call_phys2(sys_table->boottime->exit_boot_services,
|
|
|
+ handle, key);
|
|
|
+ if (status != EFI_SUCCESS) {
|
|
|
+ /*
|
|
|
+ * ExitBootServices() will fail if any of the event
|
|
|
+ * handlers change the memory map. In which case, we
|
|
|
+ * must be prepared to retry, but only once so that
|
|
|
+ * we're guaranteed to exit on repeated failures instead
|
|
|
+ * of spinning forever.
|
|
|
+ */
|
|
|
+ if (called_exit)
|
|
|
+ goto free_mem_map;
|
|
|
|
|
|
+ called_exit = true;
|
|
|
+ efi_call_phys1(sys_table->boottime->free_pool, mem_map);
|
|
|
+ goto get_map;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Historic? */
|
|
|
+ boot_params->alt_mem_k = 32 * 1024;
|
|
|
+
|
|
|
+ status = setup_e820(boot_params, e820ext, e820ext_size);
|
|
|
+ if (status != EFI_SUCCESS)
|
|
|
+ return status;
|
|
|
+
|
|
|
+ return EFI_SUCCESS;
|
|
|
+
|
|
|
+free_mem_map:
|
|
|
+ efi_call_phys1(sys_table->boottime->free_pool, mem_map);
|
|
|
return status;
|
|
|
}
|
|
|
|
|
|
+
|
|
|
/*
|
|
|
* On success we return a pointer to a boot_params structure, and NULL
|
|
|
* on failure.
|
|
@@ -1157,7 +748,7 @@ static efi_status_t relocate_kernel(struct setup_header *hdr)
|
|
|
struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
|
|
|
struct boot_params *boot_params)
|
|
|
{
|
|
|
- struct desc_ptr *gdt, *idt;
|
|
|
+ struct desc_ptr *gdt;
|
|
|
efi_loaded_image_t *image;
|
|
|
struct setup_header *hdr = &boot_params->hdr;
|
|
|
efi_status_t status;
|
|
@@ -1177,37 +768,33 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
|
|
|
EFI_LOADER_DATA, sizeof(*gdt),
|
|
|
(void **)&gdt);
|
|
|
if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to alloc mem for gdt structure\n");
|
|
|
+ efi_printk(sys_table, "Failed to alloc mem for gdt structure\n");
|
|
|
goto fail;
|
|
|
}
|
|
|
|
|
|
gdt->size = 0x800;
|
|
|
- status = low_alloc(gdt->size, 8, (unsigned long *)&gdt->address);
|
|
|
- if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to alloc mem for gdt\n");
|
|
|
- goto fail;
|
|
|
- }
|
|
|
-
|
|
|
- status = efi_call_phys3(sys_table->boottime->allocate_pool,
|
|
|
- EFI_LOADER_DATA, sizeof(*idt),
|
|
|
- (void **)&idt);
|
|
|
+ status = efi_low_alloc(sys_table, gdt->size, 8,
|
|
|
+ (unsigned long *)&gdt->address);
|
|
|
if (status != EFI_SUCCESS) {
|
|
|
- efi_printk("Failed to alloc mem for idt structure\n");
|
|
|
+ efi_printk(sys_table, "Failed to alloc mem for gdt\n");
|
|
|
goto fail;
|
|
|
}
|
|
|
|
|
|
- idt->size = 0;
|
|
|
- idt->address = 0;
|
|
|
-
|
|
|
/*
|
|
|
* If the kernel isn't already loaded at the preferred load
|
|
|
* address, relocate it.
|
|
|
*/
|
|
|
if (hdr->pref_address != hdr->code32_start) {
|
|
|
- status = relocate_kernel(hdr);
|
|
|
-
|
|
|
+ unsigned long bzimage_addr = hdr->code32_start;
|
|
|
+ status = efi_relocate_kernel(sys_table, &bzimage_addr,
|
|
|
+ hdr->init_size, hdr->init_size,
|
|
|
+ hdr->pref_address,
|
|
|
+ hdr->kernel_alignment);
|
|
|
if (status != EFI_SUCCESS)
|
|
|
goto fail;
|
|
|
+
|
|
|
+ hdr->pref_address = hdr->code32_start;
|
|
|
+ hdr->code32_start = bzimage_addr;
|
|
|
}
|
|
|
|
|
|
status = exit_boot(boot_params, handle);
|
|
@@ -1267,10 +854,8 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
|
|
|
desc->base2 = 0x00;
|
|
|
#endif /* CONFIG_X86_64 */
|
|
|
|
|
|
- asm volatile ("lidt %0" : : "m" (*idt));
|
|
|
- asm volatile ("lgdt %0" : : "m" (*gdt));
|
|
|
-
|
|
|
asm volatile("cli");
|
|
|
+ asm volatile ("lgdt %0" : : "m" (*gdt));
|
|
|
|
|
|
return boot_params;
|
|
|
fail:
|