[linux.git] / drivers / firmware / efi / memmap.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Common EFI memory map functions.
 */

#define pr_fmt(fmt) "efi: " fmt

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/efi.h>
#include <linux/io.h>
#include <asm/early_ioremap.h>
#include <linux/memblock.h>
#include <linux/slab.h>

static phys_addr_t __init __efi_memmap_alloc_early(unsigned long size)
{
	return memblock_phys_alloc(size, SMP_CACHE_BYTES);
}

static phys_addr_t __init __efi_memmap_alloc_late(unsigned long size)
{
	unsigned int order = get_order(size);
	struct page *p = alloc_pages(GFP_KERNEL, order);

	if (!p)
		return 0;

	return PFN_PHYS(page_to_pfn(p));
}

/**
 * efi_memmap_alloc - Allocate memory for the EFI memory map
 * @num_entries: Number of entries in the allocated map.
 *
 * Depending on whether mm_init() has already been invoked or not,
 * either memblock or "normal" page allocation is used.
 *
 * Returns the physical address of the allocated memory map on
 * success, zero on failure.
 */
phys_addr_t __init efi_memmap_alloc(unsigned int num_entries)
{
	unsigned long size = num_entries * efi.memmap.desc_size;

	if (slab_is_available())
		return __efi_memmap_alloc_late(size);

	return __efi_memmap_alloc_early(size);
}

/**
 * __efi_memmap_init - Common code for mapping the EFI memory map
 * @data: EFI memory map data
 * @late: Use early or late mapping function?
 *
 * This function takes care of figuring out which function to use to
 * map the EFI memory map in efi.memmap based on how far into the boot
 * we are.
 *
 * During bootup @late should be %false since we only have access to
 * the early_memremap*() functions as the vmalloc space isn't setup.
 * Once the kernel is fully booted we can fallback to the more robust
 * memremap*() API.
 *
 * Returns zero on success, a negative error code on failure.
 */
static int __init
__efi_memmap_init(struct efi_memory_map_data *data, bool late)
{
	struct efi_memory_map map;
	phys_addr_t phys_map;

	if (efi_enabled(EFI_PARAVIRT))
		return 0;

	phys_map = data->phys_map;

	if (late)
		map.map = memremap(phys_map, data->size, MEMREMAP_WB);
	else
		map.map = early_memremap(phys_map, data->size);

	if (!map.map) {
		pr_err("Could not map the memory map!\n");
		return -ENOMEM;
	}

	map.phys_map = data->phys_map;
	map.nr_map = data->size / data->desc_size;
	map.map_end = map.map + data->size;

	map.desc_version = data->desc_version;
	map.desc_size = data->desc_size;
	map.late = late;

	set_bit(EFI_MEMMAP, &efi.flags);

	efi.memmap = map;

	return 0;
}

/**
 * efi_memmap_init_early - Map the EFI memory map data structure
 * @data: EFI memory map data
 *
 * Use early_memremap() to map the passed in EFI memory map and assign
 * it to efi.memmap.
 */
int __init efi_memmap_init_early(struct efi_memory_map_data *data)
{
	/* Cannot go backwards */
	WARN_ON(efi.memmap.late);

	return __efi_memmap_init(data, false);
}

void __init efi_memmap_unmap(void)
{
	if (!efi_enabled(EFI_MEMMAP))
		return;

	if (!efi.memmap.late) {
		unsigned long size;

		size = efi.memmap.desc_size * efi.memmap.nr_map;
		early_memunmap(efi.memmap.map, size);
	} else {
		memunmap(efi.memmap.map);
	}

	efi.memmap.map = NULL;
	clear_bit(EFI_MEMMAP, &efi.flags);
}

/**
 * efi_memmap_init_late - Map efi.memmap with memremap()
 * @phys_addr: Physical address of the new EFI memory map
 * @size: Size in bytes of the new EFI memory map
 *
 * Setup a mapping of the EFI memory map using ioremap_cache(). This
 * function should only be called once the vmalloc space has been
 * setup and is therefore not suitable for calling during early EFI
 * initialise, e.g. in efi_init(). Additionally, it expects
 * efi_memmap_init_early() to have already been called.
 *
 * The reason there are two EFI memmap initialisation
 * (efi_memmap_init_early() and this late version) is because the
 * early EFI memmap should be explicitly unmapped once EFI
 * initialisation is complete as the fixmap space used to map the EFI
 * memmap (via early_memremap()) is a scarce resource.
 *
 * This late mapping is intended to persist for the duration of
 * runtime so that things like efi_mem_desc_lookup() and
 * efi_mem_attributes() always work.
 *
 * Returns zero on success, a negative error code on failure.
 */
int __init efi_memmap_init_late(phys_addr_t addr, unsigned long size)
{
	struct efi_memory_map_data data = {
		.phys_map = addr,
		.size = size,
	};

	/* Did we forget to unmap the early EFI memmap? */
	WARN_ON(efi.memmap.map);

	/* Were we already called? */
	WARN_ON(efi.memmap.late);

	/*
	 * It makes no sense to allow callers to register different
	 * values for the following fields. Copy them out of the
	 * existing early EFI memmap.
	 */
	data.desc_version = efi.memmap.desc_version;
	data.desc_size = efi.memmap.desc_size;

	return __efi_memmap_init(&data, true);
}

/**
 * efi_memmap_install - Install a new EFI memory map in efi.memmap
 * @addr: Physical address of the memory map
 * @nr_map: Number of entries in the memory map
 *
 * Unlike efi_memmap_init_*(), this function does not allow the caller
 * to switch from early to late mappings. It simply uses the existing
 * mapping function and installs the new memmap.
 *
 * Returns zero on success, a negative error code on failure.
 */
int __init efi_memmap_install(phys_addr_t addr, unsigned int nr_map)
{
	struct efi_memory_map_data data;

	efi_memmap_unmap();

	data.phys_map = addr;
	data.size = efi.memmap.desc_size * nr_map;
	data.desc_version = efi.memmap.desc_version;
	data.desc_size = efi.memmap.desc_size;

	return __efi_memmap_init(&data, efi.memmap.late);
}

/**
 * efi_memmap_split_count - Count number of additional EFI memmap entries
 * @md: EFI memory descriptor to split
 * @range: Address range (start, end) to split around
 *
 * Returns the number of additional EFI memmap entries required to
 * accomodate @range.
 */
int __init efi_memmap_split_count(efi_memory_desc_t *md, struct range *range)
{
	u64 m_start, m_end;
	u64 start, end;
	int count = 0;

	start = md->phys_addr;
	end = start + (md->num_pages << EFI_PAGE_SHIFT) - 1;

	/* modifying range */
	m_start = range->start;
	m_end = range->end;

	if (m_start <= start) {
		/* split into 2 parts */
		if (start < m_end && m_end < end)
			count++;
	}

	if (start < m_start && m_start < end) {
		/* split into 3 parts */
		if (m_end < end)
			count += 2;
		/* split into 2 parts */
		if (end <= m_end)
			count++;
	}

	return count;
}

/**
 * efi_memmap_insert - Insert a memory region in an EFI memmap
 * @old_memmap: The existing EFI memory map structure
 * @buf: Address of buffer to store new map
 * @mem: Memory map entry to insert
 *
 * It is suggested that you call efi_memmap_split_count() first
 * to see how large @buf needs to be.
 */
void __init efi_memmap_insert(struct efi_memory_map *old_memmap, void *buf,
			      struct efi_mem_range *mem)
{
	u64 m_start, m_end, m_attr;
	efi_memory_desc_t *md;
	u64 start, end;
	void *old, *new;

	/* modifying range */
	m_start = mem->range.start;
	m_end = mem->range.end;
	m_attr = mem->attribute;

	/*
	 * The EFI memory map deals with regions in EFI_PAGE_SIZE
	 * units. Ensure that the region described by 'mem' is aligned
	 * correctly.
	 */
	if (!IS_ALIGNED(m_start, EFI_PAGE_SIZE) ||
	    !IS_ALIGNED(m_end + 1, EFI_PAGE_SIZE)) {
		WARN_ON(1);
		return;
	}

	for (old = old_memmap->map, new = buf;
	     old < old_memmap->map_end;
	     old += old_memmap->desc_size, new += old_memmap->desc_size) {

		/* copy original EFI memory descriptor */
		memcpy(new, old, old_memmap->desc_size);
		md = new;
		start = md->phys_addr;
		end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1;

		if (m_start <= start && end <= m_end)
			md->attribute |= m_attr;

		if (m_start <= start &&
		    (start < m_end && m_end < end)) {
			/* first part */
			md->attribute |= m_attr;
			md->num_pages = (m_end - md->phys_addr + 1) >>
				EFI_PAGE_SHIFT;
			/* latter part */
			new += old_memmap->desc_size;
			memcpy(new, old, old_memmap->desc_size);
			md = new;
			md->phys_addr = m_end + 1;
			md->num_pages = (end - md->phys_addr + 1) >>
				EFI_PAGE_SHIFT;
		}

		if ((start < m_start && m_start < end) && m_end < end) {
			/* first part */
			md->num_pages = (m_start - md->phys_addr) >>
				EFI_PAGE_SHIFT;
			/* middle part */
			new += old_memmap->desc_size;
			memcpy(new, old, old_memmap->desc_size);
			md = new;
			md->attribute |= m_attr;
			md->phys_addr = m_start;
			md->num_pages = (m_end - m_start + 1) >>
				EFI_PAGE_SHIFT;
			/* last part */
			new += old_memmap->desc_size;
			memcpy(new, old, old_memmap->desc_size);
			md = new;
			md->phys_addr = m_end + 1;
			md->num_pages = (end - m_end) >>
				EFI_PAGE_SHIFT;
		}

		if ((start < m_start && m_start < end) &&
		    (end <= m_end)) {
			/* first part */
			md->num_pages = (m_start - md->phys_addr) >>
				EFI_PAGE_SHIFT;
			/* latter part */
			new += old_memmap->desc_size;
			memcpy(new, old, old_memmap->desc_size);
			md = new;
			md->phys_addr = m_start;
			md->num_pages = (end - md->phys_addr + 1) >>
				EFI_PAGE_SHIFT;
			md->attribute |= m_attr;
		}
	}
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
60863c0d MF	2	/*
	3	* Common EFI memory map functions.
	4	*/
	5
	6	#define pr_fmt(fmt) "efi: " fmt
	7
	8	#include <linux/init.h>
	9	#include <linux/kernel.h>
	10	#include <linux/efi.h>
	11	#include <linux/io.h>
	12	#include <asm/early_ioremap.h>
20b1e22d NS	13	#include <linux/memblock.h>
	14	#include <linux/slab.h>
	15
	16	static phys_addr_t __init __efi_memmap_alloc_early(unsigned long size)
	17	{
7e1c4e27	18	return memblock_phys_alloc(size, SMP_CACHE_BYTES);
20b1e22d NS	19	}
	20
	21	static phys_addr_t __init __efi_memmap_alloc_late(unsigned long size)
	22	{
	23	unsigned int order = get_order(size);
	24	struct page *p = alloc_pages(GFP_KERNEL, order);
	25
	26	if (!p)
	27	return 0;
	28
	29	return PFN_PHYS(page_to_pfn(p));
	30	}
	31
	32	/**
	33	* efi_memmap_alloc - Allocate memory for the EFI memory map
	34	* @num_entries: Number of entries in the allocated map.
	35	*
	36	* Depending on whether mm_init() has already been invoked or not,
	37	* either memblock or "normal" page allocation is used.
	38	*
	39	* Returns the physical address of the allocated memory map on
	40	* success, zero on failure.
	41	*/
	42	phys_addr_t __init efi_memmap_alloc(unsigned int num_entries)
	43	{
	44	unsigned long size = num_entries * efi.memmap.desc_size;
	45
	46	if (slab_is_available())
	47	return __efi_memmap_alloc_late(size);
	48
	49	return __efi_memmap_alloc_early(size);
	50	}
60863c0d MF	51
	52	/**
	53	* __efi_memmap_init - Common code for mapping the EFI memory map
	54	* @data: EFI memory map data
	55	* @late: Use early or late mapping function?
	56	*
	57	* This function takes care of figuring out which function to use to
	58	* map the EFI memory map in efi.memmap based on how far into the boot
	59	* we are.
	60	*
	61	* During bootup @late should be %false since we only have access to
	62	* the early_memremap*() functions as the vmalloc space isn't setup.
	63	* Once the kernel is fully booted we can fallback to the more robust
	64	* memremap*() API.
	65	*
	66	* Returns zero on success, a negative error code on failure.
	67	*/
	68	static int __init
	69	__efi_memmap_init(struct efi_memory_map_data *data, bool late)
	70	{
	71	struct efi_memory_map map;
	72	phys_addr_t phys_map;
	73
	74	if (efi_enabled(EFI_PARAVIRT))
	75	return 0;
	76
	77	phys_map = data->phys_map;
	78
	79	if (late)
	80	map.map = memremap(phys_map, data->size, MEMREMAP_WB);
	81	else
	82	map.map = early_memremap(phys_map, data->size);
	83
	84	if (!map.map) {
	85	pr_err("Could not map the memory map!\n");
	86	return -ENOMEM;
	87	}
	88
	89	map.phys_map = data->phys_map;
	90	map.nr_map = data->size / data->desc_size;
	91	map.map_end = map.map + data->size;
	92
	93	map.desc_version = data->desc_version;
	94	map.desc_size = data->desc_size;
	95	map.late = late;
	96
	97	set_bit(EFI_MEMMAP, &efi.flags);
	98
	99	efi.memmap = map;
	100
	101	return 0;
	102	}
	103
	104	/**
	105	* efi_memmap_init_early - Map the EFI memory map data structure
	106	* @data: EFI memory map data
	107	*
	108	* Use early_memremap() to map the passed in EFI memory map and assign
	109	* it to efi.memmap.
	110	*/
	111	int __init efi_memmap_init_early(struct efi_memory_map_data *data)
	112	{
	113	/* Cannot go backwards */
	114	WARN_ON(efi.memmap.late);
115
116	return __efi_memmap_init(data, false);
117	}
118
119	void __init efi_memmap_unmap(void)
120	{
33412b86 AB	121	if (!efi_enabled(EFI_MEMMAP))
	122	return;
	123
60863c0d MF	124	if (!efi.memmap.late) {
	125	unsigned long size;
	126
	127	size = efi.memmap.desc_size * efi.memmap.nr_map;
	128	early_memunmap(efi.memmap.map, size);
	129	} else {
	130	memunmap(efi.memmap.map);
	131	}
	132
	133	efi.memmap.map = NULL;
	134	clear_bit(EFI_MEMMAP, &efi.flags);
	135	}
	136
	137	/**
	138	* efi_memmap_init_late - Map efi.memmap with memremap()
	139	* @phys_addr: Physical address of the new EFI memory map
	140	* @size: Size in bytes of the new EFI memory map
	141	*
	142	* Setup a mapping of the EFI memory map using ioremap_cache(). This
	143	* function should only be called once the vmalloc space has been
	144	* setup and is therefore not suitable for calling during early EFI
	145	* initialise, e.g. in efi_init(). Additionally, it expects
	146	* efi_memmap_init_early() to have already been called.
	147	*
	148	* The reason there are two EFI memmap initialisation
	149	* (efi_memmap_init_early() and this late version) is because the
	150	* early EFI memmap should be explicitly unmapped once EFI
	151	* initialisation is complete as the fixmap space used to map the EFI
	152	* memmap (via early_memremap()) is a scarce resource.
	153	*
	154	* This late mapping is intended to persist for the duration of
	155	* runtime so that things like efi_mem_desc_lookup() and
	156	* efi_mem_attributes() always work.
	157	*
	158	* Returns zero on success, a negative error code on failure.
	159	*/
	160	int __init efi_memmap_init_late(phys_addr_t addr, unsigned long size)
	161	{
	162	struct efi_memory_map_data data = {
	163	.phys_map = addr,
	164	.size = size,
	165	};
	166
	167	/* Did we forget to unmap the early EFI memmap? */
	168	WARN_ON(efi.memmap.map);
	169
	170	/* Were we already called? */
	171	WARN_ON(efi.memmap.late);
	172
	173	/*
	174	* It makes no sense to allow callers to register different
	175	* values for the following fields. Copy them out of the
	176	* existing early EFI memmap.
	177	*/
	178	data.desc_version = efi.memmap.desc_version;
	179	data.desc_size = efi.memmap.desc_size;
	180
	181	return __efi_memmap_init(&data, true);
	182	}
	183
c45f4da3 MF	184	/**
	185	* efi_memmap_install - Install a new EFI memory map in efi.memmap
	186	* @addr: Physical address of the memory map
	187	* @nr_map: Number of entries in the memory map
	188	*
	189	* Unlike efi_memmap_init_*(), this function does not allow the caller
	190	* to switch from early to late mappings. It simply uses the existing
	191	* mapping function and installs the new memmap.
	192	*
	193	* Returns zero on success, a negative error code on failure.
	194	*/
	195	int __init efi_memmap_install(phys_addr_t addr, unsigned int nr_map)
	196	{
	197	struct efi_memory_map_data data;
	198
	199	efi_memmap_unmap();
	200
	201	data.phys_map = addr;
	202	data.size = efi.memmap.desc_size * nr_map;
	203	data.desc_version = efi.memmap.desc_version;
	204	data.desc_size = efi.memmap.desc_size;
	205
	206	return __efi_memmap_init(&data, efi.memmap.late);
	207	}
	208
60863c0d MF	209	/**
	210	* efi_memmap_split_count - Count number of additional EFI memmap entries
	211	* @md: EFI memory descriptor to split
	212	* @range: Address range (start, end) to split around
	213	*
	214	* Returns the number of additional EFI memmap entries required to
	215	* accomodate @range.
	216	*/
	217	int __init efi_memmap_split_count(efi_memory_desc_t md, struct range range)
	218	{
	219	u64 m_start, m_end;
	220	u64 start, end;
	221	int count = 0;
	222
	223	start = md->phys_addr;
	224	end = start + (md->num_pages << EFI_PAGE_SHIFT) - 1;
	225
	226	/* modifying range */
	227	m_start = range->start;
	228	m_end = range->end;
	229
	230	if (m_start <= start) {
	231	/* split into 2 parts */
	232	if (start < m_end && m_end < end)
	233	count++;
	234	}
	235
	236	if (start < m_start && m_start < end) {
	237	/* split into 3 parts */
	238	if (m_end < end)
	239	count += 2;
	240	/* split into 2 parts */
	241	if (end <= m_end)
	242	count++;
	243	}
	244
	245	return count;
	246	}
	247
	248	/**
	249	* efi_memmap_insert - Insert a memory region in an EFI memmap
	250	* @old_memmap: The existing EFI memory map structure
	251	* @buf: Address of buffer to store new map
	252	* @mem: Memory map entry to insert
	253	*
	254	* It is suggested that you call efi_memmap_split_count() first
	255	* to see how large @buf needs to be.
	256	*/
	257	void __init efi_memmap_insert(struct efi_memory_map old_memmap, void buf,
	258	struct efi_mem_range *mem)
	259	{
	260	u64 m_start, m_end, m_attr;
	261	efi_memory_desc_t *md;
	262	u64 start, end;
	263	void old, new;
	264
	265	/* modifying range */
	266	m_start = mem->range.start;
	267	m_end = mem->range.end;
	268	m_attr = mem->attribute;
	269
92dc3350 MF	270	/*
	271	* The EFI memory map deals with regions in EFI_PAGE_SIZE
	272	* units. Ensure that the region described by 'mem' is aligned
	273	* correctly.
	274	*/
	275	if (!IS_ALIGNED(m_start, EFI_PAGE_SIZE) \|\|
	276	!IS_ALIGNED(m_end + 1, EFI_PAGE_SIZE)) {
	277	WARN_ON(1);
	278	return;
	279	}
	280
60863c0d MF	281	for (old = old_memmap->map, new = buf;
	282	old < old_memmap->map_end;
	283	old += old_memmap->desc_size, new += old_memmap->desc_size) {
	284
	285	/* copy original EFI memory descriptor */
	286	memcpy(new, old, old_memmap->desc_size);
	287	md = new;
	288	start = md->phys_addr;
	289	end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1;
	290
	291	if (m_start <= start && end <= m_end)
	292	md->attribute \|= m_attr;
	293
	294	if (m_start <= start &&
	295	(start < m_end && m_end < end)) {
	296	/* first part */
	297	md->attribute \|= m_attr;
	298	md->num_pages = (m_end - md->phys_addr + 1) >>
	299	EFI_PAGE_SHIFT;
	300	/* latter part */
	301	new += old_memmap->desc_size;
	302	memcpy(new, old, old_memmap->desc_size);
	303	md = new;
	304	md->phys_addr = m_end + 1;
	305	md->num_pages = (end - md->phys_addr + 1) >>
	306	EFI_PAGE_SHIFT;
	307	}
	308
	309	if ((start < m_start && m_start < end) && m_end < end) {
	310	/* first part */
	311	md->num_pages = (m_start - md->phys_addr) >>
	312	EFI_PAGE_SHIFT;
	313	/* middle part */
	314	new += old_memmap->desc_size;
	315	memcpy(new, old, old_memmap->desc_size);
	316	md = new;
	317	md->attribute \|= m_attr;
	318	md->phys_addr = m_start;
	319	md->num_pages = (m_end - m_start + 1) >>
	320	EFI_PAGE_SHIFT;
	321	/* last part */
	322	new += old_memmap->desc_size;
	323	memcpy(new, old, old_memmap->desc_size);
	324	md = new;
	325	md->phys_addr = m_end + 1;
	326	md->num_pages = (end - m_end) >>
	327	EFI_PAGE_SHIFT;
	328	}
	329
	330	if ((start < m_start && m_start < end) &&
	331	(end <= m_end)) {
	332	/* first part */
	333	md->num_pages = (m_start - md->phys_addr) >>
	334	EFI_PAGE_SHIFT;
	335	/* latter part */
	336	new += old_memmap->desc_size;
	337	memcpy(new, old, old_memmap->desc_size);
	338	md = new;
	339	md->phys_addr = m_start;
	340	md->num_pages = (end - md->phys_addr + 1) >>
	341	EFI_PAGE_SHIFT;
	342	md->attribute \|= m_attr;
	343	}
	344	}
345	}