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 <linux/bootmem.h>
19 #include <linux/memblock.h>
21 #include <asm/proto.h>
25 #include <asm/uv/uv.h>
27 int acpi_numa __initdata
;
29 static __init
int setup_node(int pxm
)
31 return acpi_map_pxm_to_node(pxm
);
34 static __init
void bad_srat(void)
36 printk(KERN_ERR
"SRAT: SRAT not used.\n");
40 static __init
inline int srat_disabled(void)
45 /* Callback for SLIT parsing */
46 void __init
acpi_numa_slit_init(struct acpi_table_slit
*slit
)
50 for (i
= 0; i
< slit
->locality_count
; i
++)
51 for (j
= 0; j
< slit
->locality_count
; j
++)
52 numa_set_distance(pxm_to_node(i
), pxm_to_node(j
),
53 slit
->entry
[slit
->locality_count
* i
+ j
]);
56 /* Callback for Proximity Domain -> x2APIC mapping */
58 acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity
*pa
)
65 if (pa
->header
.length
< sizeof(struct acpi_srat_x2apic_cpu_affinity
)) {
69 if ((pa
->flags
& ACPI_SRAT_CPU_ENABLED
) == 0)
71 pxm
= pa
->proximity_domain
;
72 apic_id
= pa
->apic_id
;
73 if (!apic
->apic_id_valid(apic_id
)) {
74 printk(KERN_INFO
"SRAT: PXM %u -> X2APIC 0x%04x ignored\n",
78 node
= setup_node(pxm
);
80 printk(KERN_ERR
"SRAT: Too many proximity domains %x\n", pxm
);
85 if (apic_id
>= MAX_LOCAL_APIC
) {
86 printk(KERN_INFO
"SRAT: PXM %u -> APIC 0x%04x -> Node %u skipped apicid that is too big\n", pxm
, apic_id
, node
);
89 set_apicid_to_node(apic_id
, node
);
90 node_set(node
, numa_nodes_parsed
);
92 printk(KERN_INFO
"SRAT: PXM %u -> APIC 0x%04x -> Node %u\n",
96 /* Callback for Proximity Domain -> LAPIC mapping */
98 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity
*pa
)
105 if (pa
->header
.length
!= sizeof(struct acpi_srat_cpu_affinity
)) {
109 if ((pa
->flags
& ACPI_SRAT_CPU_ENABLED
) == 0)
111 pxm
= pa
->proximity_domain_lo
;
112 if (acpi_srat_revision
>= 2)
113 pxm
|= *((unsigned int*)pa
->proximity_domain_hi
) << 8;
114 node
= setup_node(pxm
);
116 printk(KERN_ERR
"SRAT: Too many proximity domains %x\n", pxm
);
121 if (get_uv_system_type() >= UV_X2APIC
)
122 apic_id
= (pa
->apic_id
<< 8) | pa
->local_sapic_eid
;
124 apic_id
= pa
->apic_id
;
126 if (apic_id
>= MAX_LOCAL_APIC
) {
127 printk(KERN_INFO
"SRAT: PXM %u -> APIC 0x%02x -> Node %u skipped apicid that is too big\n", pxm
, apic_id
, node
);
131 set_apicid_to_node(apic_id
, node
);
132 node_set(node
, numa_nodes_parsed
);
134 printk(KERN_INFO
"SRAT: PXM %u -> APIC 0x%02x -> Node %u\n",
138 #ifdef CONFIG_MEMORY_HOTPLUG
139 static inline int save_add_info(void) {return 1;}
141 static inline int save_add_info(void) {return 0;}
144 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
146 handle_movablemem(int node
, u64 start
, u64 end
, u32 hotpluggable
)
149 unsigned long start_pfn
, end_pfn
;
151 start_pfn
= PFN_DOWN(start
);
152 end_pfn
= PFN_UP(end
);
155 * For movablemem_map=acpi:
157 * SRAT: |_____| |_____| |_________| |_________| ......
159 * hotpluggable: n y y n
160 * movablemem_map: |_____| |_________|
162 * Using movablemem_map, we can prevent memblock from allocating memory
163 * on ZONE_MOVABLE at boot time.
165 * Before parsing SRAT, memblock has already reserve some memory ranges
166 * for other purposes, such as for kernel image. We cannot prevent
167 * kernel from using these memory, so we need to exclude these memory
168 * even if it is hotpluggable.
169 * Furthermore, to ensure the kernel has enough memory to boot, we make
170 * all the memory on the node which the kernel resides in
173 if (hotpluggable
&& movablemem_map
.acpi
) {
174 /* Exclude ranges reserved by memblock. */
175 struct memblock_type
*rgn
= &memblock
.reserved
;
177 for (i
= 0; i
< rgn
->cnt
; i
++) {
178 if (end
<= rgn
->regions
[i
].base
||
179 start
>= rgn
->regions
[i
].base
+
180 rgn
->regions
[i
].size
)
184 * If the memory range overlaps the memory reserved by
185 * memblock, then the kernel resides in this node.
187 node_set(node
, movablemem_map
.numa_nodes_kernel
);
193 * If the kernel resides in this node, then the whole node
194 * should not be hotpluggable.
196 if (node_isset(node
, movablemem_map
.numa_nodes_kernel
))
199 insert_movablemem_map(start_pfn
, end_pfn
);
202 * numa_nodes_hotplug nodemask represents which nodes are put
203 * into movablemem_map.map[].
205 node_set(node
, movablemem_map
.numa_nodes_hotplug
);
210 * For movablemem_map=nn[KMG]@ss[KMG]:
212 * SRAT: |_____| |_____| |_________| |_________| ......
214 * user specified: |__| |___|
215 * movablemem_map: |___| |_________| |______| ......
217 * Using movablemem_map, we can prevent memblock from allocating memory
218 * on ZONE_MOVABLE at boot time.
220 * NOTE: In this case, SRAT info will be ingored.
222 overlap
= movablemem_map_overlap(start_pfn
, end_pfn
);
225 * If part of this range is in movablemem_map, we need to
226 * add the range after it to extend the range to the end
227 * of the node, because from the min address specified to
228 * the end of the node will be ZONE_MOVABLE.
230 start_pfn
= max(start_pfn
,
231 movablemem_map
.map
[overlap
].start_pfn
);
232 insert_movablemem_map(start_pfn
, end_pfn
);
235 * Set the nodemask, so that if the address range on one node
236 * is not continuse, we can add the subsequent ranges on the
237 * same node into movablemem_map.
239 node_set(node
, movablemem_map
.numa_nodes_hotplug
);
241 if (node_isset(node
, movablemem_map
.numa_nodes_hotplug
))
243 * Insert the range if we already have movable ranges
246 insert_movablemem_map(start_pfn
, end_pfn
);
251 #else /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
253 handle_movablemem(int node
, u64 start
, u64 end
, u32 hotpluggable
)
256 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
258 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
260 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity
*ma
)
268 if (ma
->header
.length
!= sizeof(struct acpi_srat_mem_affinity
))
269 goto out_err_bad_srat
;
270 if ((ma
->flags
& ACPI_SRAT_MEM_ENABLED
) == 0)
272 hotpluggable
= ma
->flags
& ACPI_SRAT_MEM_HOT_PLUGGABLE
;
273 if (hotpluggable
&& !save_add_info())
276 start
= ma
->base_address
;
277 end
= start
+ ma
->length
;
278 pxm
= ma
->proximity_domain
;
279 if (acpi_srat_revision
<= 1)
282 node
= setup_node(pxm
);
284 printk(KERN_ERR
"SRAT: Too many proximity domains.\n");
285 goto out_err_bad_srat
;
288 if (numa_add_memblk(node
, start
, end
) < 0)
289 goto out_err_bad_srat
;
291 node_set(node
, numa_nodes_parsed
);
293 printk(KERN_INFO
"SRAT: Node %u PXM %u [mem %#010Lx-%#010Lx] %s\n",
295 (unsigned long long) start
, (unsigned long long) end
- 1,
296 hotpluggable
? "Hot Pluggable": "");
298 handle_movablemem(node
, start
, end
, hotpluggable
);
307 void __init
acpi_numa_arch_fixup(void) {}
309 int __init
x86_acpi_numa_init(void)
313 ret
= acpi_numa_init();
316 return srat_disabled() ? -EINVAL
: 0;