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
] __cpuinitdata
= {
60 [0 ... MAX_LOCAL_APIC
-1] = NUMA_NO_NODE
63 int __cpuinit
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 __cpuinit
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 if (node
!= NUMA_NO_NODE
)
101 set_cpu_numa_node(cpu
, node
);
104 void __cpuinit
numa_clear_node(int cpu
)
106 numa_set_node(cpu
, NUMA_NO_NODE
);
110 * Allocate node_to_cpumask_map based on number of available nodes
111 * Requires node_possible_map to be valid.
113 * Note: node_to_cpumask() is not valid until after this is done.
114 * (Use CONFIG_DEBUG_PER_CPU_MAPS to check this.)
116 void __init
setup_node_to_cpumask_map(void)
118 unsigned int node
, num
= 0;
120 /* setup nr_node_ids if not done yet */
121 if (nr_node_ids
== MAX_NUMNODES
) {
122 for_each_node_mask(node
, node_possible_map
)
124 nr_node_ids
= num
+ 1;
127 /* allocate the map */
128 for (node
= 0; node
< nr_node_ids
; node
++)
129 alloc_bootmem_cpumask_var(&node_to_cpumask_map
[node
]);
131 /* cpumask_of_node() will now work */
132 pr_debug("Node to cpumask map for %d nodes\n", nr_node_ids
);
135 static int __init
numa_add_memblk_to(int nid
, u64 start
, u64 end
,
136 struct numa_meminfo
*mi
)
138 /* ignore zero length blks */
142 /* whine about and ignore invalid blks */
143 if (start
> end
|| nid
< 0 || nid
>= MAX_NUMNODES
) {
144 pr_warning("NUMA: Warning: invalid memblk node %d (%Lx-%Lx)\n",
149 if (mi
->nr_blks
>= NR_NODE_MEMBLKS
) {
150 pr_err("NUMA: too many memblk ranges\n");
154 mi
->blk
[mi
->nr_blks
].start
= start
;
155 mi
->blk
[mi
->nr_blks
].end
= end
;
156 mi
->blk
[mi
->nr_blks
].nid
= nid
;
162 * numa_remove_memblk_from - Remove one numa_memblk from a numa_meminfo
163 * @idx: Index of memblk to remove
164 * @mi: numa_meminfo to remove memblk from
166 * Remove @idx'th numa_memblk from @mi by shifting @mi->blk[] and
167 * decrementing @mi->nr_blks.
169 void __init
numa_remove_memblk_from(int idx
, struct numa_meminfo
*mi
)
172 memmove(&mi
->blk
[idx
], &mi
->blk
[idx
+ 1],
173 (mi
->nr_blks
- idx
) * sizeof(mi
->blk
[0]));
177 * numa_add_memblk - Add one numa_memblk to numa_meminfo
178 * @nid: NUMA node ID of the new memblk
179 * @start: Start address of the new memblk
180 * @end: End address of the new memblk
182 * Add a new memblk to the default numa_meminfo.
185 * 0 on success, -errno on failure.
187 int __init
numa_add_memblk(int nid
, u64 start
, u64 end
)
189 return numa_add_memblk_to(nid
, start
, end
, &numa_meminfo
);
192 /* Initialize NODE_DATA for a node on the local memory */
193 static void __init
setup_node_data(int nid
, u64 start
, u64 end
)
195 const u64 nd_low
= PFN_PHYS(MAX_DMA_PFN
);
196 const u64 nd_high
= PFN_PHYS(max_pfn_mapped
);
197 const size_t nd_size
= roundup(sizeof(pg_data_t
), PAGE_SIZE
);
198 bool remapped
= false;
204 * Don't confuse VM with a node that doesn't have the
205 * minimum amount of memory:
207 if (end
&& (end
- start
) < NODE_MIN_SIZE
)
210 /* initialize remap allocator before aligning to ZONE_ALIGN */
211 init_alloc_remap(nid
, start
, end
);
213 start
= roundup(start
, ZONE_ALIGN
);
215 printk(KERN_INFO
"Initmem setup node %d %016Lx-%016Lx\n",
219 * Allocate node data. Try remap allocator first, node-local
220 * memory and then any node. Never allocate in DMA zone.
222 nd
= alloc_remap(nid
, nd_size
);
227 nd_pa
= memblock_x86_find_in_range_node(nid
, nd_low
, nd_high
,
228 nd_size
, SMP_CACHE_BYTES
);
229 if (nd_pa
== MEMBLOCK_ERROR
)
230 nd_pa
= memblock_find_in_range(nd_low
, nd_high
,
231 nd_size
, SMP_CACHE_BYTES
);
232 if (nd_pa
== MEMBLOCK_ERROR
) {
233 pr_err("Cannot find %zu bytes in node %d\n",
237 memblock_x86_reserve_range(nd_pa
, nd_pa
+ nd_size
, "NODE_DATA");
241 /* report and initialize */
242 printk(KERN_INFO
" NODE_DATA [%016Lx - %016Lx]%s\n",
243 nd_pa
, nd_pa
+ nd_size
- 1, remapped
? " (remapped)" : "");
244 tnid
= early_pfn_to_nid(nd_pa
>> PAGE_SHIFT
);
245 if (!remapped
&& tnid
!= nid
)
246 printk(KERN_INFO
" NODE_DATA(%d) on node %d\n", nid
, tnid
);
249 memset(NODE_DATA(nid
), 0, sizeof(pg_data_t
));
250 NODE_DATA(nid
)->node_id
= nid
;
251 NODE_DATA(nid
)->node_start_pfn
= start
>> PAGE_SHIFT
;
252 NODE_DATA(nid
)->node_spanned_pages
= (end
- start
) >> PAGE_SHIFT
;
254 node_set_online(nid
);
258 * numa_cleanup_meminfo - Cleanup a numa_meminfo
259 * @mi: numa_meminfo to clean up
261 * Sanitize @mi by merging and removing unncessary memblks. Also check for
262 * conflicts and clear unused memblks.
265 * 0 on success, -errno on failure.
267 int __init
numa_cleanup_meminfo(struct numa_meminfo
*mi
)
270 const u64 high
= PFN_PHYS(max_pfn
);
273 /* first, trim all entries */
274 for (i
= 0; i
< mi
->nr_blks
; i
++) {
275 struct numa_memblk
*bi
= &mi
->blk
[i
];
277 /* make sure all blocks are inside the limits */
278 bi
->start
= max(bi
->start
, low
);
279 bi
->end
= min(bi
->end
, high
);
281 /* and there's no empty block */
282 if (bi
->start
>= bi
->end
)
283 numa_remove_memblk_from(i
--, mi
);
286 /* merge neighboring / overlapping entries */
287 for (i
= 0; i
< mi
->nr_blks
; i
++) {
288 struct numa_memblk
*bi
= &mi
->blk
[i
];
290 for (j
= i
+ 1; j
< mi
->nr_blks
; j
++) {
291 struct numa_memblk
*bj
= &mi
->blk
[j
];
295 * See whether there are overlapping blocks. Whine
296 * about but allow overlaps of the same nid. They
297 * will be merged below.
299 if (bi
->end
> bj
->start
&& bi
->start
< bj
->end
) {
300 if (bi
->nid
!= bj
->nid
) {
301 pr_err("NUMA: node %d (%Lx-%Lx) overlaps with node %d (%Lx-%Lx)\n",
302 bi
->nid
, bi
->start
, bi
->end
,
303 bj
->nid
, bj
->start
, bj
->end
);
306 pr_warning("NUMA: Warning: node %d (%Lx-%Lx) overlaps with itself (%Lx-%Lx)\n",
307 bi
->nid
, bi
->start
, bi
->end
,
312 * Join together blocks on the same node, holes
313 * between which don't overlap with memory on other
316 if (bi
->nid
!= bj
->nid
)
318 start
= min(bi
->start
, bj
->start
);
319 end
= max(bi
->end
, bj
->end
);
320 for (k
= 0; k
< mi
->nr_blks
; k
++) {
321 struct numa_memblk
*bk
= &mi
->blk
[k
];
323 if (bi
->nid
== bk
->nid
)
325 if (start
< bk
->end
&& end
> bk
->start
)
330 printk(KERN_INFO
"NUMA: Node %d [%Lx,%Lx) + [%Lx,%Lx) -> [%Lx,%Lx)\n",
331 bi
->nid
, bi
->start
, bi
->end
, bj
->start
, bj
->end
,
335 numa_remove_memblk_from(j
--, mi
);
339 /* clear unused ones */
340 for (i
= mi
->nr_blks
; i
< ARRAY_SIZE(mi
->blk
); i
++) {
341 mi
->blk
[i
].start
= mi
->blk
[i
].end
= 0;
342 mi
->blk
[i
].nid
= NUMA_NO_NODE
;
349 * Set nodes, which have memory in @mi, in *@nodemask.
351 static void __init
numa_nodemask_from_meminfo(nodemask_t
*nodemask
,
352 const struct numa_meminfo
*mi
)
356 for (i
= 0; i
< ARRAY_SIZE(mi
->blk
); i
++)
357 if (mi
->blk
[i
].start
!= mi
->blk
[i
].end
&&
358 mi
->blk
[i
].nid
!= NUMA_NO_NODE
)
359 node_set(mi
->blk
[i
].nid
, *nodemask
);
363 * numa_reset_distance - Reset NUMA distance table
365 * The current table is freed. The next numa_set_distance() call will
368 void __init
numa_reset_distance(void)
370 size_t size
= numa_distance_cnt
* numa_distance_cnt
* sizeof(numa_distance
[0]);
372 /* numa_distance could be 1LU marking allocation failure, test cnt */
373 if (numa_distance_cnt
)
374 memblock_x86_free_range(__pa(numa_distance
),
375 __pa(numa_distance
) + size
);
376 numa_distance_cnt
= 0;
377 numa_distance
= NULL
; /* enable table creation */
380 static int __init
numa_alloc_distance(void)
382 nodemask_t nodes_parsed
;
387 /* size the new table and allocate it */
388 nodes_parsed
= numa_nodes_parsed
;
389 numa_nodemask_from_meminfo(&nodes_parsed
, &numa_meminfo
);
391 for_each_node_mask(i
, nodes_parsed
)
394 size
= cnt
* cnt
* sizeof(numa_distance
[0]);
396 phys
= memblock_find_in_range(0, PFN_PHYS(max_pfn_mapped
),
398 if (phys
== MEMBLOCK_ERROR
) {
399 pr_warning("NUMA: Warning: can't allocate distance table!\n");
400 /* don't retry until explicitly reset */
401 numa_distance
= (void *)1LU;
404 memblock_x86_reserve_range(phys
, phys
+ size
, "NUMA DIST");
406 numa_distance
= __va(phys
);
407 numa_distance_cnt
= cnt
;
409 /* fill with the default distances */
410 for (i
= 0; i
< cnt
; i
++)
411 for (j
= 0; j
< cnt
; j
++)
412 numa_distance
[i
* cnt
+ j
] = i
== j
?
413 LOCAL_DISTANCE
: REMOTE_DISTANCE
;
414 printk(KERN_DEBUG
"NUMA: Initialized distance table, cnt=%d\n", cnt
);
420 * numa_set_distance - Set NUMA distance from one NUMA to another
421 * @from: the 'from' node to set distance
422 * @to: the 'to' node to set distance
423 * @distance: NUMA distance
425 * Set the distance from node @from to @to to @distance. If distance table
426 * doesn't exist, one which is large enough to accommodate all the currently
427 * known nodes will be created.
429 * If such table cannot be allocated, a warning is printed and further
430 * calls are ignored until the distance table is reset with
431 * numa_reset_distance().
433 * If @from or @to is higher than the highest known node at the time of
434 * table creation or @distance doesn't make sense, the call is ignored.
435 * This is to allow simplification of specific NUMA config implementations.
437 void __init
numa_set_distance(int from
, int to
, int distance
)
439 if (!numa_distance
&& numa_alloc_distance() < 0)
442 if (from
>= numa_distance_cnt
|| to
>= numa_distance_cnt
) {
443 printk_once(KERN_DEBUG
"NUMA: Debug: distance out of bound, from=%d to=%d distance=%d\n",
448 if ((u8
)distance
!= distance
||
449 (from
== to
&& distance
!= LOCAL_DISTANCE
)) {
450 pr_warn_once("NUMA: Warning: invalid distance parameter, from=%d to=%d distance=%d\n",
455 numa_distance
[from
* numa_distance_cnt
+ to
] = distance
;
458 int __node_distance(int from
, int to
)
460 if (from
>= numa_distance_cnt
|| to
>= numa_distance_cnt
)
461 return from
== to
? LOCAL_DISTANCE
: REMOTE_DISTANCE
;
462 return numa_distance
[from
* numa_distance_cnt
+ to
];
464 EXPORT_SYMBOL(__node_distance
);
467 * Sanity check to catch more bad NUMA configurations (they are amazingly
468 * common). Make sure the nodes cover all memory.
470 static bool __init
numa_meminfo_cover_memory(const struct numa_meminfo
*mi
)
472 u64 numaram
, e820ram
;
476 for (i
= 0; i
< mi
->nr_blks
; i
++) {
477 u64 s
= mi
->blk
[i
].start
>> PAGE_SHIFT
;
478 u64 e
= mi
->blk
[i
].end
>> PAGE_SHIFT
;
480 numaram
-= __absent_pages_in_range(mi
->blk
[i
].nid
, s
, e
);
481 if ((s64
)numaram
< 0)
485 e820ram
= max_pfn
- (memblock_x86_hole_size(0,
486 PFN_PHYS(max_pfn
)) >> PAGE_SHIFT
);
487 /* We seem to lose 3 pages somewhere. Allow 1M of slack. */
488 if ((s64
)(e820ram
- numaram
) >= (1 << (20 - PAGE_SHIFT
))) {
489 printk(KERN_ERR
"NUMA: nodes only cover %LuMB of your %LuMB e820 RAM. Not used.\n",
490 (numaram
<< PAGE_SHIFT
) >> 20,
491 (e820ram
<< PAGE_SHIFT
) >> 20);
497 static int __init
numa_register_memblks(struct numa_meminfo
*mi
)
501 /* Account for nodes with cpus and no memory */
502 node_possible_map
= numa_nodes_parsed
;
503 numa_nodemask_from_meminfo(&node_possible_map
, mi
);
504 if (WARN_ON(nodes_empty(node_possible_map
)))
507 for (i
= 0; i
< mi
->nr_blks
; i
++)
508 memblock_x86_register_active_regions(mi
->blk
[i
].nid
,
509 mi
->blk
[i
].start
>> PAGE_SHIFT
,
510 mi
->blk
[i
].end
>> PAGE_SHIFT
);
512 /* for out of order entries */
514 if (!numa_meminfo_cover_memory(mi
))
517 /* Finally register nodes. */
518 for_each_node_mask(nid
, node_possible_map
) {
519 u64 start
= PFN_PHYS(max_pfn
);
522 for (i
= 0; i
< mi
->nr_blks
; i
++) {
523 if (nid
!= mi
->blk
[i
].nid
)
525 start
= min(mi
->blk
[i
].start
, start
);
526 end
= max(mi
->blk
[i
].end
, end
);
530 setup_node_data(nid
, start
, end
);
537 * There are unfortunately some poorly designed mainboards around that
538 * only connect memory to a single CPU. This breaks the 1:1 cpu->node
539 * mapping. To avoid this fill in the mapping for all possible CPUs,
540 * as the number of CPUs is not known yet. We round robin the existing
543 static void __init
numa_init_array(void)
547 rr
= first_node(node_online_map
);
548 for (i
= 0; i
< nr_cpu_ids
; i
++) {
549 if (early_cpu_to_node(i
) != NUMA_NO_NODE
)
551 numa_set_node(i
, rr
);
552 rr
= next_node(rr
, node_online_map
);
553 if (rr
== MAX_NUMNODES
)
554 rr
= first_node(node_online_map
);
558 static int __init
numa_init(int (*init_func
)(void))
563 for (i
= 0; i
< MAX_LOCAL_APIC
; i
++)
564 set_apicid_to_node(i
, NUMA_NO_NODE
);
566 nodes_clear(numa_nodes_parsed
);
567 nodes_clear(node_possible_map
);
568 nodes_clear(node_online_map
);
569 memset(&numa_meminfo
, 0, sizeof(numa_meminfo
));
570 remove_all_active_ranges();
571 numa_reset_distance();
576 ret
= numa_cleanup_meminfo(&numa_meminfo
);
580 numa_emulation(&numa_meminfo
, numa_distance_cnt
);
582 ret
= numa_register_memblks(&numa_meminfo
);
586 for (i
= 0; i
< nr_cpu_ids
; i
++) {
587 int nid
= early_cpu_to_node(i
);
589 if (nid
== NUMA_NO_NODE
)
591 if (!node_online(nid
))
599 * dummy_numa_init - Fallback dummy NUMA init
601 * Used if there's no underlying NUMA architecture, NUMA initialization
602 * fails, or NUMA is disabled on the command line.
604 * Must online at least one node and add memory blocks that cover all
605 * allowed memory. This function must not fail.
607 static int __init
dummy_numa_init(void)
609 printk(KERN_INFO
"%s\n",
610 numa_off
? "NUMA turned off" : "No NUMA configuration found");
611 printk(KERN_INFO
"Faking a node at %016Lx-%016Lx\n",
612 0LLU, PFN_PHYS(max_pfn
));
614 node_set(0, numa_nodes_parsed
);
615 numa_add_memblk(0, 0, PFN_PHYS(max_pfn
));
621 * x86_numa_init - Initialize NUMA
623 * Try each configured NUMA initialization method until one succeeds. The
624 * last fallback is dummy single node config encomapssing whole memory and
627 void __init
x86_numa_init(void)
630 #ifdef CONFIG_X86_NUMAQ
631 if (!numa_init(numaq_numa_init
))
634 #ifdef CONFIG_ACPI_NUMA
635 if (!numa_init(x86_acpi_numa_init
))
638 #ifdef CONFIG_AMD_NUMA
639 if (!numa_init(amd_numa_init
))
644 numa_init(dummy_numa_init
);
647 static __init
int find_near_online_node(int node
)
650 int min_val
= INT_MAX
;
653 for_each_online_node(n
) {
654 val
= node_distance(node
, n
);
666 * Setup early cpu_to_node.
668 * Populate cpu_to_node[] only if x86_cpu_to_apicid[],
669 * and apicid_to_node[] tables have valid entries for a CPU.
670 * This means we skip cpu_to_node[] initialisation for NUMA
671 * emulation and faking node case (when running a kernel compiled
672 * for NUMA on a non NUMA box), which is OK as cpu_to_node[]
673 * is already initialized in a round robin manner at numa_init_array,
674 * prior to this call, and this initialization is good enough
675 * for the fake NUMA cases.
677 * Called before the per_cpu areas are setup.
679 void __init
init_cpu_to_node(void)
682 u16
*cpu_to_apicid
= early_per_cpu_ptr(x86_cpu_to_apicid
);
684 BUG_ON(cpu_to_apicid
== NULL
);
686 for_each_possible_cpu(cpu
) {
687 int node
= numa_cpu_node(cpu
);
689 if (node
== NUMA_NO_NODE
)
691 if (!node_online(node
))
692 node
= find_near_online_node(node
);
693 numa_set_node(cpu
, node
);
697 #ifndef CONFIG_DEBUG_PER_CPU_MAPS
699 # ifndef CONFIG_NUMA_EMU
700 void __cpuinit
numa_add_cpu(int cpu
)
702 cpumask_set_cpu(cpu
, node_to_cpumask_map
[early_cpu_to_node(cpu
)]);
705 void __cpuinit
numa_remove_cpu(int cpu
)
707 cpumask_clear_cpu(cpu
, node_to_cpumask_map
[early_cpu_to_node(cpu
)]);
709 # endif /* !CONFIG_NUMA_EMU */
711 #else /* !CONFIG_DEBUG_PER_CPU_MAPS */
713 int __cpu_to_node(int cpu
)
715 if (early_per_cpu_ptr(x86_cpu_to_node_map
)) {
717 "cpu_to_node(%d): usage too early!\n", cpu
);
719 return early_per_cpu_ptr(x86_cpu_to_node_map
)[cpu
];
721 return per_cpu(x86_cpu_to_node_map
, cpu
);
723 EXPORT_SYMBOL(__cpu_to_node
);
726 * Same function as cpu_to_node() but used if called before the
727 * per_cpu areas are setup.
729 int early_cpu_to_node(int cpu
)
731 if (early_per_cpu_ptr(x86_cpu_to_node_map
))
732 return early_per_cpu_ptr(x86_cpu_to_node_map
)[cpu
];
734 if (!cpu_possible(cpu
)) {
736 "early_cpu_to_node(%d): no per_cpu area!\n", cpu
);
740 return per_cpu(x86_cpu_to_node_map
, cpu
);
743 void debug_cpumask_set_cpu(int cpu
, int node
, bool enable
)
745 struct cpumask
*mask
;
748 if (node
== NUMA_NO_NODE
) {
749 /* early_cpu_to_node() already emits a warning and trace */
752 mask
= node_to_cpumask_map
[node
];
754 pr_err("node_to_cpumask_map[%i] NULL\n", node
);
760 cpumask_set_cpu(cpu
, mask
);
762 cpumask_clear_cpu(cpu
, mask
);
764 cpulist_scnprintf(buf
, sizeof(buf
), mask
);
765 printk(KERN_DEBUG
"%s cpu %d node %d: mask now %s\n",
766 enable
? "numa_add_cpu" : "numa_remove_cpu",
771 # ifndef CONFIG_NUMA_EMU
772 static void __cpuinit
numa_set_cpumask(int cpu
, bool enable
)
774 debug_cpumask_set_cpu(cpu
, early_cpu_to_node(cpu
), enable
);
777 void __cpuinit
numa_add_cpu(int cpu
)
779 numa_set_cpumask(cpu
, true);
782 void __cpuinit
numa_remove_cpu(int cpu
)
784 numa_set_cpumask(cpu
, false);
786 # endif /* !CONFIG_NUMA_EMU */
789 * Returns a pointer to the bitmask of CPUs on Node 'node'.
791 const struct cpumask
*cpumask_of_node(int node
)
793 if (node
>= nr_node_ids
) {
795 "cpumask_of_node(%d): node > nr_node_ids(%d)\n",
798 return cpu_none_mask
;
800 if (node_to_cpumask_map
[node
] == NULL
) {
802 "cpumask_of_node(%d): no node_to_cpumask_map!\n",
805 return cpu_online_mask
;
807 return node_to_cpumask_map
[node
];
809 EXPORT_SYMBOL(cpumask_of_node
);
811 #endif /* !CONFIG_DEBUG_PER_CPU_MAPS */
813 #ifdef CONFIG_MEMORY_HOTPLUG
814 int memory_add_physaddr_to_nid(u64 start
)
816 struct numa_meminfo
*mi
= &numa_meminfo
;
817 int nid
= mi
->blk
[0].nid
;
820 for (i
= 0; i
< mi
->nr_blks
; i
++)
821 if (mi
->blk
[i
].start
<= start
&& mi
->blk
[i
].end
> start
)
822 nid
= mi
->blk
[i
].nid
;
825 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid
);