586 lines
15 KiB
C
586 lines
15 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* NUMA emulation
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/topology.h>
|
|
#include <linux/memblock.h>
|
|
#include <asm/dma.h>
|
|
|
|
#include "numa_internal.h"
|
|
|
|
static int emu_nid_to_phys[MAX_NUMNODES];
|
|
static char *emu_cmdline __initdata;
|
|
|
|
int __init numa_emu_cmdline(char *str)
|
|
{
|
|
emu_cmdline = str;
|
|
return 0;
|
|
}
|
|
|
|
static int __init emu_find_memblk_by_nid(int nid, const struct numa_meminfo *mi)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < mi->nr_blks; i++)
|
|
if (mi->blk[i].nid == nid)
|
|
return i;
|
|
return -ENOENT;
|
|
}
|
|
|
|
static u64 __init mem_hole_size(u64 start, u64 end)
|
|
{
|
|
unsigned long start_pfn = PFN_UP(start);
|
|
unsigned long end_pfn = PFN_DOWN(end);
|
|
|
|
if (start_pfn < end_pfn)
|
|
return PFN_PHYS(absent_pages_in_range(start_pfn, end_pfn));
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Sets up nid to range from @start to @end. The return value is -errno if
|
|
* something went wrong, 0 otherwise.
|
|
*/
|
|
static int __init emu_setup_memblk(struct numa_meminfo *ei,
|
|
struct numa_meminfo *pi,
|
|
int nid, int phys_blk, u64 size)
|
|
{
|
|
struct numa_memblk *eb = &ei->blk[ei->nr_blks];
|
|
struct numa_memblk *pb = &pi->blk[phys_blk];
|
|
|
|
if (ei->nr_blks >= NR_NODE_MEMBLKS) {
|
|
pr_err("NUMA: Too many emulated memblks, failing emulation\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
ei->nr_blks++;
|
|
eb->start = pb->start;
|
|
eb->end = pb->start + size;
|
|
eb->nid = nid;
|
|
|
|
if (emu_nid_to_phys[nid] == NUMA_NO_NODE)
|
|
emu_nid_to_phys[nid] = pb->nid;
|
|
|
|
pb->start += size;
|
|
if (pb->start >= pb->end) {
|
|
WARN_ON_ONCE(pb->start > pb->end);
|
|
numa_remove_memblk_from(phys_blk, pi);
|
|
}
|
|
|
|
printk(KERN_INFO "Faking node %d at [mem %#018Lx-%#018Lx] (%LuMB)\n",
|
|
nid, eb->start, eb->end - 1, (eb->end - eb->start) >> 20);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Sets up nr_nodes fake nodes interleaved over physical nodes ranging from addr
|
|
* to max_addr.
|
|
*
|
|
* Returns zero on success or negative on error.
|
|
*/
|
|
static int __init split_nodes_interleave(struct numa_meminfo *ei,
|
|
struct numa_meminfo *pi,
|
|
u64 addr, u64 max_addr, int nr_nodes)
|
|
{
|
|
nodemask_t physnode_mask = numa_nodes_parsed;
|
|
u64 size;
|
|
int big;
|
|
int nid = 0;
|
|
int i, ret;
|
|
|
|
if (nr_nodes <= 0)
|
|
return -1;
|
|
if (nr_nodes > MAX_NUMNODES) {
|
|
pr_info("numa=fake=%d too large, reducing to %d\n",
|
|
nr_nodes, MAX_NUMNODES);
|
|
nr_nodes = MAX_NUMNODES;
|
|
}
|
|
|
|
/*
|
|
* Calculate target node size. x86_32 freaks on __udivdi3() so do
|
|
* the division in ulong number of pages and convert back.
|
|
*/
|
|
size = max_addr - addr - mem_hole_size(addr, max_addr);
|
|
size = PFN_PHYS((unsigned long)(size >> PAGE_SHIFT) / nr_nodes);
|
|
|
|
/*
|
|
* Calculate the number of big nodes that can be allocated as a result
|
|
* of consolidating the remainder.
|
|
*/
|
|
big = ((size & ~FAKE_NODE_MIN_HASH_MASK) * nr_nodes) /
|
|
FAKE_NODE_MIN_SIZE;
|
|
|
|
size &= FAKE_NODE_MIN_HASH_MASK;
|
|
if (!size) {
|
|
pr_err("Not enough memory for each node. "
|
|
"NUMA emulation disabled.\n");
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* Continue to fill physical nodes with fake nodes until there is no
|
|
* memory left on any of them.
|
|
*/
|
|
while (nodes_weight(physnode_mask)) {
|
|
for_each_node_mask(i, physnode_mask) {
|
|
u64 dma32_end = PFN_PHYS(MAX_DMA32_PFN);
|
|
u64 start, limit, end;
|
|
int phys_blk;
|
|
|
|
phys_blk = emu_find_memblk_by_nid(i, pi);
|
|
if (phys_blk < 0) {
|
|
node_clear(i, physnode_mask);
|
|
continue;
|
|
}
|
|
start = pi->blk[phys_blk].start;
|
|
limit = pi->blk[phys_blk].end;
|
|
end = start + size;
|
|
|
|
if (nid < big)
|
|
end += FAKE_NODE_MIN_SIZE;
|
|
|
|
/*
|
|
* Continue to add memory to this fake node if its
|
|
* non-reserved memory is less than the per-node size.
|
|
*/
|
|
while (end - start - mem_hole_size(start, end) < size) {
|
|
end += FAKE_NODE_MIN_SIZE;
|
|
if (end > limit) {
|
|
end = limit;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If there won't be at least FAKE_NODE_MIN_SIZE of
|
|
* non-reserved memory in ZONE_DMA32 for the next node,
|
|
* this one must extend to the boundary.
|
|
*/
|
|
if (end < dma32_end && dma32_end - end -
|
|
mem_hole_size(end, dma32_end) < FAKE_NODE_MIN_SIZE)
|
|
end = dma32_end;
|
|
|
|
/*
|
|
* If there won't be enough non-reserved memory for the
|
|
* next node, this one must extend to the end of the
|
|
* physical node.
|
|
*/
|
|
if (limit - end - mem_hole_size(end, limit) < size)
|
|
end = limit;
|
|
|
|
ret = emu_setup_memblk(ei, pi, nid++ % nr_nodes,
|
|
phys_blk,
|
|
min(end, limit) - start);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Returns the end address of a node so that there is at least `size' amount of
|
|
* non-reserved memory or `max_addr' is reached.
|
|
*/
|
|
static u64 __init find_end_of_node(u64 start, u64 max_addr, u64 size)
|
|
{
|
|
u64 end = start + size;
|
|
|
|
while (end - start - mem_hole_size(start, end) < size) {
|
|
end += FAKE_NODE_MIN_SIZE;
|
|
if (end > max_addr) {
|
|
end = max_addr;
|
|
break;
|
|
}
|
|
}
|
|
return end;
|
|
}
|
|
|
|
static u64 uniform_size(u64 max_addr, u64 base, u64 hole, int nr_nodes)
|
|
{
|
|
unsigned long max_pfn = PHYS_PFN(max_addr);
|
|
unsigned long base_pfn = PHYS_PFN(base);
|
|
unsigned long hole_pfns = PHYS_PFN(hole);
|
|
|
|
return PFN_PHYS((max_pfn - base_pfn - hole_pfns) / nr_nodes);
|
|
}
|
|
|
|
/*
|
|
* Sets up fake nodes of `size' interleaved over physical nodes ranging from
|
|
* `addr' to `max_addr'.
|
|
*
|
|
* Returns zero on success or negative on error.
|
|
*/
|
|
static int __init split_nodes_size_interleave_uniform(struct numa_meminfo *ei,
|
|
struct numa_meminfo *pi,
|
|
u64 addr, u64 max_addr, u64 size,
|
|
int nr_nodes, struct numa_memblk *pblk,
|
|
int nid)
|
|
{
|
|
nodemask_t physnode_mask = numa_nodes_parsed;
|
|
int i, ret, uniform = 0;
|
|
u64 min_size;
|
|
|
|
if ((!size && !nr_nodes) || (nr_nodes && !pblk))
|
|
return -1;
|
|
|
|
/*
|
|
* In the 'uniform' case split the passed in physical node by
|
|
* nr_nodes, in the non-uniform case, ignore the passed in
|
|
* physical block and try to create nodes of at least size
|
|
* @size.
|
|
*
|
|
* In the uniform case, split the nodes strictly by physical
|
|
* capacity, i.e. ignore holes. In the non-uniform case account
|
|
* for holes and treat @size as a minimum floor.
|
|
*/
|
|
if (!nr_nodes)
|
|
nr_nodes = MAX_NUMNODES;
|
|
else {
|
|
nodes_clear(physnode_mask);
|
|
node_set(pblk->nid, physnode_mask);
|
|
uniform = 1;
|
|
}
|
|
|
|
if (uniform) {
|
|
min_size = uniform_size(max_addr, addr, 0, nr_nodes);
|
|
size = min_size;
|
|
} else {
|
|
/*
|
|
* The limit on emulated nodes is MAX_NUMNODES, so the
|
|
* size per node is increased accordingly if the
|
|
* requested size is too small. This creates a uniform
|
|
* distribution of node sizes across the entire machine
|
|
* (but not necessarily over physical nodes).
|
|
*/
|
|
min_size = uniform_size(max_addr, addr,
|
|
mem_hole_size(addr, max_addr), nr_nodes);
|
|
}
|
|
min_size = ALIGN(max(min_size, FAKE_NODE_MIN_SIZE), FAKE_NODE_MIN_SIZE);
|
|
if (size < min_size) {
|
|
pr_err("Fake node size %LuMB too small, increasing to %LuMB\n",
|
|
size >> 20, min_size >> 20);
|
|
size = min_size;
|
|
}
|
|
size = ALIGN_DOWN(size, FAKE_NODE_MIN_SIZE);
|
|
|
|
/*
|
|
* Fill physical nodes with fake nodes of size until there is no memory
|
|
* left on any of them.
|
|
*/
|
|
while (nodes_weight(physnode_mask)) {
|
|
for_each_node_mask(i, physnode_mask) {
|
|
u64 dma32_end = PFN_PHYS(MAX_DMA32_PFN);
|
|
u64 start, limit, end;
|
|
int phys_blk;
|
|
|
|
phys_blk = emu_find_memblk_by_nid(i, pi);
|
|
if (phys_blk < 0) {
|
|
node_clear(i, physnode_mask);
|
|
continue;
|
|
}
|
|
|
|
start = pi->blk[phys_blk].start;
|
|
limit = pi->blk[phys_blk].end;
|
|
|
|
if (uniform)
|
|
end = start + size;
|
|
else
|
|
end = find_end_of_node(start, limit, size);
|
|
/*
|
|
* If there won't be at least FAKE_NODE_MIN_SIZE of
|
|
* non-reserved memory in ZONE_DMA32 for the next node,
|
|
* this one must extend to the boundary.
|
|
*/
|
|
if (end < dma32_end && dma32_end - end -
|
|
mem_hole_size(end, dma32_end) < FAKE_NODE_MIN_SIZE)
|
|
end = dma32_end;
|
|
|
|
/*
|
|
* If there won't be enough non-reserved memory for the
|
|
* next node, this one must extend to the end of the
|
|
* physical node.
|
|
*/
|
|
if ((limit - end - mem_hole_size(end, limit) < size)
|
|
&& !uniform)
|
|
end = limit;
|
|
|
|
ret = emu_setup_memblk(ei, pi, nid++ % MAX_NUMNODES,
|
|
phys_blk,
|
|
min(end, limit) - start);
|
|
if (ret < 0)
|
|
return ret;
|
|
}
|
|
}
|
|
return nid;
|
|
}
|
|
|
|
static int __init split_nodes_size_interleave(struct numa_meminfo *ei,
|
|
struct numa_meminfo *pi,
|
|
u64 addr, u64 max_addr, u64 size)
|
|
{
|
|
return split_nodes_size_interleave_uniform(ei, pi, addr, max_addr, size,
|
|
0, NULL, 0);
|
|
}
|
|
|
|
static int __init setup_emu2phys_nid(int *dfl_phys_nid)
|
|
{
|
|
int i, max_emu_nid = 0;
|
|
|
|
*dfl_phys_nid = NUMA_NO_NODE;
|
|
for (i = 0; i < ARRAY_SIZE(emu_nid_to_phys); i++) {
|
|
if (emu_nid_to_phys[i] != NUMA_NO_NODE) {
|
|
max_emu_nid = i;
|
|
if (*dfl_phys_nid == NUMA_NO_NODE)
|
|
*dfl_phys_nid = emu_nid_to_phys[i];
|
|
}
|
|
}
|
|
|
|
return max_emu_nid;
|
|
}
|
|
|
|
/**
|
|
* numa_emulation - Emulate NUMA nodes
|
|
* @numa_meminfo: NUMA configuration to massage
|
|
* @numa_dist_cnt: The size of the physical NUMA distance table
|
|
*
|
|
* Emulate NUMA nodes according to the numa=fake kernel parameter.
|
|
* @numa_meminfo contains the physical memory configuration and is modified
|
|
* to reflect the emulated configuration on success. @numa_dist_cnt is
|
|
* used to determine the size of the physical distance table.
|
|
*
|
|
* On success, the following modifications are made.
|
|
*
|
|
* - @numa_meminfo is updated to reflect the emulated nodes.
|
|
*
|
|
* - __apicid_to_node[] is updated such that APIC IDs are mapped to the
|
|
* emulated nodes.
|
|
*
|
|
* - NUMA distance table is rebuilt to represent distances between emulated
|
|
* nodes. The distances are determined considering how emulated nodes
|
|
* are mapped to physical nodes and match the actual distances.
|
|
*
|
|
* - emu_nid_to_phys[] reflects how emulated nodes are mapped to physical
|
|
* nodes. This is used by numa_add_cpu() and numa_remove_cpu().
|
|
*
|
|
* If emulation is not enabled or fails, emu_nid_to_phys[] is filled with
|
|
* identity mapping and no other modification is made.
|
|
*/
|
|
void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
|
|
{
|
|
static struct numa_meminfo ei __initdata;
|
|
static struct numa_meminfo pi __initdata;
|
|
const u64 max_addr = PFN_PHYS(max_pfn);
|
|
u8 *phys_dist = NULL;
|
|
size_t phys_size = numa_dist_cnt * numa_dist_cnt * sizeof(phys_dist[0]);
|
|
int max_emu_nid, dfl_phys_nid;
|
|
int i, j, ret;
|
|
|
|
if (!emu_cmdline)
|
|
goto no_emu;
|
|
|
|
memset(&ei, 0, sizeof(ei));
|
|
pi = *numa_meminfo;
|
|
|
|
for (i = 0; i < MAX_NUMNODES; i++)
|
|
emu_nid_to_phys[i] = NUMA_NO_NODE;
|
|
|
|
/*
|
|
* If the numa=fake command-line contains a 'M' or 'G', it represents
|
|
* the fixed node size. Otherwise, if it is just a single number N,
|
|
* split the system RAM into N fake nodes.
|
|
*/
|
|
if (strchr(emu_cmdline, 'U')) {
|
|
nodemask_t physnode_mask = numa_nodes_parsed;
|
|
unsigned long n;
|
|
int nid = 0;
|
|
|
|
n = simple_strtoul(emu_cmdline, &emu_cmdline, 0);
|
|
ret = -1;
|
|
for_each_node_mask(i, physnode_mask) {
|
|
/*
|
|
* The reason we pass in blk[0] is due to
|
|
* numa_remove_memblk_from() called by
|
|
* emu_setup_memblk() will delete entry 0
|
|
* and then move everything else up in the pi.blk
|
|
* array. Therefore we should always be looking
|
|
* at blk[0].
|
|
*/
|
|
ret = split_nodes_size_interleave_uniform(&ei, &pi,
|
|
pi.blk[0].start, pi.blk[0].end, 0,
|
|
n, &pi.blk[0], nid);
|
|
if (ret < 0)
|
|
break;
|
|
if (ret < n) {
|
|
pr_info("%s: phys: %d only got %d of %ld nodes, failing\n",
|
|
__func__, i, ret, n);
|
|
ret = -1;
|
|
break;
|
|
}
|
|
nid = ret;
|
|
}
|
|
} else if (strchr(emu_cmdline, 'M') || strchr(emu_cmdline, 'G')) {
|
|
u64 size;
|
|
|
|
size = memparse(emu_cmdline, &emu_cmdline);
|
|
ret = split_nodes_size_interleave(&ei, &pi, 0, max_addr, size);
|
|
} else {
|
|
unsigned long n;
|
|
|
|
n = simple_strtoul(emu_cmdline, &emu_cmdline, 0);
|
|
ret = split_nodes_interleave(&ei, &pi, 0, max_addr, n);
|
|
}
|
|
if (*emu_cmdline == ':')
|
|
emu_cmdline++;
|
|
|
|
if (ret < 0)
|
|
goto no_emu;
|
|
|
|
if (numa_cleanup_meminfo(&ei) < 0) {
|
|
pr_warn("NUMA: Warning: constructed meminfo invalid, disabling emulation\n");
|
|
goto no_emu;
|
|
}
|
|
|
|
/* copy the physical distance table */
|
|
if (numa_dist_cnt) {
|
|
u64 phys;
|
|
|
|
phys = memblock_phys_alloc_range(phys_size, PAGE_SIZE, 0,
|
|
PFN_PHYS(max_pfn_mapped));
|
|
if (!phys) {
|
|
pr_warn("NUMA: Warning: can't allocate copy of distance table, disabling emulation\n");
|
|
goto no_emu;
|
|
}
|
|
phys_dist = __va(phys);
|
|
|
|
for (i = 0; i < numa_dist_cnt; i++)
|
|
for (j = 0; j < numa_dist_cnt; j++)
|
|
phys_dist[i * numa_dist_cnt + j] =
|
|
node_distance(i, j);
|
|
}
|
|
|
|
/*
|
|
* Determine the max emulated nid and the default phys nid to use
|
|
* for unmapped nodes.
|
|
*/
|
|
max_emu_nid = setup_emu2phys_nid(&dfl_phys_nid);
|
|
|
|
/* commit */
|
|
*numa_meminfo = ei;
|
|
|
|
/* Make sure numa_nodes_parsed only contains emulated nodes */
|
|
nodes_clear(numa_nodes_parsed);
|
|
for (i = 0; i < ARRAY_SIZE(ei.blk); i++)
|
|
if (ei.blk[i].start != ei.blk[i].end &&
|
|
ei.blk[i].nid != NUMA_NO_NODE)
|
|
node_set(ei.blk[i].nid, numa_nodes_parsed);
|
|
|
|
/*
|
|
* Transform __apicid_to_node table to use emulated nids by
|
|
* reverse-mapping phys_nid. The maps should always exist but fall
|
|
* back to zero just in case.
|
|
*/
|
|
for (i = 0; i < ARRAY_SIZE(__apicid_to_node); i++) {
|
|
if (__apicid_to_node[i] == NUMA_NO_NODE)
|
|
continue;
|
|
for (j = 0; j < ARRAY_SIZE(emu_nid_to_phys); j++)
|
|
if (__apicid_to_node[i] == emu_nid_to_phys[j])
|
|
break;
|
|
__apicid_to_node[i] = j < ARRAY_SIZE(emu_nid_to_phys) ? j : 0;
|
|
}
|
|
|
|
/* make sure all emulated nodes are mapped to a physical node */
|
|
for (i = 0; i < ARRAY_SIZE(emu_nid_to_phys); i++)
|
|
if (emu_nid_to_phys[i] == NUMA_NO_NODE)
|
|
emu_nid_to_phys[i] = dfl_phys_nid;
|
|
|
|
/* transform distance table */
|
|
numa_reset_distance();
|
|
for (i = 0; i < max_emu_nid + 1; i++) {
|
|
for (j = 0; j < max_emu_nid + 1; j++) {
|
|
int physi = emu_nid_to_phys[i];
|
|
int physj = emu_nid_to_phys[j];
|
|
int dist;
|
|
|
|
if (get_option(&emu_cmdline, &dist) == 2)
|
|
;
|
|
else if (physi >= numa_dist_cnt || physj >= numa_dist_cnt)
|
|
dist = physi == physj ?
|
|
LOCAL_DISTANCE : REMOTE_DISTANCE;
|
|
else
|
|
dist = phys_dist[physi * numa_dist_cnt + physj];
|
|
|
|
numa_set_distance(i, j, dist);
|
|
}
|
|
}
|
|
|
|
/* free the copied physical distance table */
|
|
memblock_free(phys_dist, phys_size);
|
|
return;
|
|
|
|
no_emu:
|
|
/* No emulation. Build identity emu_nid_to_phys[] for numa_add_cpu() */
|
|
for (i = 0; i < ARRAY_SIZE(emu_nid_to_phys); i++)
|
|
emu_nid_to_phys[i] = i;
|
|
}
|
|
|
|
#ifndef CONFIG_DEBUG_PER_CPU_MAPS
|
|
void numa_add_cpu(int cpu)
|
|
{
|
|
int physnid, nid;
|
|
|
|
nid = early_cpu_to_node(cpu);
|
|
BUG_ON(nid == NUMA_NO_NODE || !node_online(nid));
|
|
|
|
physnid = emu_nid_to_phys[nid];
|
|
|
|
/*
|
|
* Map the cpu to each emulated node that is allocated on the physical
|
|
* node of the cpu's apic id.
|
|
*/
|
|
for_each_online_node(nid)
|
|
if (emu_nid_to_phys[nid] == physnid)
|
|
cpumask_set_cpu(cpu, node_to_cpumask_map[nid]);
|
|
}
|
|
|
|
void numa_remove_cpu(int cpu)
|
|
{
|
|
int i;
|
|
|
|
for_each_online_node(i)
|
|
cpumask_clear_cpu(cpu, node_to_cpumask_map[i]);
|
|
}
|
|
#else /* !CONFIG_DEBUG_PER_CPU_MAPS */
|
|
static void numa_set_cpumask(int cpu, bool enable)
|
|
{
|
|
int nid, physnid;
|
|
|
|
nid = early_cpu_to_node(cpu);
|
|
if (nid == NUMA_NO_NODE) {
|
|
/* early_cpu_to_node() already emits a warning and trace */
|
|
return;
|
|
}
|
|
|
|
physnid = emu_nid_to_phys[nid];
|
|
|
|
for_each_online_node(nid) {
|
|
if (emu_nid_to_phys[nid] != physnid)
|
|
continue;
|
|
|
|
debug_cpumask_set_cpu(cpu, nid, enable);
|
|
}
|
|
}
|
|
|
|
void numa_add_cpu(int cpu)
|
|
{
|
|
numa_set_cpumask(cpu, true);
|
|
}
|
|
|
|
void numa_remove_cpu(int cpu)
|
|
{
|
|
numa_set_cpumask(cpu, false);
|
|
}
|
|
#endif /* !CONFIG_DEBUG_PER_CPU_MAPS */
|