1 /* Common code for 32 and 64-bit NUMA */
2 #include <linux/kernel.h>
4 #include <linux/string.h>
5 #include <linux/init.h>
6 #include <linux/bootmem.h>
7 #include <linux/memblock.h>
8 #include <linux/mmzone.h>
9 #include <linux/ctype.h>
10 #include <linux/module.h>
11 #include <linux/nodemask.h>
12 #include <linux/sched.h>
13 #include <linux/topology.h>
16 #include <asm/proto.h>
19 #include <asm/amd_nb.h>
21 #include "numa_internal.h"
23 int __initdata numa_off
;
24 nodemask_t numa_nodes_parsed __initdata
;
26 struct pglist_data
*node_data
[MAX_NUMNODES
] __read_mostly
;
27 EXPORT_SYMBOL(node_data
);
29 static struct numa_meminfo numa_meminfo
30 #ifndef CONFIG_MEMORY_HOTPLUG
35 static int numa_distance_cnt
;
36 static u8
*numa_distance
;
38 static __init
int numa_setup(char *opt
)
42 if (!strncmp(opt
, "off", 3))
44 #ifdef CONFIG_NUMA_EMU
45 if (!strncmp(opt
, "fake=", 5))
46 numa_emu_cmdline(opt
+ 5);
48 #ifdef CONFIG_ACPI_NUMA
49 if (!strncmp(opt
, "noacpi", 6))
54 early_param("numa", numa_setup
);
57 * apicid, cpu, node mappings
59 s16 __apicid_to_node
[MAX_LOCAL_APIC
] = {
60 [0 ... MAX_LOCAL_APIC
-1] = NUMA_NO_NODE
63 int numa_cpu_node(int cpu
)
65 int apicid
= early_per_cpu(x86_cpu_to_apicid
, cpu
);
67 if (apicid
!= BAD_APICID
)
68 return __apicid_to_node
[apicid
];
72 cpumask_var_t node_to_cpumask_map
[MAX_NUMNODES
];
73 EXPORT_SYMBOL(node_to_cpumask_map
);
76 * Map cpu index to node index
78 DEFINE_EARLY_PER_CPU(int, x86_cpu_to_node_map
, NUMA_NO_NODE
);
79 EXPORT_EARLY_PER_CPU_SYMBOL(x86_cpu_to_node_map
);
81 void numa_set_node(int cpu
, int node
)
83 int *cpu_to_node_map
= early_per_cpu_ptr(x86_cpu_to_node_map
);
85 /* early setting, no percpu area yet */
86 if (cpu_to_node_map
) {
87 cpu_to_node_map
[cpu
] = node
;
91 #ifdef CONFIG_DEBUG_PER_CPU_MAPS
92 if (cpu
>= nr_cpu_ids
|| !cpu_possible(cpu
)) {
93 printk(KERN_ERR
"numa_set_node: invalid cpu# (%d)\n", cpu
);
98 per_cpu(x86_cpu_to_node_map
, cpu
) = node
;
100 set_cpu_numa_node(cpu
, node
);
103 void numa_clear_node(int cpu
)
105 numa_set_node(cpu
, NUMA_NO_NODE
);
109 * Allocate node_to_cpumask_map based on number of available nodes
110 * Requires node_possible_map to be valid.
112 * Note: cpumask_of_node() is not valid until after this is done.
113 * (Use CONFIG_DEBUG_PER_CPU_MAPS to check this.)
115 void __init
setup_node_to_cpumask_map(void)
119 /* setup nr_node_ids if not done yet */
120 if (nr_node_ids
== MAX_NUMNODES
)
123 /* allocate the map */
124 for (node
= 0; node
< nr_node_ids
; node
++)
125 alloc_bootmem_cpumask_var(&node_to_cpumask_map
[node
]);
127 /* cpumask_of_node() will now work */
128 pr_debug("Node to cpumask map for %d nodes\n", nr_node_ids
);
131 static int __init
numa_add_memblk_to(int nid
, u64 start
, u64 end
,
132 struct numa_meminfo
*mi
)
134 /* ignore zero length blks */
138 /* whine about and ignore invalid blks */
139 if (start
> end
|| nid
< 0 || nid
>= MAX_NUMNODES
) {
140 pr_warning("NUMA: Warning: invalid memblk node %d [mem %#010Lx-%#010Lx]\n",
141 nid
, start
, end
- 1);
145 if (mi
->nr_blks
>= NR_NODE_MEMBLKS
) {
146 pr_err("NUMA: too many memblk ranges\n");
150 mi
->blk
[mi
->nr_blks
].start
= start
;
151 mi
->blk
[mi
->nr_blks
].end
= end
;
152 mi
->blk
[mi
->nr_blks
].nid
= nid
;
158 * numa_remove_memblk_from - Remove one numa_memblk from a numa_meminfo
159 * @idx: Index of memblk to remove
160 * @mi: numa_meminfo to remove memblk from
162 * Remove @idx'th numa_memblk from @mi by shifting @mi->blk[] and
163 * decrementing @mi->nr_blks.
165 void __init
numa_remove_memblk_from(int idx
, struct numa_meminfo
*mi
)
168 memmove(&mi
->blk
[idx
], &mi
->blk
[idx
+ 1],
169 (mi
->nr_blks
- idx
) * sizeof(mi
->blk
[0]));
173 * numa_add_memblk - Add one numa_memblk to numa_meminfo
174 * @nid: NUMA node ID of the new memblk
175 * @start: Start address of the new memblk
176 * @end: End address of the new memblk
178 * Add a new memblk to the default numa_meminfo.
181 * 0 on success, -errno on failure.
183 int __init
numa_add_memblk(int nid
, u64 start
, u64 end
)
185 return numa_add_memblk_to(nid
, start
, end
, &numa_meminfo
);
188 /* Initialize NODE_DATA for a node on the local memory */
189 static void __init
setup_node_data(int nid
, u64 start
, u64 end
)
191 const size_t nd_size
= roundup(sizeof(pg_data_t
), PAGE_SIZE
);
197 * Don't confuse VM with a node that doesn't have the
198 * minimum amount of memory:
200 if (end
&& (end
- start
) < NODE_MIN_SIZE
)
203 start
= roundup(start
, ZONE_ALIGN
);
205 printk(KERN_INFO
"Initmem setup node %d [mem %#010Lx-%#010Lx]\n",
206 nid
, start
, end
- 1);
209 * Allocate node data. Try node-local memory and then any node.
210 * Never allocate in DMA zone.
212 nd_pa
= memblock_alloc_nid(nd_size
, SMP_CACHE_BYTES
, nid
);
214 pr_err("Cannot find %zu bytes in node %d\n",
220 /* report and initialize */
221 printk(KERN_INFO
" NODE_DATA [mem %#010Lx-%#010Lx]\n",
222 nd_pa
, nd_pa
+ nd_size
- 1);
223 tnid
= early_pfn_to_nid(nd_pa
>> PAGE_SHIFT
);
225 printk(KERN_INFO
" NODE_DATA(%d) on node %d\n", nid
, tnid
);
228 memset(NODE_DATA(nid
), 0, sizeof(pg_data_t
));
229 NODE_DATA(nid
)->node_id
= nid
;
230 NODE_DATA(nid
)->node_start_pfn
= start
>> PAGE_SHIFT
;
231 NODE_DATA(nid
)->node_spanned_pages
= (end
- start
) >> PAGE_SHIFT
;
233 node_set_online(nid
);
237 * numa_cleanup_meminfo - Cleanup a numa_meminfo
238 * @mi: numa_meminfo to clean up
240 * Sanitize @mi by merging and removing unncessary memblks. Also check for
241 * conflicts and clear unused memblks.
244 * 0 on success, -errno on failure.
246 int __init
numa_cleanup_meminfo(struct numa_meminfo
*mi
)
249 const u64 high
= PFN_PHYS(max_pfn
);
252 /* first, trim all entries */
253 for (i
= 0; i
< mi
->nr_blks
; i
++) {
254 struct numa_memblk
*bi
= &mi
->blk
[i
];
256 /* make sure all blocks are inside the limits */
257 bi
->start
= max(bi
->start
, low
);
258 bi
->end
= min(bi
->end
, high
);
260 /* and there's no empty block */
261 if (bi
->start
>= bi
->end
)
262 numa_remove_memblk_from(i
--, mi
);
265 /* merge neighboring / overlapping entries */
266 for (i
= 0; i
< mi
->nr_blks
; i
++) {
267 struct numa_memblk
*bi
= &mi
->blk
[i
];
269 for (j
= i
+ 1; j
< mi
->nr_blks
; j
++) {
270 struct numa_memblk
*bj
= &mi
->blk
[j
];
274 * See whether there are overlapping blocks. Whine
275 * about but allow overlaps of the same nid. They
276 * will be merged below.
278 if (bi
->end
> bj
->start
&& bi
->start
< bj
->end
) {
279 if (bi
->nid
!= bj
->nid
) {
280 pr_err("NUMA: node %d [mem %#010Lx-%#010Lx] overlaps with node %d [mem %#010Lx-%#010Lx]\n",
281 bi
->nid
, bi
->start
, bi
->end
- 1,
282 bj
->nid
, bj
->start
, bj
->end
- 1);
285 pr_warning("NUMA: Warning: node %d [mem %#010Lx-%#010Lx] overlaps with itself [mem %#010Lx-%#010Lx]\n",
286 bi
->nid
, bi
->start
, bi
->end
- 1,
287 bj
->start
, bj
->end
- 1);
291 * Join together blocks on the same node, holes
292 * between which don't overlap with memory on other
295 if (bi
->nid
!= bj
->nid
)
297 start
= min(bi
->start
, bj
->start
);
298 end
= max(bi
->end
, bj
->end
);
299 for (k
= 0; k
< mi
->nr_blks
; k
++) {
300 struct numa_memblk
*bk
= &mi
->blk
[k
];
302 if (bi
->nid
== bk
->nid
)
304 if (start
< bk
->end
&& end
> bk
->start
)
309 printk(KERN_INFO
"NUMA: Node %d [mem %#010Lx-%#010Lx] + [mem %#010Lx-%#010Lx] -> [mem %#010Lx-%#010Lx]\n",
310 bi
->nid
, bi
->start
, bi
->end
- 1, bj
->start
,
311 bj
->end
- 1, start
, end
- 1);
314 numa_remove_memblk_from(j
--, mi
);
318 /* clear unused ones */
319 for (i
= mi
->nr_blks
; i
< ARRAY_SIZE(mi
->blk
); i
++) {
320 mi
->blk
[i
].start
= mi
->blk
[i
].end
= 0;
321 mi
->blk
[i
].nid
= NUMA_NO_NODE
;
328 * Set nodes, which have memory in @mi, in *@nodemask.
330 static void __init
numa_nodemask_from_meminfo(nodemask_t
*nodemask
,
331 const struct numa_meminfo
*mi
)
335 for (i
= 0; i
< ARRAY_SIZE(mi
->blk
); i
++)
336 if (mi
->blk
[i
].start
!= mi
->blk
[i
].end
&&
337 mi
->blk
[i
].nid
!= NUMA_NO_NODE
)
338 node_set(mi
->blk
[i
].nid
, *nodemask
);
342 * numa_reset_distance - Reset NUMA distance table
344 * The current table is freed. The next numa_set_distance() call will
347 void __init
numa_reset_distance(void)
349 size_t size
= numa_distance_cnt
* numa_distance_cnt
* sizeof(numa_distance
[0]);
351 /* numa_distance could be 1LU marking allocation failure, test cnt */
352 if (numa_distance_cnt
)
353 memblock_free(__pa(numa_distance
), size
);
354 numa_distance_cnt
= 0;
355 numa_distance
= NULL
; /* enable table creation */
358 static int __init
numa_alloc_distance(void)
360 nodemask_t nodes_parsed
;
365 /* size the new table and allocate it */
366 nodes_parsed
= numa_nodes_parsed
;
367 numa_nodemask_from_meminfo(&nodes_parsed
, &numa_meminfo
);
369 for_each_node_mask(i
, nodes_parsed
)
372 size
= cnt
* cnt
* sizeof(numa_distance
[0]);
374 phys
= memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped
),
377 pr_warning("NUMA: Warning: can't allocate distance table!\n");
378 /* don't retry until explicitly reset */
379 numa_distance
= (void *)1LU;
382 memblock_reserve(phys
, size
);
384 numa_distance
= __va(phys
);
385 numa_distance_cnt
= cnt
;
387 /* fill with the default distances */
388 for (i
= 0; i
< cnt
; i
++)
389 for (j
= 0; j
< cnt
; j
++)
390 numa_distance
[i
* cnt
+ j
] = i
== j
?
391 LOCAL_DISTANCE
: REMOTE_DISTANCE
;
392 printk(KERN_DEBUG
"NUMA: Initialized distance table, cnt=%d\n", cnt
);
398 * numa_set_distance - Set NUMA distance from one NUMA to another
399 * @from: the 'from' node to set distance
400 * @to: the 'to' node to set distance
401 * @distance: NUMA distance
403 * Set the distance from node @from to @to to @distance. If distance table
404 * doesn't exist, one which is large enough to accommodate all the currently
405 * known nodes will be created.
407 * If such table cannot be allocated, a warning is printed and further
408 * calls are ignored until the distance table is reset with
409 * numa_reset_distance().
411 * If @from or @to is higher than the highest known node or lower than zero
412 * at the time of table creation or @distance doesn't make sense, the call
414 * This is to allow simplification of specific NUMA config implementations.
416 void __init
numa_set_distance(int from
, int to
, int distance
)
418 if (!numa_distance
&& numa_alloc_distance() < 0)
421 if (from
>= numa_distance_cnt
|| to
>= numa_distance_cnt
||
422 from
< 0 || to
< 0) {
423 pr_warn_once("NUMA: Warning: node ids are out of bound, from=%d to=%d distance=%d\n",
428 if ((u8
)distance
!= distance
||
429 (from
== to
&& distance
!= LOCAL_DISTANCE
)) {
430 pr_warn_once("NUMA: Warning: invalid distance parameter, from=%d to=%d distance=%d\n",
435 numa_distance
[from
* numa_distance_cnt
+ to
] = distance
;
438 int __node_distance(int from
, int to
)
440 if (from
>= numa_distance_cnt
|| to
>= numa_distance_cnt
)
441 return from
== to
? LOCAL_DISTANCE
: REMOTE_DISTANCE
;
442 return numa_distance
[from
* numa_distance_cnt
+ to
];
444 EXPORT_SYMBOL(__node_distance
);
447 * Sanity check to catch more bad NUMA configurations (they are amazingly
448 * common). Make sure the nodes cover all memory.
450 static bool __init
numa_meminfo_cover_memory(const struct numa_meminfo
*mi
)
452 u64 numaram
, e820ram
;
456 for (i
= 0; i
< mi
->nr_blks
; i
++) {
457 u64 s
= mi
->blk
[i
].start
>> PAGE_SHIFT
;
458 u64 e
= mi
->blk
[i
].end
>> PAGE_SHIFT
;
460 numaram
-= __absent_pages_in_range(mi
->blk
[i
].nid
, s
, e
);
461 if ((s64
)numaram
< 0)
465 e820ram
= max_pfn
- absent_pages_in_range(0, max_pfn
);
467 /* We seem to lose 3 pages somewhere. Allow 1M of slack. */
468 if ((s64
)(e820ram
- numaram
) >= (1 << (20 - PAGE_SHIFT
))) {
469 printk(KERN_ERR
"NUMA: nodes only cover %LuMB of your %LuMB e820 RAM. Not used.\n",
470 (numaram
<< PAGE_SHIFT
) >> 20,
471 (e820ram
<< PAGE_SHIFT
) >> 20);
477 static int __init
numa_register_memblks(struct numa_meminfo
*mi
)
479 unsigned long uninitialized_var(pfn_align
);
482 /* Account for nodes with cpus and no memory */
483 node_possible_map
= numa_nodes_parsed
;
484 numa_nodemask_from_meminfo(&node_possible_map
, mi
);
485 if (WARN_ON(nodes_empty(node_possible_map
)))
488 for (i
= 0; i
< mi
->nr_blks
; i
++) {
489 struct numa_memblk
*mb
= &mi
->blk
[i
];
490 memblock_set_node(mb
->start
, mb
->end
- mb
->start
, mb
->nid
);
494 * If sections array is gonna be used for pfn -> nid mapping, check
495 * whether its granularity is fine enough.
497 #ifdef NODE_NOT_IN_PAGE_FLAGS
498 pfn_align
= node_map_pfn_alignment();
499 if (pfn_align
&& pfn_align
< PAGES_PER_SECTION
) {
500 printk(KERN_WARNING
"Node alignment %LuMB < min %LuMB, rejecting NUMA config\n",
501 PFN_PHYS(pfn_align
) >> 20,
502 PFN_PHYS(PAGES_PER_SECTION
) >> 20);
506 if (!numa_meminfo_cover_memory(mi
))
509 /* Finally register nodes. */
510 for_each_node_mask(nid
, node_possible_map
) {
511 u64 start
= PFN_PHYS(max_pfn
);
514 for (i
= 0; i
< mi
->nr_blks
; i
++) {
515 if (nid
!= mi
->blk
[i
].nid
)
517 start
= min(mi
->blk
[i
].start
, start
);
518 end
= max(mi
->blk
[i
].end
, end
);
522 setup_node_data(nid
, start
, end
);
525 /* Dump memblock with node info and return. */
531 * There are unfortunately some poorly designed mainboards around that
532 * only connect memory to a single CPU. This breaks the 1:1 cpu->node
533 * mapping. To avoid this fill in the mapping for all possible CPUs,
534 * as the number of CPUs is not known yet. We round robin the existing
537 static void __init
numa_init_array(void)
541 rr
= first_node(node_online_map
);
542 for (i
= 0; i
< nr_cpu_ids
; i
++) {
543 if (early_cpu_to_node(i
) != NUMA_NO_NODE
)
545 numa_set_node(i
, rr
);
546 rr
= next_node(rr
, node_online_map
);
547 if (rr
== MAX_NUMNODES
)
548 rr
= first_node(node_online_map
);
552 static int __init
numa_init(int (*init_func
)(void))
557 for (i
= 0; i
< MAX_LOCAL_APIC
; i
++)
558 set_apicid_to_node(i
, NUMA_NO_NODE
);
560 nodes_clear(numa_nodes_parsed
);
561 nodes_clear(node_possible_map
);
562 nodes_clear(node_online_map
);
563 memset(&numa_meminfo
, 0, sizeof(numa_meminfo
));
564 WARN_ON(memblock_set_node(0, ULLONG_MAX
, MAX_NUMNODES
));
565 numa_reset_distance();
570 ret
= numa_cleanup_meminfo(&numa_meminfo
);
574 numa_emulation(&numa_meminfo
, numa_distance_cnt
);
576 ret
= numa_register_memblks(&numa_meminfo
);
580 for (i
= 0; i
< nr_cpu_ids
; i
++) {
581 int nid
= early_cpu_to_node(i
);
583 if (nid
== NUMA_NO_NODE
)
585 if (!node_online(nid
))
593 * dummy_numa_init - Fallback dummy NUMA init
595 * Used if there's no underlying NUMA architecture, NUMA initialization
596 * fails, or NUMA is disabled on the command line.
598 * Must online at least one node and add memory blocks that cover all
599 * allowed memory. This function must not fail.
601 static int __init
dummy_numa_init(void)
603 printk(KERN_INFO
"%s\n",
604 numa_off
? "NUMA turned off" : "No NUMA configuration found");
605 printk(KERN_INFO
"Faking a node at [mem %#018Lx-%#018Lx]\n",
606 0LLU, PFN_PHYS(max_pfn
) - 1);
608 node_set(0, numa_nodes_parsed
);
609 numa_add_memblk(0, 0, PFN_PHYS(max_pfn
));
615 * x86_numa_init - Initialize NUMA
617 * Try each configured NUMA initialization method until one succeeds. The
618 * last fallback is dummy single node config encomapssing whole memory and
621 void __init
x86_numa_init(void)
624 #ifdef CONFIG_X86_NUMAQ
625 if (!numa_init(numaq_numa_init
))
628 #ifdef CONFIG_ACPI_NUMA
629 if (!numa_init(x86_acpi_numa_init
))
632 #ifdef CONFIG_AMD_NUMA
633 if (!numa_init(amd_numa_init
))
638 numa_init(dummy_numa_init
);
641 static __init
int find_near_online_node(int node
)
644 int min_val
= INT_MAX
;
647 for_each_online_node(n
) {
648 val
= node_distance(node
, n
);
660 * Setup early cpu_to_node.
662 * Populate cpu_to_node[] only if x86_cpu_to_apicid[],
663 * and apicid_to_node[] tables have valid entries for a CPU.
664 * This means we skip cpu_to_node[] initialisation for NUMA
665 * emulation and faking node case (when running a kernel compiled
666 * for NUMA on a non NUMA box), which is OK as cpu_to_node[]
667 * is already initialized in a round robin manner at numa_init_array,
668 * prior to this call, and this initialization is good enough
669 * for the fake NUMA cases.
671 * Called before the per_cpu areas are setup.
673 void __init
init_cpu_to_node(void)
676 u16
*cpu_to_apicid
= early_per_cpu_ptr(x86_cpu_to_apicid
);
678 BUG_ON(cpu_to_apicid
== NULL
);
680 for_each_possible_cpu(cpu
) {
681 int node
= numa_cpu_node(cpu
);
683 if (node
== NUMA_NO_NODE
)
685 if (!node_online(node
))
686 node
= find_near_online_node(node
);
687 numa_set_node(cpu
, node
);
691 #ifndef CONFIG_DEBUG_PER_CPU_MAPS
693 # ifndef CONFIG_NUMA_EMU
694 void numa_add_cpu(int cpu
)
696 cpumask_set_cpu(cpu
, node_to_cpumask_map
[early_cpu_to_node(cpu
)]);
699 void numa_remove_cpu(int cpu
)
701 cpumask_clear_cpu(cpu
, node_to_cpumask_map
[early_cpu_to_node(cpu
)]);
703 # endif /* !CONFIG_NUMA_EMU */
705 #else /* !CONFIG_DEBUG_PER_CPU_MAPS */
707 int __cpu_to_node(int cpu
)
709 if (early_per_cpu_ptr(x86_cpu_to_node_map
)) {
711 "cpu_to_node(%d): usage too early!\n", cpu
);
713 return early_per_cpu_ptr(x86_cpu_to_node_map
)[cpu
];
715 return per_cpu(x86_cpu_to_node_map
, cpu
);
717 EXPORT_SYMBOL(__cpu_to_node
);
720 * Same function as cpu_to_node() but used if called before the
721 * per_cpu areas are setup.
723 int early_cpu_to_node(int cpu
)
725 if (early_per_cpu_ptr(x86_cpu_to_node_map
))
726 return early_per_cpu_ptr(x86_cpu_to_node_map
)[cpu
];
728 if (!cpu_possible(cpu
)) {
730 "early_cpu_to_node(%d): no per_cpu area!\n", cpu
);
734 return per_cpu(x86_cpu_to_node_map
, cpu
);
737 void debug_cpumask_set_cpu(int cpu
, int node
, bool enable
)
739 struct cpumask
*mask
;
742 if (node
== NUMA_NO_NODE
) {
743 /* early_cpu_to_node() already emits a warning and trace */
746 mask
= node_to_cpumask_map
[node
];
748 pr_err("node_to_cpumask_map[%i] NULL\n", node
);
754 cpumask_set_cpu(cpu
, mask
);
756 cpumask_clear_cpu(cpu
, mask
);
758 cpulist_scnprintf(buf
, sizeof(buf
), mask
);
759 printk(KERN_DEBUG
"%s cpu %d node %d: mask now %s\n",
760 enable
? "numa_add_cpu" : "numa_remove_cpu",
765 # ifndef CONFIG_NUMA_EMU
766 static void numa_set_cpumask(int cpu
, bool enable
)
768 debug_cpumask_set_cpu(cpu
, early_cpu_to_node(cpu
), enable
);
771 void numa_add_cpu(int cpu
)
773 numa_set_cpumask(cpu
, true);
776 void numa_remove_cpu(int cpu
)
778 numa_set_cpumask(cpu
, false);
780 # endif /* !CONFIG_NUMA_EMU */
783 * Returns a pointer to the bitmask of CPUs on Node 'node'.
785 const struct cpumask
*cpumask_of_node(int node
)
787 if (node
>= nr_node_ids
) {
789 "cpumask_of_node(%d): node > nr_node_ids(%d)\n",
792 return cpu_none_mask
;
794 if (node_to_cpumask_map
[node
] == NULL
) {
796 "cpumask_of_node(%d): no node_to_cpumask_map!\n",
799 return cpu_online_mask
;
801 return node_to_cpumask_map
[node
];
803 EXPORT_SYMBOL(cpumask_of_node
);
805 #endif /* !CONFIG_DEBUG_PER_CPU_MAPS */
807 #ifdef CONFIG_MEMORY_HOTPLUG
808 int memory_add_physaddr_to_nid(u64 start
)
810 struct numa_meminfo
*mi
= &numa_meminfo
;
811 int nid
= mi
->blk
[0].nid
;
814 for (i
= 0; i
< mi
->nr_blks
; i
++)
815 if (mi
->blk
[i
].start
<= start
&& mi
->blk
[i
].end
> start
)
816 nid
= mi
->blk
[i
].nid
;
819 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid
);