[deliverable/linux.git] / arch / s390 / numa / numa.c

/*
 * NUMA support for s390
 *
 * Implement NUMA core code.
 *
 * Copyright IBM Corp. 2015
 */

#define KMSG_COMPONENT "numa"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/kernel.h>
#include <linux/mmzone.h>
#include <linux/cpumask.h>
#include <linux/bootmem.h>
#include <linux/memblock.h>
#include <linux/slab.h>
#include <linux/node.h>

#include <asm/numa.h>
#include "numa_mode.h"

pg_data_t *node_data[MAX_NUMNODES];
EXPORT_SYMBOL(node_data);

cpumask_t node_to_cpumask_map[MAX_NUMNODES];
EXPORT_SYMBOL(node_to_cpumask_map);

const struct numa_mode numa_mode_plain = {
	.name = "plain",
};

static const struct numa_mode *mode = &numa_mode_plain;

int numa_pfn_to_nid(unsigned long pfn)
{
	return mode->__pfn_to_nid ? mode->__pfn_to_nid(pfn) : 0;
}

void numa_update_cpu_topology(void)
{
	if (mode->update_cpu_topology)
		mode->update_cpu_topology();
}

int __node_distance(int a, int b)
{
	return mode->distance ? mode->distance(a, b) : 0;
}

int numa_debug_enabled;

/*
 * alloc_node_data() - Allocate node data
 */
static __init pg_data_t *alloc_node_data(void)
{
	pg_data_t *res;

	res = (pg_data_t *) memblock_alloc(sizeof(pg_data_t), 8);
	memset(res, 0, sizeof(pg_data_t));
	return res;
}

/*
 * numa_setup_memory() - Assign bootmem to nodes
 *
 * The memory is first added to memblock without any respect to nodes.
 * This is fixed before remaining memblock memory is handed over to the
 * buddy allocator.
 * An important side effect is that large bootmem allocations might easily
 * cross node boundaries, which can be needed for large allocations with
 * smaller memory stripes in each node (i.e. when using NUMA emulation).
 *
 * Memory defines nodes:
 * Therefore this routine also sets the nodes online with memory.
 */
static void __init numa_setup_memory(void)
{
	unsigned long cur_base, align, end_of_dram;
	int nid = 0;

	end_of_dram = memblock_end_of_DRAM();
	align = mode->align ? mode->align() : ULONG_MAX;

	/*
	 * Step through all available memory and assign it to the nodes
	 * indicated by the mode implementation.
	 * All nodes which are seen here will be set online.
	 */
	cur_base = 0;
	do {
		nid = numa_pfn_to_nid(PFN_DOWN(cur_base));
		node_set_online(nid);
		memblock_set_node(cur_base, align, &memblock.memory, nid);
		cur_base += align;
	} while (cur_base < end_of_dram);

	/* Allocate and fill out node_data */
	for (nid = 0; nid < MAX_NUMNODES; nid++)
		NODE_DATA(nid) = alloc_node_data();

	for_each_online_node(nid) {
		unsigned long start_pfn, end_pfn;
		unsigned long t_start, t_end;
		int i;

		start_pfn = ULONG_MAX;
		end_pfn = 0;
		for_each_mem_pfn_range(i, nid, &t_start, &t_end, NULL) {
			if (t_start < start_pfn)
				start_pfn = t_start;
			if (t_end > end_pfn)
				end_pfn = t_end;
		}
		NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
		NODE_DATA(nid)->node_id = nid;
	}
}

/*
 * numa_setup() - Earliest initialization
 *
 * Assign the mode and call the mode's setup routine.
 */
void __init numa_setup(void)
{
	pr_info("NUMA mode: %s\n", mode->name);
	if (mode->setup)
		mode->setup();
	numa_setup_memory();
	memblock_dump_all();
}


/*
 * numa_init_early() - Initialization initcall
 *
 * This runs when only one CPU is online and before the first
 * topology update is called for by the scheduler.
 */
static int __init numa_init_early(void)
{
	/* Attach all possible CPUs to node 0 for now. */
	cpumask_copy(&node_to_cpumask_map[0], cpu_possible_mask);
	return 0;
}
early_initcall(numa_init_early);

/*
 * numa_init_late() - Initialization initcall
 *
 * Register NUMA nodes.
 */
static int __init numa_init_late(void)
{
	int nid;

	for_each_online_node(nid)
		register_one_node(nid);
	return 0;
}
arch_initcall(numa_init_late);

static int __init parse_debug(char *parm)
{
	numa_debug_enabled = 1;
	return 0;
}
early_param("numa_debug", parse_debug);

static int __init parse_numa(char *parm)
{
	if (strcmp(parm, numa_mode_plain.name) == 0)
		mode = &numa_mode_plain;
#ifdef CONFIG_NUMA_EMU
	if (strcmp(parm, numa_mode_emu.name) == 0)
		mode = &numa_mode_emu;
#endif
	return 0;
}
early_param("numa", parse_numa);
Commit	Line	Data
3a368f74 PH	1	/*
	2	* NUMA support for s390
	3	*
	4	* Implement NUMA core code.
	5	*
	6	* Copyright IBM Corp. 2015
	7	*/
	8
	9	#define KMSG_COMPONENT "numa"
	10	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	11
	12	#include <linux/kernel.h>
	13	#include <linux/mmzone.h>
	14	#include <linux/cpumask.h>
	15	#include <linux/bootmem.h>
	16	#include <linux/memblock.h>
	17	#include <linux/slab.h>
	18	#include <linux/node.h>
	19
	20	#include <asm/numa.h>
	21	#include "numa_mode.h"
	22
	23	pg_data_t *node_data[MAX_NUMNODES];
	24	EXPORT_SYMBOL(node_data);
	25
22be9cd9	26	cpumask_t node_to_cpumask_map[MAX_NUMNODES];
3a368f74 PH	27	EXPORT_SYMBOL(node_to_cpumask_map);
	28
	29	const struct numa_mode numa_mode_plain = {
	30	.name = "plain",
	31	};
	32
	33	static const struct numa_mode *mode = &numa_mode_plain;
	34
	35	int numa_pfn_to_nid(unsigned long pfn)
	36	{
	37	return mode->__pfn_to_nid ? mode->__pfn_to_nid(pfn) : 0;
	38	}
	39
	40	void numa_update_cpu_topology(void)
	41	{
	42	if (mode->update_cpu_topology)
	43	mode->update_cpu_topology();
	44	}
	45
	46	int __node_distance(int a, int b)
	47	{
	48	return mode->distance ? mode->distance(a, b) : 0;
	49	}
	50
	51	int numa_debug_enabled;
	52
	53	/*
	54	* alloc_node_data() - Allocate node data
	55	*/
	56	static __init pg_data_t *alloc_node_data(void)
	57	{
	58	pg_data_t *res;
	59
ef1f7fd7	60	res = (pg_data_t *) memblock_alloc(sizeof(pg_data_t), 8);
3a368f74 PH	61	memset(res, 0, sizeof(pg_data_t));
	62	return res;
	63	}
	64
	65	/*
	66	* numa_setup_memory() - Assign bootmem to nodes
	67	*
	68	* The memory is first added to memblock without any respect to nodes.
	69	* This is fixed before remaining memblock memory is handed over to the
	70	* buddy allocator.
	71	* An important side effect is that large bootmem allocations might easily
	72	* cross node boundaries, which can be needed for large allocations with
	73	* smaller memory stripes in each node (i.e. when using NUMA emulation).
	74	*
	75	* Memory defines nodes:
	76	* Therefore this routine also sets the nodes online with memory.
	77	*/
	78	static void __init numa_setup_memory(void)
	79	{
	80	unsigned long cur_base, align, end_of_dram;
	81	int nid = 0;
	82
	83	end_of_dram = memblock_end_of_DRAM();
	84	align = mode->align ? mode->align() : ULONG_MAX;
	85
	86	/*
	87	* Step through all available memory and assign it to the nodes
	88	* indicated by the mode implementation.
	89	* All nodes which are seen here will be set online.
	90	*/
	91	cur_base = 0;
	92	do {
	93	nid = numa_pfn_to_nid(PFN_DOWN(cur_base));
	94	node_set_online(nid);
	95	memblock_set_node(cur_base, align, &memblock.memory, nid);
	96	cur_base += align;
	97	} while (cur_base < end_of_dram);
	98
	99	/* Allocate and fill out node_data */
	100	for (nid = 0; nid < MAX_NUMNODES; nid++)
	101	NODE_DATA(nid) = alloc_node_data();
	102
	103	for_each_online_node(nid) {
	104	unsigned long start_pfn, end_pfn;
	105	unsigned long t_start, t_end;
	106	int i;
	107
	108	start_pfn = ULONG_MAX;
	109	end_pfn = 0;
	110	for_each_mem_pfn_range(i, nid, &t_start, &t_end, NULL) {
	111	if (t_start < start_pfn)
	112	start_pfn = t_start;
	113	if (t_end > end_pfn)
	114	end_pfn = t_end;
	115	}
	116	NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;
	117	NODE_DATA(nid)->node_id = nid;
	118	}
	119	}
	120
	121	/*
	122	* numa_setup() - Earliest initialization
	123	*
	124	* Assign the mode and call the mode's setup routine.
125	*/
126	void __init numa_setup(void)
127	{
128	pr_info("NUMA mode: %s\n", mode->name);
129	if (mode->setup)
130	mode->setup();
131	numa_setup_memory();
132	memblock_dump_all();
133	}
134
135
136	/*
137	* numa_init_early() - Initialization initcall
138	*
139	* This runs when only one CPU is online and before the first
140	* topology update is called for by the scheduler.
141	*/
142	static int __init numa_init_early(void)
143	{
144	/* Attach all possible CPUs to node 0 for now. */
22be9cd9	145	cpumask_copy(&node_to_cpumask_map[0], cpu_possible_mask);
3a368f74 PH	146	return 0;
	147	}
	148	early_initcall(numa_init_early);
	149
	150	/*
	151	* numa_init_late() - Initialization initcall
	152	*
	153	* Register NUMA nodes.
	154	*/
	155	static int __init numa_init_late(void)
	156	{
	157	int nid;
	158
	159	for_each_online_node(nid)
	160	register_one_node(nid);
	161	return 0;
	162	}
2d0f76a6	163	arch_initcall(numa_init_late);
3a368f74 PH	164
	165	static int __init parse_debug(char *parm)
	166	{
	167	numa_debug_enabled = 1;
	168	return 0;
	169	}
	170	early_param("numa_debug", parse_debug);
	171
	172	static int __init parse_numa(char *parm)
	173	{
	174	if (strcmp(parm, numa_mode_plain.name) == 0)
	175	mode = &numa_mode_plain;
c29a7baf MH	176	#ifdef CONFIG_NUMA_EMU
	177	if (strcmp(parm, numa_mode_emu.name) == 0)
	178	mode = &numa_mode_emu;
	179	#endif
3a368f74 PH	180	return 0;
	181	}
	182	early_param("numa", parse_numa);