efi: Remove global 'memmap' EFI memory map (884f4f66) · Commits · 戴 / test

arch/x86/platform/efi/efi.c

+47 −37

Original line number	Original line	Diff line number	Diff line
	@@ -56,8 +56,6 @@

	#define EFI_DEBUG		#define EFI_DEBUG

	struct efi_memory_map memmap;

	static struct efi efi_phys __initdata;		static struct efi efi_phys __initdata;
	static efi_system_table_t efi_systab __initdata;		static efi_system_table_t efi_systab __initdata;

	@@ -207,15 +205,13 @@ int __init efi_memblock_x86_reserve_range(void)
	#else		#else
	pmap = (e->efi_memmap \| ((__u64)e->efi_memmap_hi << 32));		pmap = (e->efi_memmap \| ((__u64)e->efi_memmap_hi << 32));
	#endif		#endif
	memmap.phys_map = pmap;		efi.memmap.phys_map = pmap;
	memmap.nr_map = e->efi_memmap_size /		efi.memmap.nr_map = e->efi_memmap_size /
	e->efi_memdesc_size;		e->efi_memdesc_size;
	memmap.desc_size = e->efi_memdesc_size;		efi.memmap.desc_size = e->efi_memdesc_size;
	memmap.desc_version = e->efi_memdesc_version;		efi.memmap.desc_version = e->efi_memdesc_version;

	memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);

	efi.memmap = &memmap;		memblock_reserve(pmap, efi.memmap.nr_map * efi.memmap.desc_size);

	return 0;		return 0;
	}		}
	@@ -240,10 +236,14 @@ void __init efi_print_memmap(void)

	void __init efi_unmap_memmap(void)		void __init efi_unmap_memmap(void)
	{		{
			unsigned long size;

	clear_bit(EFI_MEMMAP, &efi.flags);		clear_bit(EFI_MEMMAP, &efi.flags);
	if (memmap.map) {
	early_memunmap(memmap.map, memmap.nr_map * memmap.desc_size);		size = efi.memmap.nr_map * efi.memmap.desc_size;
	memmap.map = NULL;		if (efi.memmap.map) {
			early_memunmap(efi.memmap.map, size);
			efi.memmap.map = NULL;
	}		}
	}		}

	@@ -432,17 +432,22 @@ static int __init efi_runtime_init(void)

	static int __init efi_memmap_init(void)		static int __init efi_memmap_init(void)
	{		{
			unsigned long addr, size;

	if (efi_enabled(EFI_PARAVIRT))		if (efi_enabled(EFI_PARAVIRT))
	return 0;		return 0;

	/* Map the EFI memory map */		/* Map the EFI memory map */
	memmap.map = early_memremap((unsigned long)memmap.phys_map,		size = efi.memmap.nr_map * efi.memmap.desc_size;
	memmap.nr_map * memmap.desc_size);		addr = (unsigned long)efi.memmap.phys_map;
	if (memmap.map == NULL) {
			efi.memmap.map = early_memremap(addr, size);
			if (efi.memmap.map == NULL) {
	pr_err("Could not map the memory map!\n");		pr_err("Could not map the memory map!\n");
	return -ENOMEM;		return -ENOMEM;
	}		}
	memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
			efi.memmap.map_end = efi.memmap.map + size;

	if (add_efi_memmap)		if (add_efi_memmap)
	do_add_efi_memmap();		do_add_efi_memmap();
	@@ -638,6 +643,7 @@ static void __init get_systab_virt_addr(efi_memory_desc_t *md)
	static void __init save_runtime_map(void)		static void __init save_runtime_map(void)
	{		{
	#ifdef CONFIG_KEXEC_CORE		#ifdef CONFIG_KEXEC_CORE
			unsigned long desc_size;
	efi_memory_desc_t *md;		efi_memory_desc_t *md;
	void tmp, q = NULL;		void tmp, q = NULL;
	int count = 0;		int count = 0;
	@@ -645,21 +651,23 @@ static void __init save_runtime_map(void)
	if (efi_enabled(EFI_OLD_MEMMAP))		if (efi_enabled(EFI_OLD_MEMMAP))
	return;		return;

			desc_size = efi.memmap.desc_size;

	for_each_efi_memory_desc(md) {		for_each_efi_memory_desc(md) {
	if (!(md->attribute & EFI_MEMORY_RUNTIME) \|\|		if (!(md->attribute & EFI_MEMORY_RUNTIME) \|\|
	(md->type == EFI_BOOT_SERVICES_CODE) \|\|		(md->type == EFI_BOOT_SERVICES_CODE) \|\|
	(md->type == EFI_BOOT_SERVICES_DATA))		(md->type == EFI_BOOT_SERVICES_DATA))
	continue;		continue;
	tmp = krealloc(q, (count + 1) * memmap.desc_size, GFP_KERNEL);		tmp = krealloc(q, (count + 1) * desc_size, GFP_KERNEL);
	if (!tmp)		if (!tmp)
	goto out;		goto out;
	q = tmp;		q = tmp;

	memcpy(q + count * memmap.desc_size, md, memmap.desc_size);		memcpy(q + count * desc_size, md, desc_size);
	count++;		count++;
	}		}

	efi_runtime_map_setup(q, count, memmap.desc_size);		efi_runtime_map_setup(q, count, desc_size);
	return;		return;

	out:		out:
	@@ -699,10 +707,10 @@ static inline void efi_map_next_entry_reverse(void entry)
	{		{
	/* Initial call */		/* Initial call */
	if (!entry)		if (!entry)
	return memmap.map_end - memmap.desc_size;		return efi.memmap.map_end - efi.memmap.desc_size;

	entry -= memmap.desc_size;		entry -= efi.memmap.desc_size;
	if (entry < memmap.map)		if (entry < efi.memmap.map)
	return NULL;		return NULL;

	return entry;		return entry;
	@@ -744,10 +752,10 @@ static void efi_map_next_entry(void entry)

	/* Initial call */		/* Initial call */
	if (!entry)		if (!entry)
	return memmap.map;		return efi.memmap.map;

	entry += memmap.desc_size;		entry += efi.memmap.desc_size;
	if (entry >= memmap.map_end)		if (entry >= efi.memmap.map_end)
	return NULL;		return NULL;

	return entry;		return entry;
	@@ -761,8 +769,11 @@ static void * __init efi_map_regions(int count, int pg_shift)
	{		{
	void p, new_memmap = NULL;		void p, new_memmap = NULL;
	unsigned long left = 0;		unsigned long left = 0;
			unsigned long desc_size;
	efi_memory_desc_t *md;		efi_memory_desc_t *md;

			desc_size = efi.memmap.desc_size;

	p = NULL;		p = NULL;
	while ((p = efi_map_next_entry(p))) {		while ((p = efi_map_next_entry(p))) {
	md = p;		md = p;
	@@ -777,7 +788,7 @@ static void * __init efi_map_regions(int count, int pg_shift)
	efi_map_region(md);		efi_map_region(md);
	get_systab_virt_addr(md);		get_systab_virt_addr(md);

	if (left < memmap.desc_size) {		if (left < desc_size) {
	new_memmap = realloc_pages(new_memmap, *pg_shift);		new_memmap = realloc_pages(new_memmap, *pg_shift);
	if (!new_memmap)		if (!new_memmap)
	return NULL;		return NULL;
	@@ -786,10 +797,9 @@ static void * __init efi_map_regions(int count, int pg_shift)
	(*pg_shift)++;		(*pg_shift)++;
	}		}

	memcpy(new_memmap + (count memmap.desc_size), md,		memcpy(new_memmap + (count desc_size), md, desc_size);
	memmap.desc_size);

	left -= memmap.desc_size;		left -= desc_size;
	(*count)++;		(*count)++;
	}		}

	@@ -833,10 +843,10 @@ static void __init kexec_enter_virtual_mode(void)

	BUG_ON(!efi.systab);		BUG_ON(!efi.systab);

	num_pages = ALIGN(memmap.nr_map * memmap.desc_size, PAGE_SIZE);		num_pages = ALIGN(efi.memmap.nr_map * efi.memmap.desc_size, PAGE_SIZE);
	num_pages >>= PAGE_SHIFT;		num_pages >>= PAGE_SHIFT;

	if (efi_setup_page_tables(memmap.phys_map, num_pages)) {		if (efi_setup_page_tables(efi.memmap.phys_map, num_pages)) {
	clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);		clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
	return;		return;
	}		}
	@@ -920,16 +930,16 @@ static void __init __efi_enter_virtual_mode(void)

	if (efi_is_native()) {		if (efi_is_native()) {
	status = phys_efi_set_virtual_address_map(		status = phys_efi_set_virtual_address_map(
	memmap.desc_size * count,		efi.memmap.desc_size * count,
	memmap.desc_size,		efi.memmap.desc_size,
	memmap.desc_version,		efi.memmap.desc_version,
	(efi_memory_desc_t *)__pa(new_memmap));		(efi_memory_desc_t *)__pa(new_memmap));
	} else {		} else {
	status = efi_thunk_set_virtual_address_map(		status = efi_thunk_set_virtual_address_map(
	efi_phys.set_virtual_address_map,		efi_phys.set_virtual_address_map,
	memmap.desc_size * count,		efi.memmap.desc_size * count,
	memmap.desc_size,		efi.memmap.desc_size,
	memmap.desc_version,		efi.memmap.desc_version,
	(efi_memory_desc_t *)__pa(new_memmap));		(efi_memory_desc_t *)__pa(new_memmap));
	}		}

drivers/firmware/efi/arm-init.c

+9 −11

Original line number	Original line	Diff line number	Diff line
	@@ -20,8 +20,6 @@

	#include <asm/efi.h>		#include <asm/efi.h>

	struct efi_memory_map memmap;

	u64 efi_system_table;		u64 efi_system_table;

	static int __init is_normal_ram(efi_memory_desc_t *md)		static int __init is_normal_ram(efi_memory_desc_t *md)
	@@ -40,7 +38,7 @@ static phys_addr_t efi_to_phys(unsigned long addr)
	{		{
	efi_memory_desc_t *md;		efi_memory_desc_t *md;

	for_each_efi_memory_desc_in_map(&memmap, md) {		for_each_efi_memory_desc(md) {
	if (!(md->attribute & EFI_MEMORY_RUNTIME))		if (!(md->attribute & EFI_MEMORY_RUNTIME))
	continue;		continue;
	if (md->virt_addr == 0)		if (md->virt_addr == 0)
	@@ -145,7 +143,7 @@ static __init void reserve_regions(void)
	if (efi_enabled(EFI_DBG))		if (efi_enabled(EFI_DBG))
	pr_info("Processing EFI memory map:\n");		pr_info("Processing EFI memory map:\n");

	for_each_efi_memory_desc_in_map(&memmap, md) {		for_each_efi_memory_desc(md) {
	paddr = md->phys_addr;		paddr = md->phys_addr;
	npages = md->num_pages;		npages = md->num_pages;

	@@ -186,9 +184,9 @@ void __init efi_init(void)

	efi_system_table = params.system_table;		efi_system_table = params.system_table;

	memmap.phys_map = params.mmap;		efi.memmap.phys_map = params.mmap;
	memmap.map = early_memremap_ro(params.mmap, params.mmap_size);		efi.memmap.map = early_memremap_ro(params.mmap, params.mmap_size);
	if (memmap.map == NULL) {		if (efi.memmap.map == NULL) {
	/*		/*
	* If we are booting via UEFI, the UEFI memory map is the only		* If we are booting via UEFI, the UEFI memory map is the only
	* description of memory we have, so there is little point in		* description of memory we have, so there is little point in
	@@ -196,15 +194,15 @@ void __init efi_init(void)
	*/		*/
	panic("Unable to map EFI memory map.\n");		panic("Unable to map EFI memory map.\n");
	}		}
	memmap.map_end = memmap.map + params.mmap_size;		efi.memmap.map_end = efi.memmap.map + params.mmap_size;
	memmap.desc_size = params.desc_size;		efi.memmap.desc_size = params.desc_size;
	memmap.desc_version = params.desc_ver;		efi.memmap.desc_version = params.desc_ver;

	if (uefi_init() < 0)		if (uefi_init() < 0)
	return;		return;

	reserve_regions();		reserve_regions();
	early_memunmap(memmap.map, params.mmap_size);		early_memunmap(efi.memmap.map, params.mmap_size);

	if (IS_ENABLED(CONFIG_ARM)) {		if (IS_ENABLED(CONFIG_ARM)) {
	/*		/*

drivers/firmware/efi/arm-runtime.c

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -103,15 +103,15 @@ static int __init arm_enable_runtime_services(void)

	pr_info("Remapping and enabling EFI services.\n");		pr_info("Remapping and enabling EFI services.\n");

	mapsize = memmap.map_end - memmap.map;		mapsize = efi.memmap.map_end - efi.memmap.map;
	memmap.map = (__force void *)ioremap_cache(memmap.phys_map,
			efi.memmap.map = (__force void *)ioremap_cache(efi.memmap.phys_map,
	mapsize);		mapsize);
	if (!memmap.map) {		if (!efi.memmap.map) {
	pr_err("Failed to remap EFI memory map\n");		pr_err("Failed to remap EFI memory map\n");
	return -ENOMEM;		return -ENOMEM;
	}		}
	memmap.map_end = memmap.map + mapsize;		efi.memmap.map_end = efi.memmap.map + mapsize;
	efi.memmap = &memmap;

	if (!efi_virtmap_init()) {		if (!efi_virtmap_init()) {
	pr_err("UEFI virtual mapping missing or invalid -- runtime services will not be available\n");		pr_err("UEFI virtual mapping missing or invalid -- runtime services will not be available\n");

drivers/firmware/efi/efi.c

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -256,7 +256,7 @@ subsys_initcall(efisubsys_init);
	*/		*/
	int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)		int __init efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
	{		{
	struct efi_memory_map *map = efi.memmap;		struct efi_memory_map *map = &efi.memmap;
	phys_addr_t p, e;		phys_addr_t p, e;

	if (!efi_enabled(EFI_MEMMAP)) {		if (!efi_enabled(EFI_MEMMAP)) {

drivers/firmware/efi/fake_mem.c

+20 −20

Original line number	Original line	Diff line number	Diff line
	@@ -57,7 +57,7 @@ static int __init cmp_fake_mem(const void x1, const void x2)
	void __init efi_fake_memmap(void)		void __init efi_fake_memmap(void)
	{		{
	u64 start, end, m_start, m_end, m_attr;		u64 start, end, m_start, m_end, m_attr;
	int new_nr_map = memmap.nr_map;		int new_nr_map = efi.memmap.nr_map;
	efi_memory_desc_t *md;		efi_memory_desc_t *md;
	phys_addr_t new_memmap_phy;		phys_addr_t new_memmap_phy;
	void *new_memmap;		void *new_memmap;
	@@ -94,25 +94,25 @@ void __init efi_fake_memmap(void)
	}		}

	/* allocate memory for new EFI memmap */		/* allocate memory for new EFI memmap */
	new_memmap_phy = memblock_alloc(memmap.desc_size * new_nr_map,		new_memmap_phy = memblock_alloc(efi.memmap.desc_size * new_nr_map,
	PAGE_SIZE);		PAGE_SIZE);
	if (!new_memmap_phy)		if (!new_memmap_phy)
	return;		return;

	/* create new EFI memmap */		/* create new EFI memmap */
	new_memmap = early_memremap(new_memmap_phy,		new_memmap = early_memremap(new_memmap_phy,
	memmap.desc_size * new_nr_map);		efi.memmap.desc_size * new_nr_map);
	if (!new_memmap) {		if (!new_memmap) {
	memblock_free(new_memmap_phy, memmap.desc_size * new_nr_map);		memblock_free(new_memmap_phy, efi.memmap.desc_size * new_nr_map);
	return;		return;
	}		}

	for (old = memmap.map, new = new_memmap;		for (old = efi.memmap.map, new = new_memmap;
	old < memmap.map_end;		old < efi.memmap.map_end;
	old += memmap.desc_size, new += memmap.desc_size) {		old += efi.memmap.desc_size, new += efi.memmap.desc_size) {

	/* copy original EFI memory descriptor */		/* copy original EFI memory descriptor */
	memcpy(new, old, memmap.desc_size);		memcpy(new, old, efi.memmap.desc_size);
	md = new;		md = new;
	start = md->phys_addr;		start = md->phys_addr;
	end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1;		end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1;
	@@ -133,8 +133,8 @@ void __init efi_fake_memmap(void)
	md->num_pages = (m_end - md->phys_addr + 1) >>		md->num_pages = (m_end - md->phys_addr + 1) >>
	EFI_PAGE_SHIFT;		EFI_PAGE_SHIFT;
	/* latter part */		/* latter part */
	new += memmap.desc_size;		new += efi.memmap.desc_size;
	memcpy(new, old, memmap.desc_size);		memcpy(new, old, efi.memmap.desc_size);
	md = new;		md = new;
	md->phys_addr = m_end + 1;		md->phys_addr = m_end + 1;
	md->num_pages = (end - md->phys_addr + 1) >>		md->num_pages = (end - md->phys_addr + 1) >>
	@@ -146,16 +146,16 @@ void __init efi_fake_memmap(void)
	md->num_pages = (m_start - md->phys_addr) >>		md->num_pages = (m_start - md->phys_addr) >>
	EFI_PAGE_SHIFT;		EFI_PAGE_SHIFT;
	/* middle part */		/* middle part */
	new += memmap.desc_size;		new += efi.memmap.desc_size;
	memcpy(new, old, memmap.desc_size);		memcpy(new, old, efi.memmap.desc_size);
	md = new;		md = new;
	md->attribute \|= m_attr;		md->attribute \|= m_attr;
	md->phys_addr = m_start;		md->phys_addr = m_start;
	md->num_pages = (m_end - m_start + 1) >>		md->num_pages = (m_end - m_start + 1) >>
	EFI_PAGE_SHIFT;		EFI_PAGE_SHIFT;
	/* last part */		/* last part */
	new += memmap.desc_size;		new += efi.memmap.desc_size;
	memcpy(new, old, memmap.desc_size);		memcpy(new, old, efi.memmap.desc_size);
	md = new;		md = new;
	md->phys_addr = m_end + 1;		md->phys_addr = m_end + 1;
	md->num_pages = (end - m_end) >>		md->num_pages = (end - m_end) >>
	@@ -168,8 +168,8 @@ void __init efi_fake_memmap(void)
	md->num_pages = (m_start - md->phys_addr) >>		md->num_pages = (m_start - md->phys_addr) >>
	EFI_PAGE_SHIFT;		EFI_PAGE_SHIFT;
	/* latter part */		/* latter part */
	new += memmap.desc_size;		new += efi.memmap.desc_size;
	memcpy(new, old, memmap.desc_size);		memcpy(new, old, efi.memmap.desc_size);
	md = new;		md = new;
	md->phys_addr = m_start;		md->phys_addr = m_start;
	md->num_pages = (end - md->phys_addr + 1) >>		md->num_pages = (end - md->phys_addr + 1) >>
	@@ -181,10 +181,10 @@ void __init efi_fake_memmap(void)

	/* swap into new EFI memmap */		/* swap into new EFI memmap */
	efi_unmap_memmap();		efi_unmap_memmap();
	memmap.map = new_memmap;		efi.memmap.map = new_memmap;
	memmap.phys_map = new_memmap_phy;		efi.memmap.phys_map = new_memmap_phy;
	memmap.nr_map = new_nr_map;		efi.memmap.nr_map = new_nr_map;
	memmap.map_end = memmap.map + memmap.nr_map * memmap.desc_size;		efi.memmap.map_end = efi.memmap.map + efi.memmap.nr_map * efi.memmap.desc_size;
	set_bit(EFI_MEMMAP, &efi.flags);		set_bit(EFI_MEMMAP, &efi.flags);

	/* print new EFI memmap */		/* print new EFI memmap */

Admin message