Commit 3203209d authored by Matt Fleming's avatar Matt Fleming
Browse files

Merge branch 'arm/common' into next

parents 9efff389 4e283088

arch/x86/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -1579,7 +1579,7 @@ config EFI_STUB 
          This kernel feature allows a bzImage to be loaded directly

	  by EFI firmware without the use of a bootloader.



	  See Documentation/x86/efi-stub.txt for more information.

	  See Documentation/efi-stub.txt for more information.



config SECCOMP

	def_bool y

arch/x86/boot/compressed/eboot.c

+39 −541
Original line number Diff line number Diff line
@@ -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;



		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;

		}

	}

#include "../../../../drivers/firmware/efi/efi-stub-helper.c"



	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");

	cmdline_ptr = efi_convert_cmdline_to_ascii(sys_table, image,

						   &options_size);

	if (!cmdline_ptr)

		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;

	hdr->cmd_line_ptr = (unsigned long)cmdline_ptr;



	hdr->ramdisk_image = 0;

	hdr->ramdisk_size = 0;
@@ -969,16 +502,20 @@ 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;

}
@@ -996,25 +533,12 @@ static efi_status_t exit_boot(struct boot_params *boot_params, 
	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;

	}

	status = efi_get_memory_map(sys_table, &mem_map, &size, &desc_size,

				    &desc_version, &key);



	if (status != EFI_SUCCESS)

		goto free_mem_map;

		return status;



	memcpy(&efi->efi_loader_signature, EFI_LOADER_SIGNATURE, sizeof(__u32));

	efi->efi_systab = (unsigned long)sys_table;
@@ -1043,6 +567,7 @@ static efi_status_t exit_boot(struct boot_params *boot_params, 
			goto free_mem_map;



		called_exit = true;

		efi_call_phys1(sys_table->boottime->free_pool, mem_map);

		goto get_map;

	}
@@ -1111,44 +636,10 @@ static efi_status_t exit_boot(struct boot_params *boot_params, 
	return EFI_SUCCESS;



free_mem_map:

	low_free(_size, (unsigned long)mem_map);

	efi_call_phys1(sys_table->boottime->free_pool, mem_map);

	return status;

}



static efi_status_t relocate_kernel(struct setup_header *hdr)

{

	unsigned long start, nr_pages;

	efi_status_t status;



	/*

	 * 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;



	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);

		if (status != EFI_SUCCESS)

			efi_printk("Failed to alloc mem for kernel\n");

	}



	if (status == EFI_SUCCESS)

		memcpy((void *)start, (void *)(unsigned long)hdr->code32_start,

		       hdr->init_size);



	hdr->pref_address = hdr->code32_start;

	hdr->code32_start = (__u32)start;



	return status;

}



/*

 * On success we return a pointer to a boot_params structure, and NULL
@@ -1177,14 +668,15 @@ 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);

	status = efi_low_alloc(sys_table, gdt->size, 8,

			   (unsigned long *)&gdt->address);

	if (status != EFI_SUCCESS) {

		efi_printk("Failed to alloc mem for gdt\n");

		efi_printk(sys_table, "Failed to alloc mem for gdt\n");

		goto fail;

	}
@@ -1192,7 +684,7 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table, 
				EFI_LOADER_DATA, sizeof(*idt),

				(void **)&idt);

	if (status != EFI_SUCCESS) {

		efi_printk("Failed to alloc mem for idt structure\n");

		efi_printk(sys_table, "Failed to alloc mem for idt structure\n");

		goto fail;

	}
@@ -1204,10 +696,16 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table, 
	 * 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);

arch/x86/boot/compressed/eboot.h

+0 −9
Original line number Diff line number Diff line
@@ -11,9 +11,6 @@ 


#define DESC_TYPE_CODE_DATA	(1 << 0)



#define EFI_PAGE_SIZE		(1UL << EFI_PAGE_SHIFT)

#define EFI_READ_CHUNK_SIZE	(1024 * 1024)



#define EFI_CONSOLE_OUT_DEVICE_GUID    \

	EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4, 0x9a, 0x46, 0x0, 0x90, 0x27, \

		  0x3f, 0xc1, 0x4d)
@@ -62,10 +59,4 @@ struct efi_uga_draw_protocol { 
	void *blt;

};



struct efi_simple_text_output_protocol {

	void *reset;

	void *output_string;

	void *test_string;

};



#endif /* BOOT_COMPRESSED_EBOOT_H */

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

0 → 100644
+638 −0

File added.

Preview size limit exceeded, changes collapsed.