e189624916
Current ACPI ARM64 NUMA initialization code in
acpi_numa_gicc_affinity_init()
carries out NUMA nodes creation and cpu<->node mappings at the same time
in the arch backend so that a single SRAT walk is needed to parse both
pieces of information. This implies that the cpu<->node mappings must
be stashed in an array (sized NR_CPUS) so that SMP code can later use
the stashed values to avoid another SRAT table walk to set-up the early
cpu<->node mappings.
If the kernel is configured with a NR_CPUS value less than the actual
processor entries in the SRAT (and MADT), the logic in
acpi_numa_gicc_affinity_init() is broken in that the cpu<->node mapping
is only carried out (and stashed for future use) only for a number of
SRAT entries up to NR_CPUS, which do not necessarily correspond to the
possible cpus detected at SMP initialization in
acpi_map_gic_cpu_interface() (ie MADT and SRAT processor entries order
is not enforced), which leaves the kernel with broken cpu<->node
mappings.
Furthermore, given the current ACPI NUMA code parsing logic in
acpi_numa_gicc_affinity_init(), PXM domains for CPUs that are not parsed
because they exceed NR_CPUS entries are not mapped to NUMA nodes (ie the
PXM corresponding node is not created in the kernel) leaving the system
with a broken NUMA topology.
Rework the ACPI ARM64 NUMA initialization process so that the NUMA
nodes creation and cpu<->node mappings are decoupled. cpu<->node
mappings are moved to SMP initialization code (where they are needed),
at the cost of an extra SRAT walk so that ACPI NUMA mappings can be
batched before being applied, fixing current parsing pitfalls.
Acked-by: Hanjun Guo <hanjun.guo@linaro.org>
Tested-by: John Garry <john.garry@huawei.com>
Fixes: d8b47fca8c ("arm64, ACPI, NUMA: NUMA support based on SRAT and
SLIT")
Link: http://lkml.kernel.org/r/1527768879-88161-2-git-send-email-xiexiuqi@huawei.com
Reported-by: Xie XiuQi <xiexiuqi@huawei.com>
Signed-off-by: Lorenzo Pieralisi <lorenzo.pieralisi@arm.com>
Cc: Punit Agrawal <punit.agrawal@arm.com>
Cc: Jonathan Cameron <jonathan.cameron@huawei.com>
Cc: Will Deacon <will.deacon@arm.com>
Cc: Hanjun Guo <guohanjun@huawei.com>
Cc: Ganapatrao Kulkarni <gkulkarni@caviumnetworks.com>
Cc: Jeremy Linton <jeremy.linton@arm.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Xie XiuQi <xiexiuqi@huawei.com>
Signed-off-by: Will Deacon <will.deacon@arm.com>
134 lines
3 KiB
C
134 lines
3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* ACPI 5.1 based NUMA setup for ARM64
|
|
* Lots of code was borrowed from arch/x86/mm/srat.c
|
|
*
|
|
* Copyright 2004 Andi Kleen, SuSE Labs.
|
|
* Copyright (C) 2013-2016, Linaro Ltd.
|
|
* Author: Hanjun Guo <hanjun.guo@linaro.org>
|
|
*
|
|
* Reads the ACPI SRAT table to figure out what memory belongs to which CPUs.
|
|
*
|
|
* Called from acpi_numa_init while reading the SRAT and SLIT tables.
|
|
* Assumes all memory regions belonging to a single proximity domain
|
|
* are in one chunk. Holes between them will be included in the node.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "ACPI: NUMA: " fmt
|
|
|
|
#include <linux/acpi.h>
|
|
#include <linux/bitmap.h>
|
|
#include <linux/bootmem.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/memblock.h>
|
|
#include <linux/mmzone.h>
|
|
#include <linux/module.h>
|
|
#include <linux/topology.h>
|
|
|
|
#include <asm/numa.h>
|
|
|
|
static int acpi_early_node_map[NR_CPUS] __initdata = { NUMA_NO_NODE };
|
|
|
|
int __init acpi_numa_get_nid(unsigned int cpu)
|
|
{
|
|
return acpi_early_node_map[cpu];
|
|
}
|
|
|
|
static inline int get_cpu_for_acpi_id(u32 uid)
|
|
{
|
|
int cpu;
|
|
|
|
for (cpu = 0; cpu < nr_cpu_ids; cpu++)
|
|
if (uid == get_acpi_id_for_cpu(cpu))
|
|
return cpu;
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static int __init acpi_parse_gicc_pxm(struct acpi_subtable_header *header,
|
|
const unsigned long end)
|
|
{
|
|
struct acpi_srat_gicc_affinity *pa;
|
|
int cpu, pxm, node;
|
|
|
|
if (srat_disabled())
|
|
return -EINVAL;
|
|
|
|
pa = (struct acpi_srat_gicc_affinity *)header;
|
|
if (!pa)
|
|
return -EINVAL;
|
|
|
|
if (!(pa->flags & ACPI_SRAT_GICC_ENABLED))
|
|
return 0;
|
|
|
|
pxm = pa->proximity_domain;
|
|
node = pxm_to_node(pxm);
|
|
|
|
/*
|
|
* If we can't map the UID to a logical cpu this
|
|
* means that the UID is not part of possible cpus
|
|
* so we do not need a NUMA mapping for it, skip
|
|
* the SRAT entry and keep parsing.
|
|
*/
|
|
cpu = get_cpu_for_acpi_id(pa->acpi_processor_uid);
|
|
if (cpu < 0)
|
|
return 0;
|
|
|
|
acpi_early_node_map[cpu] = node;
|
|
pr_info("SRAT: PXM %d -> MPIDR 0x%llx -> Node %d\n", pxm,
|
|
cpu_logical_map(cpu), node);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void __init acpi_map_cpus_to_nodes(void)
|
|
{
|
|
acpi_table_parse_entries(ACPI_SIG_SRAT, sizeof(struct acpi_table_srat),
|
|
ACPI_SRAT_TYPE_GICC_AFFINITY,
|
|
acpi_parse_gicc_pxm, 0);
|
|
}
|
|
|
|
/* Callback for Proximity Domain -> ACPI processor UID mapping */
|
|
void __init acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa)
|
|
{
|
|
int pxm, node;
|
|
|
|
if (srat_disabled())
|
|
return;
|
|
|
|
if (pa->header.length < sizeof(struct acpi_srat_gicc_affinity)) {
|
|
pr_err("SRAT: Invalid SRAT header length: %d\n",
|
|
pa->header.length);
|
|
bad_srat();
|
|
return;
|
|
}
|
|
|
|
if (!(pa->flags & ACPI_SRAT_GICC_ENABLED))
|
|
return;
|
|
|
|
pxm = pa->proximity_domain;
|
|
node = acpi_map_pxm_to_node(pxm);
|
|
|
|
if (node == NUMA_NO_NODE || node >= MAX_NUMNODES) {
|
|
pr_err("SRAT: Too many proximity domains %d\n", pxm);
|
|
bad_srat();
|
|
return;
|
|
}
|
|
|
|
node_set(node, numa_nodes_parsed);
|
|
}
|
|
|
|
int __init arm64_acpi_numa_init(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = acpi_numa_init();
|
|
if (ret) {
|
|
pr_info("Failed to initialise from firmware\n");
|
|
return ret;
|
|
}
|
|
|
|
return srat_disabled() ? -EINVAL : 0;
|
|
}
|