x86: Export k8 physical topology

To eventually interleave emulated nodes over physical nodes, we
need to know the physical topology of the machine without actually
registering it.  This does the k8 node setup in two parts:
detection and registration.  NUMA emulation can then used the
physical topology detected to setup the address ranges of emulated
nodes accordingly.  If emulation isn't used, the k8 nodes are
registered as normal.

Two formals are added to the x86 NUMA setup functions: `acpi' and
`k8'. These represent whether ACPI or K8 NUMA has been detected;
both cannot be true at the same time.  This specifies to the NUMA
emulation code whether an underlying physical NUMA topology exists
and which interface to use.

This patch deals solely with separating the k8 setup path into
Northbridge detection and registration steps and leaves the ACPI
changes for a subsequent patch.  The `acpi' formal is added here,
however, to avoid touching all the header files again in the next
patch.

This approach also ensures emulated nodes will not span physical
nodes so the true memory latency is not misrepresented.

k8_get_nodes() may now be used to export the k8 physical topology
of the machine for NUMA emulation.

Signed-off-by: David Rientjes <rientjes@google.com>
Cc: Andreas Herrmann <andreas.herrmann3@amd.com>
Cc: Yinghai Lu <yinghai@kernel.org>
Cc: Balbir Singh <balbir@linux.vnet.ibm.com>
Cc: Ankita Garg <ankita@in.ibm.com>
Cc: Len Brown <len.brown@intel.com>
LKML-Reference: <alpine.DEB.1.00.0909251518400.14754@chino.kir.corp.google.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 39 insertions, 13 deletions

diff --git a/arch/x86/mm/k8topology_64.c b/arch/x86/mm/k8topology_64.c
index a81561acc20f..b9e2dbfe55c3 100644
--- a/arch/x86/mm/k8topology_64.c
+++ b/arch/x86/mm/k8topology_64.c
@@ -24,6 +24,9 @@
 #include <asm/apic.h>
 #include <asm/k8.h>
 
+static struct bootnode __initdata nodes[8];
+static nodemask_t __initdata nodes_parsed = NODE_MASK_NONE;
+
 static __init int find_northbridge(void)
 {
         int num;
@@ -76,12 +79,26 @@ static __init void early_get_boot_cpu_id(void)
         early_init_lapic_mapping();
 }
 
-int __init k8_scan_nodes(unsigned long start, unsigned long end)
+int __init k8_get_nodes(struct bootnode *physnodes)
 {
-        unsigned numnodes, cores, bits, apicid_base;
+        int i;
+        int ret = 0;
+
+        for_each_node_mask(i, nodes_parsed) {
+                physnodes[ret].start = nodes[i].start;
+                physnodes[ret].end = nodes[i].end;
+                ret++;
+        }
+        return ret;
+}
+
+int __init k8_numa_init(unsigned long start_pfn, unsigned long end_pfn)
+{
+        unsigned long start = PFN_PHYS(start_pfn);
+        unsigned long end = PFN_PHYS(end_pfn);
+        unsigned numnodes;
         unsigned long prevbase;
-        struct bootnode nodes[8];
-        int i, j, nb, found = 0;
+        int i, nb, found = 0;
         u32 nodeid, reg;
 
         if (!early_pci_allowed())
@@ -98,9 +115,8 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
         if (numnodes <= 1)
                 return -1;
 
-        pr_info("Number of nodes %d\n", numnodes);
+        pr_info("Number of physical nodes %d\n", numnodes);
 
-        memset(&nodes, 0, sizeof(nodes));
         prevbase = 0;
         for (i = 0; i < 8; i++) {
                 unsigned long base, limit;
@@ -130,7 +146,7 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
                                nodeid, (base >> 8) & 3, (limit >> 8) & 3);
                         return -1;
                 }
-                if (node_isset(nodeid, node_possible_map)) {
+                if (node_isset(nodeid, nodes_parsed)) {
                         pr_info("Node %d already present, skipping\n",
                                 nodeid);
                         continue;
@@ -141,8 +157,8 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
                 limit |= (1<<24)-1;
                 limit++;
 
-                if (limit > max_pfn << PAGE_SHIFT)
-                        limit = max_pfn << PAGE_SHIFT;
+                if (limit > end)
+                        limit = end;
                 if (limit <= base)
                         continue;
 
@@ -180,12 +196,23 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
 
                 prevbase = base;
 
-                node_set(nodeid, node_possible_map);
+                node_set(nodeid, nodes_parsed);
         }
 
         if (!found)
                 return -1;
+        return 0;
+}
 
+int __init k8_scan_nodes(void)
+{
+        unsigned int bits;
+        unsigned int cores;
+        unsigned int apicid_base;
+        int i;
+
+        BUG_ON(nodes_empty(nodes_parsed));
+        node_possible_map = nodes_parsed;
         memnode_shift = compute_hash_shift(nodes, 8, NULL);
         if (memnode_shift < 0) {
                 pr_err("No NUMA node hash function found. Contact maintainer\n");
@@ -204,9 +231,8 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
                 apicid_base = boot_cpu_physical_apicid;
         }
 
-        for (i = 0; i < 8; i++) {
-                if (nodes[i].start == nodes[i].end)
-                        continue;
+        for_each_node_mask(i, node_possible_map) {
+                int j;
 
                 e820_register_active_regions(i,
                                 nodes[i].start >> PAGE_SHIFT,