Merge branch 'arm/common' into next (3203209d) · Commits · e / devices / android_kernel_xiaomi_markw

Documentation/x86/efi-stub.txt→Documentation/efi-stub.txt

+0 −0

File moved.

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 @@ get_map:
		goto free_mem_map;

		called_exit = true;
		efi_call_phys1(sys_table->boottime->free_pool, mem_map);
		goto get_map;
		}

		@@ -1111,44 +636,10 @@ get_map:
		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.