2 * ACPI 3.0 based NUMA setup
3 * Copyright 2004 Andi Kleen, SuSE Labs.
5 * Reads the ACPI SRAT table to figure out what memory belongs to which CPUs.
7 * Called from acpi_numa_init while reading the SRAT and SLIT tables.
8 * Assumes all memory regions belonging to a single proximity domain
9 * are in one chunk. Holes between them will be included in the node.
12 #include <linux/kernel.h>
13 #include <linux/acpi.h>
14 #include <linux/mmzone.h>
15 #include <linux/bitmap.h>
16 #include <linux/module.h>
17 #include <linux/topology.h>
18 #include <asm/proto.h>
21 static struct acpi_table_slit
*acpi_slit
;
23 static nodemask_t nodes_parsed __initdata
;
24 static nodemask_t nodes_found __initdata
;
25 static struct node nodes
[MAX_NUMNODES
] __initdata
;
26 static __u8 pxm2node
[256] = { [0 ... 255] = 0xff };
28 static int node_to_pxm(int n
);
30 int pxm_to_node(int pxm
)
32 if ((unsigned)pxm
>= 256)
37 static __init
int setup_node(int pxm
)
39 unsigned node
= pxm2node
[pxm
];
41 if (nodes_weight(nodes_found
) >= MAX_NUMNODES
)
43 node
= first_unset_node(nodes_found
);
44 node_set(node
, nodes_found
);
50 static __init
int conflicting_nodes(unsigned long start
, unsigned long end
)
53 for_each_online_node(i
) {
54 struct node
*nd
= &nodes
[i
];
55 if (nd
->start
== nd
->end
)
57 if (nd
->end
> start
&& nd
->start
< end
)
59 if (nd
->end
== end
&& nd
->start
== start
)
65 static __init
void cutoff_node(int i
, unsigned long start
, unsigned long end
)
67 struct node
*nd
= &nodes
[i
];
68 if (nd
->start
< start
) {
70 if (nd
->end
< nd
->start
)
77 if (nd
->start
> nd
->end
)
82 static __init
void bad_srat(void)
84 printk(KERN_ERR
"SRAT: SRAT not used.\n");
88 static __init
inline int srat_disabled(void)
90 return numa_off
|| acpi_numa
< 0;
93 /* Callback for SLIT parsing */
94 void __init
acpi_numa_slit_init(struct acpi_table_slit
*slit
)
99 /* Callback for Proximity Domain -> LAPIC mapping */
101 acpi_numa_processor_affinity_init(struct acpi_table_processor_affinity
*pa
)
104 if (srat_disabled() || pa
->flags
.enabled
== 0)
106 pxm
= pa
->proximity_domain
;
107 node
= setup_node(pxm
);
109 printk(KERN_ERR
"SRAT: Too many proximity domains %x\n", pxm
);
113 apicid_to_node
[pa
->apic_id
] = node
;
115 printk(KERN_INFO
"SRAT: PXM %u -> APIC %u -> Node %u\n",
116 pxm
, pa
->apic_id
, node
);
119 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
121 acpi_numa_memory_affinity_init(struct acpi_table_memory_affinity
*ma
)
124 unsigned long start
, end
;
128 if (srat_disabled() || ma
->flags
.enabled
== 0)
130 pxm
= ma
->proximity_domain
;
131 node
= setup_node(pxm
);
133 printk(KERN_ERR
"SRAT: Too many proximity domains.\n");
137 start
= ma
->base_addr_lo
| ((u64
)ma
->base_addr_hi
<< 32);
138 end
= start
+ (ma
->length_lo
| ((u64
)ma
->length_hi
<< 32));
139 /* It is fine to add this area to the nodes data it will be used later*/
140 if (ma
->flags
.hot_pluggable
== 1)
141 printk(KERN_INFO
"SRAT: hot plug zone found %lx - %lx \n",
143 i
= conflicting_nodes(start
, end
);
146 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
147 pxm
, start
, end
, nodes
[i
].start
, nodes
[i
].end
);
150 "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
151 pxm
, start
, end
, node_to_pxm(i
),
152 nodes
[i
].start
, nodes
[i
].end
);
157 if (!node_test_and_set(node
, nodes_parsed
)) {
161 if (start
< nd
->start
)
166 if (!(nd
->end
& 0xfff))
168 printk(KERN_INFO
"SRAT: Node %u PXM %u %Lx-%Lx\n", node
, pxm
,
172 void __init
acpi_numa_arch_fixup(void) {}
174 /* Use the information discovered above to actually set up the nodes. */
175 int __init
acpi_scan_nodes(unsigned long start
, unsigned long end
)
180 memnode_shift
= compute_hash_shift(nodes
, nodes_weight(nodes_parsed
));
181 if (memnode_shift
< 0) {
183 "SRAT: No NUMA node hash function found. Contact maintainer\n");
187 for (i
= 0; i
< MAX_NUMNODES
; i
++) {
188 if (!node_isset(i
, nodes_parsed
))
190 cutoff_node(i
, start
, end
);
191 if (nodes
[i
].start
== nodes
[i
].end
) {
192 node_clear(i
, nodes_parsed
);
195 setup_node_bootmem(i
, nodes
[i
].start
, nodes
[i
].end
);
197 for (i
= 0; i
< NR_CPUS
; i
++) {
198 if (cpu_to_node
[i
] == NUMA_NO_NODE
)
200 if (!node_isset(cpu_to_node
[i
], nodes_parsed
))
201 cpu_to_node
[i
] = NUMA_NO_NODE
;
207 static int node_to_pxm(int n
)
210 if (pxm2node
[n
] == n
)
212 for (i
= 0; i
< 256; i
++)
213 if (pxm2node
[i
] == n
)
218 int __node_distance(int a
, int b
)
223 return a
== b
? 10 : 20;
224 index
= acpi_slit
->localities
* node_to_pxm(a
);
225 return acpi_slit
->entry
[index
+ node_to_pxm(b
)];
228 EXPORT_SYMBOL(__node_distance
);