[deliverable/linux.git] / arch / arm64 / mm / numa.c

/*
 * NUMA support, based on the x86 implementation.
 *
 * Copyright (C) 2015 Cavium Inc.
 * Author: Ganapatrao Kulkarni <gkulkarni@cavium.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <linux/acpi.h>
#include <linux/bootmem.h>
#include <linux/memblock.h>
#include <linux/module.h>
#include <linux/of.h>

struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
EXPORT_SYMBOL(node_data);
nodemask_t numa_nodes_parsed __initdata;
static int cpu_to_node_map[NR_CPUS] = { [0 ... NR_CPUS-1] = NUMA_NO_NODE };

static int numa_distance_cnt;
static u8 *numa_distance;
static bool numa_off;

static __init int numa_parse_early_param(char *opt)
{
	if (!opt)
		return -EINVAL;
	if (!strncmp(opt, "off", 3)) {
		pr_info("%s\n", "NUMA turned off");
		numa_off = true;
	}
	return 0;
}
early_param("numa", numa_parse_early_param);

cpumask_var_t node_to_cpumask_map[MAX_NUMNODES];
EXPORT_SYMBOL(node_to_cpumask_map);

#ifdef CONFIG_DEBUG_PER_CPU_MAPS

/*
 * Returns a pointer to the bitmask of CPUs on Node 'node'.
 */
const struct cpumask *cpumask_of_node(int node)
{
	if (WARN_ON(node >= nr_node_ids))
		return cpu_none_mask;

	if (WARN_ON(node_to_cpumask_map[node] == NULL))
		return cpu_online_mask;

	return node_to_cpumask_map[node];
}
EXPORT_SYMBOL(cpumask_of_node);

#endif

static void map_cpu_to_node(unsigned int cpu, int nid)
{
	set_cpu_numa_node(cpu, nid);
	if (nid >= 0)
		cpumask_set_cpu(cpu, node_to_cpumask_map[nid]);
}

void numa_clear_node(unsigned int cpu)
{
	int nid = cpu_to_node(cpu);

	if (nid >= 0)
		cpumask_clear_cpu(cpu, node_to_cpumask_map[nid]);
	set_cpu_numa_node(cpu, NUMA_NO_NODE);
}

/*
 * Allocate node_to_cpumask_map based on number of available nodes
 * Requires node_possible_map to be valid.
 *
 * Note: cpumask_of_node() is not valid until after this is done.
 * (Use CONFIG_DEBUG_PER_CPU_MAPS to check this.)
 */
static void __init setup_node_to_cpumask_map(void)
{
	unsigned int cpu;
	int node;

	/* setup nr_node_ids if not done yet */
	if (nr_node_ids == MAX_NUMNODES)
		setup_nr_node_ids();

	/* allocate and clear the mapping */
	for (node = 0; node < nr_node_ids; node++) {
		alloc_bootmem_cpumask_var(&node_to_cpumask_map[node]);
		cpumask_clear(node_to_cpumask_map[node]);
	}

	for_each_possible_cpu(cpu)
		set_cpu_numa_node(cpu, NUMA_NO_NODE);

	/* cpumask_of_node() will now work */
	pr_debug("NUMA: Node to cpumask map for %d nodes\n", nr_node_ids);
}

/*
 *  Set the cpu to node and mem mapping
 */
void numa_store_cpu_info(unsigned int cpu)
{
	map_cpu_to_node(cpu, numa_off ? 0 : cpu_to_node_map[cpu]);
}

void __init early_map_cpu_to_node(unsigned int cpu, int nid)
{
	/* fallback to node 0 */
	if (nid < 0 || nid >= MAX_NUMNODES)
		nid = 0;

	cpu_to_node_map[cpu] = nid;
}

/**
 * numa_add_memblk - Set node id to memblk
 * @nid: NUMA node ID of the new memblk
 * @start: Start address of the new memblk
 * @end:  End address of the new memblk
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
int __init numa_add_memblk(int nid, u64 start, u64 end)
{
	int ret;

	ret = memblock_set_node(start, (end - start), &memblock.memory, nid);
	if (ret < 0) {
		pr_err("NUMA: memblock [0x%llx - 0x%llx] failed to add on node %d\n",
			start, (end - 1), nid);
		return ret;
	}

	node_set(nid, numa_nodes_parsed);
	pr_info("NUMA: Adding memblock [0x%llx - 0x%llx] on node %d\n",
			start, (end - 1), nid);
	return ret;
}

/**
 * Initialize NODE_DATA for a node on the local memory
 */
static void __init setup_node_data(int nid, u64 start_pfn, u64 end_pfn)
{
	const size_t nd_size = roundup(sizeof(pg_data_t), SMP_CACHE_BYTES);
	u64 nd_pa;
	void *nd;
	int tnid;

	pr_info("NUMA: Initmem setup node %d [mem %#010Lx-%#010Lx]\n",
			nid, start_pfn << PAGE_SHIFT,
			(end_pfn << PAGE_SHIFT) - 1);

	nd_pa = memblock_alloc_try_nid(nd_size, SMP_CACHE_BYTES, nid);
	nd = __va(nd_pa);

	/* report and initialize */
	pr_info("NUMA: NODE_DATA [mem %#010Lx-%#010Lx]\n",
		nd_pa, nd_pa + nd_size - 1);
	tnid = early_pfn_to_nid(nd_pa >> PAGE_SHIFT);
	if (tnid != nid)
		pr_info("NUMA: NODE_DATA(%d) on node %d\n", nid, tnid);

	node_data[nid] = nd;
	memset(NODE_DATA(nid), 0, sizeof(pg_data_t));
	NODE_DATA(nid)->node_id = nid;
	NODE_DATA(nid)->node_start_pfn = start_pfn;
	NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
}

/**
 * numa_free_distance
 *
 * The current table is freed.
 */
void __init numa_free_distance(void)
{
	size_t size;

	if (!numa_distance)
		return;

	size = numa_distance_cnt * numa_distance_cnt *
		sizeof(numa_distance[0]);

	memblock_free(__pa(numa_distance), size);
	numa_distance_cnt = 0;
	numa_distance = NULL;
}

/**
 *
 * Create a new NUMA distance table.
 *
 */
static int __init numa_alloc_distance(void)
{
	size_t size;
	u64 phys;
	int i, j;

	size = nr_node_ids * nr_node_ids * sizeof(numa_distance[0]);
	phys = memblock_find_in_range(0, PFN_PHYS(max_pfn),
				      size, PAGE_SIZE);
	if (WARN_ON(!phys))
		return -ENOMEM;

	memblock_reserve(phys, size);

	numa_distance = __va(phys);
	numa_distance_cnt = nr_node_ids;

	/* fill with the default distances */
	for (i = 0; i < numa_distance_cnt; i++)
		for (j = 0; j < numa_distance_cnt; j++)
			numa_distance[i * numa_distance_cnt + j] = i == j ?
				LOCAL_DISTANCE : REMOTE_DISTANCE;

	pr_debug("NUMA: Initialized distance table, cnt=%d\n",
			numa_distance_cnt);

	return 0;
}

/**
 * numa_set_distance - Set inter node NUMA distance from node to node.
 * @from: the 'from' node to set distance
 * @to: the 'to'  node to set distance
 * @distance: NUMA distance
 *
 * Set the distance from node @from to @to to @distance.
 * If distance table doesn't exist, a warning is printed.
 *
 * If @from or @to is higher than the highest known node or lower than zero
 * or @distance doesn't make sense, the call is ignored.
 *
 */
void __init numa_set_distance(int from, int to, int distance)
{
	if (!numa_distance) {
		pr_warn_once("NUMA: Warning: distance table not allocated yet\n");
		return;
	}

	if (from >= numa_distance_cnt || to >= numa_distance_cnt ||
			from < 0 || to < 0) {
		pr_warn_once("NUMA: Warning: node ids are out of bound, from=%d to=%d distance=%d\n",
			    from, to, distance);
		return;
	}

	if ((u8)distance != distance ||
	    (from == to && distance != LOCAL_DISTANCE)) {
		pr_warn_once("NUMA: Warning: invalid distance parameter, from=%d to=%d distance=%d\n",
			     from, to, distance);
		return;
	}

	numa_distance[from * numa_distance_cnt + to] = distance;
}

/**
 * Return NUMA distance @from to @to
 */
int __node_distance(int from, int to)
{
	if (from >= numa_distance_cnt || to >= numa_distance_cnt)
		return from == to ? LOCAL_DISTANCE : REMOTE_DISTANCE;
	return numa_distance[from * numa_distance_cnt + to];
}
EXPORT_SYMBOL(__node_distance);

static int __init numa_register_nodes(void)
{
	int nid;
	struct memblock_region *mblk;

	/* Check that valid nid is set to memblks */
	for_each_memblock(memory, mblk)
		if (mblk->nid == NUMA_NO_NODE || mblk->nid >= MAX_NUMNODES) {
			pr_warn("NUMA: Warning: invalid memblk node %d [mem %#010Lx-%#010Lx]\n",
				mblk->nid, mblk->base,
				mblk->base + mblk->size - 1);
			return -EINVAL;
		}

	/* Finally register nodes. */
	for_each_node_mask(nid, numa_nodes_parsed) {
		unsigned long start_pfn, end_pfn;

		get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
		setup_node_data(nid, start_pfn, end_pfn);
		node_set_online(nid);
	}

	/* Setup online nodes to actual nodes*/
	node_possible_map = numa_nodes_parsed;

	return 0;
}

static int __init numa_init(int (*init_func)(void))
{
	int ret;

	nodes_clear(numa_nodes_parsed);
	nodes_clear(node_possible_map);
	nodes_clear(node_online_map);
	numa_free_distance();

	ret = numa_alloc_distance();
	if (ret < 0)
		return ret;

	ret = init_func();
	if (ret < 0)
		return ret;

	if (nodes_empty(numa_nodes_parsed))
		return -EINVAL;

	ret = numa_register_nodes();
	if (ret < 0)
		return ret;

	setup_node_to_cpumask_map();

	/* init boot processor */
	cpu_to_node_map[0] = 0;
	map_cpu_to_node(0, 0);

	return 0;
}

/**
 * dummy_numa_init - Fallback dummy NUMA init
 *
 * Used if there's no underlying NUMA architecture, NUMA initialization
 * fails, or NUMA is disabled on the command line.
 *
 * Must online at least one node (node 0) and add memory blocks that cover all
 * allowed memory. It is unlikely that this function fails.
 */
static int __init dummy_numa_init(void)
{
	int ret;
	struct memblock_region *mblk;

	if (numa_off)
		pr_info("NUMA disabled\n"); /* Forced off on command line. */
	else
		pr_info("No NUMA configuration found\n");
	pr_info("NUMA: Faking a node at [mem %#018Lx-%#018Lx]\n",
	       0LLU, PFN_PHYS(max_pfn) - 1);

	for_each_memblock(memory, mblk) {
		ret = numa_add_memblk(0, mblk->base, mblk->base + mblk->size);
		if (!ret)
			continue;

		pr_err("NUMA init failed\n");
		return ret;
	}

	numa_off = true;
	return 0;
}

/**
 * arm64_numa_init - Initialize NUMA
 *
 * Try each configured NUMA initialization method until one succeeds.  The
 * last fallback is dummy single node config encomapssing whole memory.
 */
void __init arm64_numa_init(void)
{
	if (!numa_off) {
		if (!acpi_disabled && !numa_init(arm64_acpi_numa_init))
			return;
		if (acpi_disabled && !numa_init(of_numa_init))
			return;
	}

	numa_init(dummy_numa_init);
}
Commit	Line	Data
1a2db300 GK	1	/*
	2	* NUMA support, based on the x86 implementation.
	3	*
	4	* Copyright (C) 2015 Cavium Inc.
	5	* Author: Ganapatrao Kulkarni <gkulkarni@cavium.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
d8b47fca	20	#include <linux/acpi.h>
1a2db300 GK	21	#include <linux/bootmem.h>
	22	#include <linux/memblock.h>
	23	#include <linux/module.h>
	24	#include <linux/of.h>
	25
	26	struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
	27	EXPORT_SYMBOL(node_data);
	28	nodemask_t numa_nodes_parsed __initdata;
	29	static int cpu_to_node_map[NR_CPUS] = { [0 ... NR_CPUS-1] = NUMA_NO_NODE };
	30
	31	static int numa_distance_cnt;
	32	static u8 *numa_distance;
34c33370	33	static bool numa_off;
1a2db300 GK	34
	35	static __init int numa_parse_early_param(char *opt)
	36	{
	37	if (!opt)
	38	return -EINVAL;
	39	if (!strncmp(opt, "off", 3)) {
	40	pr_info("%s\n", "NUMA turned off");
34c33370	41	numa_off = true;
1a2db300 GK	42	}
	43	return 0;
	44	}
	45	early_param("numa", numa_parse_early_param);
	46
	47	cpumask_var_t node_to_cpumask_map[MAX_NUMNODES];
	48	EXPORT_SYMBOL(node_to_cpumask_map);
	49
	50	#ifdef CONFIG_DEBUG_PER_CPU_MAPS
	51
	52	/*
	53	* Returns a pointer to the bitmask of CPUs on Node 'node'.
	54	*/
	55	const struct cpumask *cpumask_of_node(int node)
	56	{
	57	if (WARN_ON(node >= nr_node_ids))
	58	return cpu_none_mask;
	59
	60	if (WARN_ON(node_to_cpumask_map[node] == NULL))
	61	return cpu_online_mask;
	62
	63	return node_to_cpumask_map[node];
	64	}
	65	EXPORT_SYMBOL(cpumask_of_node);
	66
	67	#endif
	68
	69	static void map_cpu_to_node(unsigned int cpu, int nid)
	70	{
	71	set_cpu_numa_node(cpu, nid);
	72	if (nid >= 0)
	73	cpumask_set_cpu(cpu, node_to_cpumask_map[nid]);
	74	}
	75
	76	void numa_clear_node(unsigned int cpu)
	77	{
	78	int nid = cpu_to_node(cpu);
	79
	80	if (nid >= 0)
	81	cpumask_clear_cpu(cpu, node_to_cpumask_map[nid]);
	82	set_cpu_numa_node(cpu, NUMA_NO_NODE);
	83	}
	84
	85	/*
	86	* Allocate node_to_cpumask_map based on number of available nodes
	87	* Requires node_possible_map to be valid.
	88	*
	89	* Note: cpumask_of_node() is not valid until after this is done.
	90	* (Use CONFIG_DEBUG_PER_CPU_MAPS to check this.)
	91	*/
	92	static void __init setup_node_to_cpumask_map(void)
	93	{
	94	unsigned int cpu;
	95	int node;
	96
	97	/* setup nr_node_ids if not done yet */
	98	if (nr_node_ids == MAX_NUMNODES)
	99	setup_nr_node_ids();
	100
	101	/* allocate and clear the mapping */
	102	for (node = 0; node < nr_node_ids; node++) {
	103	alloc_bootmem_cpumask_var(&node_to_cpumask_map[node]);
	104	cpumask_clear(node_to_cpumask_map[node]);
	105	}
106
107	for_each_possible_cpu(cpu)
108	set_cpu_numa_node(cpu, NUMA_NO_NODE);
109
110	/* cpumask_of_node() will now work */
111	pr_debug("NUMA: Node to cpumask map for %d nodes\n", nr_node_ids);
112	}
113
114	/*
115	* Set the cpu to node and mem mapping
116	*/
117	void numa_store_cpu_info(unsigned int cpu)
118	{
119	map_cpu_to_node(cpu, numa_off ? 0 : cpu_to_node_map[cpu]);
120	}
121
122	void __init early_map_cpu_to_node(unsigned int cpu, int nid)
123	{
124	/* fallback to node 0 */
125	if (nid < 0 \|\| nid >= MAX_NUMNODES)
126	nid = 0;
127
128	cpu_to_node_map[cpu] = nid;
129	}
130
131	/**
132	* numa_add_memblk - Set node id to memblk
133	* @nid: NUMA node ID of the new memblk
134	* @start: Start address of the new memblk
8ccbbdaa	135	* @end: End address of the new memblk
1a2db300 GK	136	*
	137	* RETURNS:
	138	* 0 on success, -errno on failure.
	139	*/
8ccbbdaa	140	int __init numa_add_memblk(int nid, u64 start, u64 end)
1a2db300 GK	141	{
	142	int ret;
	143
8ccbbdaa	144	ret = memblock_set_node(start, (end - start), &memblock.memory, nid);
1a2db300 GK	145	if (ret < 0) {
1a2db300 GK	146	pr_err("NUMA: memblock [0x%llx - 0x%llx] failed to add on node %d\n",
8ccbbdaa	147	start, (end - 1), nid);
1a2db300 GK	148	return ret;
	149	}
	150
	151	node_set(nid, numa_nodes_parsed);
	152	pr_info("NUMA: Adding memblock [0x%llx - 0x%llx] on node %d\n",
8ccbbdaa	153	start, (end - 1), nid);
1a2db300 GK	154	return ret;
	155	}
	156
	157	/**
	158	* Initialize NODE_DATA for a node on the local memory
	159	*/
	160	static void __init setup_node_data(int nid, u64 start_pfn, u64 end_pfn)
	161	{
	162	const size_t nd_size = roundup(sizeof(pg_data_t), SMP_CACHE_BYTES);
	163	u64 nd_pa;
	164	void *nd;
	165	int tnid;
	166
	167	pr_info("NUMA: Initmem setup node %d [mem %#010Lx-%#010Lx]\n",
	168	nid, start_pfn << PAGE_SHIFT,
	169	(end_pfn << PAGE_SHIFT) - 1);
	170
	171	nd_pa = memblock_alloc_try_nid(nd_size, SMP_CACHE_BYTES, nid);
	172	nd = __va(nd_pa);
	173
	174	/* report and initialize */
	175	pr_info("NUMA: NODE_DATA [mem %#010Lx-%#010Lx]\n",
	176	nd_pa, nd_pa + nd_size - 1);
	177	tnid = early_pfn_to_nid(nd_pa >> PAGE_SHIFT);
	178	if (tnid != nid)
	179	pr_info("NUMA: NODE_DATA(%d) on node %d\n", nid, tnid);
	180
	181	node_data[nid] = nd;
	182	memset(NODE_DATA(nid), 0, sizeof(pg_data_t));
	183	NODE_DATA(nid)->node_id = nid;
	184	NODE_DATA(nid)->node_start_pfn = start_pfn;
	185	NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
	186	}
	187
	188	/**
	189	* numa_free_distance
	190	*
	191	* The current table is freed.
	192	*/
	193	void __init numa_free_distance(void)
	194	{
	195	size_t size;
	196
	197	if (!numa_distance)
	198	return;
	199
	200	size = numa_distance_cnt * numa_distance_cnt *
	201	sizeof(numa_distance[0]);
	202
	203	memblock_free(__pa(numa_distance), size);
	204	numa_distance_cnt = 0;
	205	numa_distance = NULL;
	206	}
	207
	208	/**
	209	*
	210	* Create a new NUMA distance table.
	211	*
	212	*/
	213	static int __init numa_alloc_distance(void)
	214	{
	215	size_t size;
	216	u64 phys;
	217	int i, j;
218
219	size = nr_node_ids * nr_node_ids * sizeof(numa_distance[0]);
220	phys = memblock_find_in_range(0, PFN_PHYS(max_pfn),
221	size, PAGE_SIZE);
222	if (WARN_ON(!phys))
223	return -ENOMEM;
224
225	memblock_reserve(phys, size);
226
227	numa_distance = __va(phys);
228	numa_distance_cnt = nr_node_ids;
229
230	/* fill with the default distances */
231	for (i = 0; i < numa_distance_cnt; i++)
232	for (j = 0; j < numa_distance_cnt; j++)
233	numa_distance[i * numa_distance_cnt + j] = i == j ?
234	LOCAL_DISTANCE : REMOTE_DISTANCE;
235
236	pr_debug("NUMA: Initialized distance table, cnt=%d\n",
237	numa_distance_cnt);
238
239	return 0;
240	}
241
242	/**
243	* numa_set_distance - Set inter node NUMA distance from node to node.
244	* @from: the 'from' node to set distance
245	* @to: the 'to' node to set distance
246	* @distance: NUMA distance
247	*
248	* Set the distance from node @from to @to to @distance.
249	* If distance table doesn't exist, a warning is printed.
250	*
251	* If @from or @to is higher than the highest known node or lower than zero
252	* or @distance doesn't make sense, the call is ignored.
253	*
254	*/
255	void __init numa_set_distance(int from, int to, int distance)
256	{
257	if (!numa_distance) {
258	pr_warn_once("NUMA: Warning: distance table not allocated yet\n");
259	return;
260	}
261
262	if (from >= numa_distance_cnt \|\| to >= numa_distance_cnt \|\|
263	from < 0 \|\| to < 0) {
264	pr_warn_once("NUMA: Warning: node ids are out of bound, from=%d to=%d distance=%d\n",
265	from, to, distance);
266	return;
267	}
268
269	if ((u8)distance != distance \|\|
270	(from == to && distance != LOCAL_DISTANCE)) {
271	pr_warn_once("NUMA: Warning: invalid distance parameter, from=%d to=%d distance=%d\n",
272	from, to, distance);
273	return;
274	}
275
276	numa_distance[from * numa_distance_cnt + to] = distance;
277	}
278
279	/**
280	* Return NUMA distance @from to @to
281	*/
282	int __node_distance(int from, int to)
283	{
284	if (from >= numa_distance_cnt \|\| to >= numa_distance_cnt)
285	return from == to ? LOCAL_DISTANCE : REMOTE_DISTANCE;
286	return numa_distance[from * numa_distance_cnt + to];
287	}
288	EXPORT_SYMBOL(__node_distance);
289
290	static int __init numa_register_nodes(void)
291	{
292	int nid;
293	struct memblock_region *mblk;
294
295	/* Check that valid nid is set to memblks */
296	for_each_memblock(memory, mblk)
297	if (mblk->nid == NUMA_NO_NODE \|\| mblk->nid >= MAX_NUMNODES) {
298	pr_warn("NUMA: Warning: invalid memblk node %d [mem %#010Lx-%#010Lx]\n",
299	mblk->nid, mblk->base,
300	mblk->base + mblk->size - 1);
301	return -EINVAL;
302	}
303
304	/* Finally register nodes. */
305	for_each_node_mask(nid, numa_nodes_parsed) {
306	unsigned long start_pfn, end_pfn;
307
308	get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
309	setup_node_data(nid, start_pfn, end_pfn);
310	node_set_online(nid);
311	}
312
313	/* Setup online nodes to actual nodes*/
314	node_possible_map = numa_nodes_parsed;
315
316	return 0;
317	}
318
319	static int __init numa_init(int (*init_func)(void))
320	{
321	int ret;
322
323	nodes_clear(numa_nodes_parsed);
324	nodes_clear(node_possible_map);
325	nodes_clear(node_online_map);
326	numa_free_distance();
327
328	ret = numa_alloc_distance();
329	if (ret < 0)
330	return ret;
331
332	ret = init_func();
333	if (ret < 0)
334	return ret;
335
336	if (nodes_empty(numa_nodes_parsed))
337	return -EINVAL;
338
339	ret = numa_register_nodes();
340	if (ret < 0)
341	return ret;
342
343	setup_node_to_cpumask_map();
344
345	/* init boot processor */
346	cpu_to_node_map[0] = 0;
347	map_cpu_to_node(0, 0);
348
349	return 0;
350	}
351
352	/**
353	* dummy_numa_init - Fallback dummy NUMA init
354	*
355	* Used if there's no underlying NUMA architecture, NUMA initialization
356	* fails, or NUMA is disabled on the command line.
357	*
358	* Must online at least one node (node 0) and add memory blocks that cover all
359	* allowed memory. It is unlikely that this function fails.
360	*/
361	static int __init dummy_numa_init(void)
362	{
363	int ret;
364	struct memblock_region *mblk;
365
34c33370 DD	366	if (numa_off)
	367	pr_info("NUMA disabled\n"); /* Forced off on command line. */
	368	else
	369	pr_info("No NUMA configuration found\n");
1a2db300 GK	370	pr_info("NUMA: Faking a node at [mem %#018Lx-%#018Lx]\n",
	371	0LLU, PFN_PHYS(max_pfn) - 1);
	372
	373	for_each_memblock(memory, mblk) {
8ccbbdaa	374	ret = numa_add_memblk(0, mblk->base, mblk->base + mblk->size);
1a2db300 GK	375	if (!ret)
	376	continue;
	377
	378	pr_err("NUMA init failed\n");
	379	return ret;
	380	}
	381
34c33370	382	numa_off = true;
1a2db300 GK	383	return 0;
	384	}
	385
	386	/**
	387	* arm64_numa_init - Initialize NUMA
	388	*
	389	* Try each configured NUMA initialization method until one succeeds. The
	390	* last fallback is dummy single node config encomapssing whole memory.
	391	*/
	392	void __init arm64_numa_init(void)
	393	{
	394	if (!numa_off) {
d8b47fca HG	395	if (!acpi_disabled && !numa_init(arm64_acpi_numa_init))
	396	return;
	397	if (acpi_disabled && !numa_init(of_numa_init))
1a2db300 GK	398	return;
	399	}
	400
	401	numa_init(dummy_numa_init);
	402	}