|
|
@@ -18,20 +18,10 @@
|
|
|
#include <asm/e820.h>
|
|
|
#include <asm/proto.h>
|
|
|
#include <asm/dma.h>
|
|
|
-#include <asm/numa.h>
|
|
|
#include <asm/acpi.h>
|
|
|
#include <asm/amd_nb.h>
|
|
|
|
|
|
-struct numa_memblk {
|
|
|
- u64 start;
|
|
|
- u64 end;
|
|
|
- int nid;
|
|
|
-};
|
|
|
-
|
|
|
-struct numa_meminfo {
|
|
|
- int nr_blks;
|
|
|
- struct numa_memblk blk[NR_NODE_MEMBLKS];
|
|
|
-};
|
|
|
+#include "numa_internal.h"
|
|
|
|
|
|
struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
|
|
|
EXPORT_SYMBOL(node_data);
|
|
|
@@ -215,7 +205,7 @@ static int __init numa_add_memblk_to(int nid, u64 start, u64 end,
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-static void __init numa_remove_memblk_from(int idx, struct numa_meminfo *mi)
|
|
|
+void __init numa_remove_memblk_from(int idx, struct numa_meminfo *mi)
|
|
|
{
|
|
|
mi->nr_blks--;
|
|
|
memmove(&mi->blk[idx], &mi->blk[idx + 1],
|
|
|
@@ -273,7 +263,7 @@ setup_node_bootmem(int nodeid, unsigned long start, unsigned long end)
|
|
|
node_set_online(nodeid);
|
|
|
}
|
|
|
|
|
|
-static int __init numa_cleanup_meminfo(struct numa_meminfo *mi)
|
|
|
+int __init numa_cleanup_meminfo(struct numa_meminfo *mi)
|
|
|
{
|
|
|
const u64 low = 0;
|
|
|
const u64 high = (u64)max_pfn << PAGE_SHIFT;
|
|
|
@@ -367,7 +357,7 @@ static void __init numa_nodemask_from_meminfo(nodemask_t *nodemask,
|
|
|
* Reset distance table. The current table is freed. The next
|
|
|
* numa_set_distance() call will create a new one.
|
|
|
*/
|
|
|
-static void __init numa_reset_distance(void)
|
|
|
+void __init numa_reset_distance(void)
|
|
|
{
|
|
|
size_t size;
|
|
|
|
|
|
@@ -525,388 +515,6 @@ static int __init numa_register_memblks(struct numa_meminfo *mi)
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
-#ifdef CONFIG_NUMA_EMU
|
|
|
-/* Numa emulation */
|
|
|
-static int emu_nid_to_phys[MAX_NUMNODES] __cpuinitdata;
|
|
|
-static char *emu_cmdline __initdata;
|
|
|
-
|
|
|
-void __init numa_emu_cmdline(char *str)
|
|
|
-{
|
|
|
- emu_cmdline = str;
|
|
|
-}
|
|
|
-
|
|
|
-static int __init emu_find_memblk_by_nid(int nid, const struct numa_meminfo *mi)
|
|
|
-{
|
|
|
- int i;
|
|
|
-
|
|
|
- for (i = 0; i < mi->nr_blks; i++)
|
|
|
- if (mi->blk[i].nid == nid)
|
|
|
- return i;
|
|
|
- return -ENOENT;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * Sets up nid to range from @start to @end. The return value is -errno if
|
|
|
- * something went wrong, 0 otherwise.
|
|
|
- */
|
|
|
-static int __init emu_setup_memblk(struct numa_meminfo *ei,
|
|
|
- struct numa_meminfo *pi,
|
|
|
- int nid, int phys_blk, u64 size)
|
|
|
-{
|
|
|
- struct numa_memblk *eb = &ei->blk[ei->nr_blks];
|
|
|
- struct numa_memblk *pb = &pi->blk[phys_blk];
|
|
|
-
|
|
|
- if (ei->nr_blks >= NR_NODE_MEMBLKS) {
|
|
|
- pr_err("NUMA: Too many emulated memblks, failing emulation\n");
|
|
|
- return -EINVAL;
|
|
|
- }
|
|
|
-
|
|
|
- ei->nr_blks++;
|
|
|
- eb->start = pb->start;
|
|
|
- eb->end = pb->start + size;
|
|
|
- eb->nid = nid;
|
|
|
-
|
|
|
- if (emu_nid_to_phys[nid] == NUMA_NO_NODE)
|
|
|
- emu_nid_to_phys[nid] = pb->nid;
|
|
|
-
|
|
|
- pb->start += size;
|
|
|
- if (pb->start >= pb->end) {
|
|
|
- WARN_ON_ONCE(pb->start > pb->end);
|
|
|
- numa_remove_memblk_from(phys_blk, pi);
|
|
|
- }
|
|
|
-
|
|
|
- printk(KERN_INFO "Faking node %d at %016Lx-%016Lx (%LuMB)\n", nid,
|
|
|
- eb->start, eb->end, (eb->end - eb->start) >> 20);
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * Sets up nr_nodes fake nodes interleaved over physical nodes ranging from addr
|
|
|
- * to max_addr. The return value is the number of nodes allocated.
|
|
|
- */
|
|
|
-static int __init split_nodes_interleave(struct numa_meminfo *ei,
|
|
|
- struct numa_meminfo *pi,
|
|
|
- u64 addr, u64 max_addr, int nr_nodes)
|
|
|
-{
|
|
|
- nodemask_t physnode_mask = NODE_MASK_NONE;
|
|
|
- u64 size;
|
|
|
- int big;
|
|
|
- int nid = 0;
|
|
|
- int i, ret;
|
|
|
-
|
|
|
- if (nr_nodes <= 0)
|
|
|
- return -1;
|
|
|
- if (nr_nodes > MAX_NUMNODES) {
|
|
|
- pr_info("numa=fake=%d too large, reducing to %d\n",
|
|
|
- nr_nodes, MAX_NUMNODES);
|
|
|
- nr_nodes = MAX_NUMNODES;
|
|
|
- }
|
|
|
-
|
|
|
- size = (max_addr - addr - memblock_x86_hole_size(addr, max_addr)) / nr_nodes;
|
|
|
- /*
|
|
|
- * Calculate the number of big nodes that can be allocated as a result
|
|
|
- * of consolidating the remainder.
|
|
|
- */
|
|
|
- big = ((size & ~FAKE_NODE_MIN_HASH_MASK) * nr_nodes) /
|
|
|
- FAKE_NODE_MIN_SIZE;
|
|
|
-
|
|
|
- size &= FAKE_NODE_MIN_HASH_MASK;
|
|
|
- if (!size) {
|
|
|
- pr_err("Not enough memory for each node. "
|
|
|
- "NUMA emulation disabled.\n");
|
|
|
- return -1;
|
|
|
- }
|
|
|
-
|
|
|
- for (i = 0; i < pi->nr_blks; i++)
|
|
|
- node_set(pi->blk[i].nid, physnode_mask);
|
|
|
-
|
|
|
- /*
|
|
|
- * Continue to fill physical nodes with fake nodes until there is no
|
|
|
- * memory left on any of them.
|
|
|
- */
|
|
|
- while (nodes_weight(physnode_mask)) {
|
|
|
- for_each_node_mask(i, physnode_mask) {
|
|
|
- u64 dma32_end = PFN_PHYS(MAX_DMA32_PFN);
|
|
|
- u64 start, limit, end;
|
|
|
- int phys_blk;
|
|
|
-
|
|
|
- phys_blk = emu_find_memblk_by_nid(i, pi);
|
|
|
- if (phys_blk < 0) {
|
|
|
- node_clear(i, physnode_mask);
|
|
|
- continue;
|
|
|
- }
|
|
|
- start = pi->blk[phys_blk].start;
|
|
|
- limit = pi->blk[phys_blk].end;
|
|
|
- end = start + size;
|
|
|
-
|
|
|
- if (nid < big)
|
|
|
- end += FAKE_NODE_MIN_SIZE;
|
|
|
-
|
|
|
- /*
|
|
|
- * Continue to add memory to this fake node if its
|
|
|
- * non-reserved memory is less than the per-node size.
|
|
|
- */
|
|
|
- while (end - start -
|
|
|
- memblock_x86_hole_size(start, end) < size) {
|
|
|
- end += FAKE_NODE_MIN_SIZE;
|
|
|
- if (end > limit) {
|
|
|
- end = limit;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /*
|
|
|
- * If there won't be at least FAKE_NODE_MIN_SIZE of
|
|
|
- * non-reserved memory in ZONE_DMA32 for the next node,
|
|
|
- * this one must extend to the boundary.
|
|
|
- */
|
|
|
- if (end < dma32_end && dma32_end - end -
|
|
|
- memblock_x86_hole_size(end, dma32_end) < FAKE_NODE_MIN_SIZE)
|
|
|
- end = dma32_end;
|
|
|
-
|
|
|
- /*
|
|
|
- * If there won't be enough non-reserved memory for the
|
|
|
- * next node, this one must extend to the end of the
|
|
|
- * physical node.
|
|
|
- */
|
|
|
- if (limit - end -
|
|
|
- memblock_x86_hole_size(end, limit) < size)
|
|
|
- end = limit;
|
|
|
-
|
|
|
- ret = emu_setup_memblk(ei, pi, nid++ % nr_nodes,
|
|
|
- phys_blk,
|
|
|
- min(end, limit) - start);
|
|
|
- if (ret < 0)
|
|
|
- return ret;
|
|
|
- }
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * Returns the end address of a node so that there is at least `size' amount of
|
|
|
- * non-reserved memory or `max_addr' is reached.
|
|
|
- */
|
|
|
-static u64 __init find_end_of_node(u64 start, u64 max_addr, u64 size)
|
|
|
-{
|
|
|
- u64 end = start + size;
|
|
|
-
|
|
|
- while (end - start - memblock_x86_hole_size(start, end) < size) {
|
|
|
- end += FAKE_NODE_MIN_SIZE;
|
|
|
- if (end > max_addr) {
|
|
|
- end = max_addr;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return end;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * Sets up fake nodes of `size' interleaved over physical nodes ranging from
|
|
|
- * `addr' to `max_addr'. The return value is the number of nodes allocated.
|
|
|
- */
|
|
|
-static int __init split_nodes_size_interleave(struct numa_meminfo *ei,
|
|
|
- struct numa_meminfo *pi,
|
|
|
- u64 addr, u64 max_addr, u64 size)
|
|
|
-{
|
|
|
- nodemask_t physnode_mask = NODE_MASK_NONE;
|
|
|
- u64 min_size;
|
|
|
- int nid = 0;
|
|
|
- int i, ret;
|
|
|
-
|
|
|
- if (!size)
|
|
|
- return -1;
|
|
|
- /*
|
|
|
- * The limit on emulated nodes is MAX_NUMNODES, so the size per node is
|
|
|
- * increased accordingly if the requested size is too small. This
|
|
|
- * creates a uniform distribution of node sizes across the entire
|
|
|
- * machine (but not necessarily over physical nodes).
|
|
|
- */
|
|
|
- min_size = (max_addr - addr - memblock_x86_hole_size(addr, max_addr)) /
|
|
|
- MAX_NUMNODES;
|
|
|
- min_size = max(min_size, FAKE_NODE_MIN_SIZE);
|
|
|
- if ((min_size & FAKE_NODE_MIN_HASH_MASK) < min_size)
|
|
|
- min_size = (min_size + FAKE_NODE_MIN_SIZE) &
|
|
|
- FAKE_NODE_MIN_HASH_MASK;
|
|
|
- if (size < min_size) {
|
|
|
- pr_err("Fake node size %LuMB too small, increasing to %LuMB\n",
|
|
|
- size >> 20, min_size >> 20);
|
|
|
- size = min_size;
|
|
|
- }
|
|
|
- size &= FAKE_NODE_MIN_HASH_MASK;
|
|
|
-
|
|
|
- for (i = 0; i < pi->nr_blks; i++)
|
|
|
- node_set(pi->blk[i].nid, physnode_mask);
|
|
|
-
|
|
|
- /*
|
|
|
- * Fill physical nodes with fake nodes of size until there is no memory
|
|
|
- * left on any of them.
|
|
|
- */
|
|
|
- while (nodes_weight(physnode_mask)) {
|
|
|
- for_each_node_mask(i, physnode_mask) {
|
|
|
- u64 dma32_end = MAX_DMA32_PFN << PAGE_SHIFT;
|
|
|
- u64 start, limit, end;
|
|
|
- int phys_blk;
|
|
|
-
|
|
|
- phys_blk = emu_find_memblk_by_nid(i, pi);
|
|
|
- if (phys_blk < 0) {
|
|
|
- node_clear(i, physnode_mask);
|
|
|
- continue;
|
|
|
- }
|
|
|
- start = pi->blk[phys_blk].start;
|
|
|
- limit = pi->blk[phys_blk].end;
|
|
|
-
|
|
|
- end = find_end_of_node(start, limit, size);
|
|
|
- /*
|
|
|
- * If there won't be at least FAKE_NODE_MIN_SIZE of
|
|
|
- * non-reserved memory in ZONE_DMA32 for the next node,
|
|
|
- * this one must extend to the boundary.
|
|
|
- */
|
|
|
- if (end < dma32_end && dma32_end - end -
|
|
|
- memblock_x86_hole_size(end, dma32_end) < FAKE_NODE_MIN_SIZE)
|
|
|
- end = dma32_end;
|
|
|
-
|
|
|
- /*
|
|
|
- * If there won't be enough non-reserved memory for the
|
|
|
- * next node, this one must extend to the end of the
|
|
|
- * physical node.
|
|
|
- */
|
|
|
- if (limit - end -
|
|
|
- memblock_x86_hole_size(end, limit) < size)
|
|
|
- end = limit;
|
|
|
-
|
|
|
- ret = emu_setup_memblk(ei, pi, nid++ % MAX_NUMNODES,
|
|
|
- phys_blk,
|
|
|
- min(end, limit) - start);
|
|
|
- if (ret < 0)
|
|
|
- return ret;
|
|
|
- }
|
|
|
- }
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * Sets up the system RAM area from start_pfn to last_pfn according to the
|
|
|
- * numa=fake command-line option.
|
|
|
- */
|
|
|
-static void __init numa_emulation(struct numa_meminfo *numa_meminfo,
|
|
|
- int numa_dist_cnt)
|
|
|
-{
|
|
|
- static struct numa_meminfo ei __initdata;
|
|
|
- static struct numa_meminfo pi __initdata;
|
|
|
- const u64 max_addr = max_pfn << PAGE_SHIFT;
|
|
|
- u8 *phys_dist = NULL;
|
|
|
- int i, j, ret;
|
|
|
-
|
|
|
- if (!emu_cmdline)
|
|
|
- goto no_emu;
|
|
|
-
|
|
|
- memset(&ei, 0, sizeof(ei));
|
|
|
- pi = *numa_meminfo;
|
|
|
-
|
|
|
- for (i = 0; i < MAX_NUMNODES; i++)
|
|
|
- emu_nid_to_phys[i] = NUMA_NO_NODE;
|
|
|
-
|
|
|
- /*
|
|
|
- * If the numa=fake command-line contains a 'M' or 'G', it represents
|
|
|
- * the fixed node size. Otherwise, if it is just a single number N,
|
|
|
- * split the system RAM into N fake nodes.
|
|
|
- */
|
|
|
- if (strchr(emu_cmdline, 'M') || strchr(emu_cmdline, 'G')) {
|
|
|
- u64 size;
|
|
|
-
|
|
|
- size = memparse(emu_cmdline, &emu_cmdline);
|
|
|
- ret = split_nodes_size_interleave(&ei, &pi, 0, max_addr, size);
|
|
|
- } else {
|
|
|
- unsigned long n;
|
|
|
-
|
|
|
- n = simple_strtoul(emu_cmdline, NULL, 0);
|
|
|
- ret = split_nodes_interleave(&ei, &pi, 0, max_addr, n);
|
|
|
- }
|
|
|
-
|
|
|
- if (ret < 0)
|
|
|
- goto no_emu;
|
|
|
-
|
|
|
- if (numa_cleanup_meminfo(&ei) < 0) {
|
|
|
- pr_warning("NUMA: Warning: constructed meminfo invalid, disabling emulation\n");
|
|
|
- goto no_emu;
|
|
|
- }
|
|
|
-
|
|
|
- /*
|
|
|
- * Copy the original distance table. It's temporary so no need to
|
|
|
- * reserve it.
|
|
|
- */
|
|
|
- if (numa_dist_cnt) {
|
|
|
- size_t size = numa_dist_cnt * sizeof(phys_dist[0]);
|
|
|
- u64 phys;
|
|
|
-
|
|
|
- phys = memblock_find_in_range(0,
|
|
|
- (u64)max_pfn_mapped << PAGE_SHIFT,
|
|
|
- size, PAGE_SIZE);
|
|
|
- if (phys == MEMBLOCK_ERROR) {
|
|
|
- pr_warning("NUMA: Warning: can't allocate copy of distance table, disabling emulation\n");
|
|
|
- goto no_emu;
|
|
|
- }
|
|
|
- phys_dist = __va(phys);
|
|
|
-
|
|
|
- for (i = 0; i < numa_dist_cnt; i++)
|
|
|
- for (j = 0; j < numa_dist_cnt; j++)
|
|
|
- phys_dist[i * numa_dist_cnt + j] =
|
|
|
- node_distance(i, j);
|
|
|
- }
|
|
|
-
|
|
|
- /* commit */
|
|
|
- *numa_meminfo = ei;
|
|
|
-
|
|
|
- /*
|
|
|
- * Transform __apicid_to_node table to use emulated nids by
|
|
|
- * reverse-mapping phys_nid. The maps should always exist but fall
|
|
|
- * back to zero just in case.
|
|
|
- */
|
|
|
- for (i = 0; i < ARRAY_SIZE(__apicid_to_node); i++) {
|
|
|
- if (__apicid_to_node[i] == NUMA_NO_NODE)
|
|
|
- continue;
|
|
|
- for (j = 0; j < ARRAY_SIZE(emu_nid_to_phys); j++)
|
|
|
- if (__apicid_to_node[i] == emu_nid_to_phys[j])
|
|
|
- break;
|
|
|
- __apicid_to_node[i] = j < ARRAY_SIZE(emu_nid_to_phys) ? j : 0;
|
|
|
- }
|
|
|
-
|
|
|
- /* make sure all emulated nodes are mapped to a physical node */
|
|
|
- for (i = 0; i < ARRAY_SIZE(emu_nid_to_phys); i++)
|
|
|
- if (emu_nid_to_phys[i] == NUMA_NO_NODE)
|
|
|
- emu_nid_to_phys[i] = 0;
|
|
|
-
|
|
|
- /* transform distance table */
|
|
|
- numa_reset_distance();
|
|
|
- for (i = 0; i < MAX_NUMNODES; i++) {
|
|
|
- for (j = 0; j < MAX_NUMNODES; j++) {
|
|
|
- int physi = emu_nid_to_phys[i];
|
|
|
- int physj = emu_nid_to_phys[j];
|
|
|
- int dist;
|
|
|
-
|
|
|
- if (physi >= numa_dist_cnt || physj >= numa_dist_cnt)
|
|
|
- dist = physi == physj ?
|
|
|
- LOCAL_DISTANCE : REMOTE_DISTANCE;
|
|
|
- else
|
|
|
- dist = phys_dist[physi * numa_dist_cnt + physj];
|
|
|
-
|
|
|
- numa_set_distance(i, j, dist);
|
|
|
- }
|
|
|
- }
|
|
|
- return;
|
|
|
-
|
|
|
-no_emu:
|
|
|
- /* No emulation. Build identity emu_nid_to_phys[] for numa_add_cpu() */
|
|
|
- for (i = 0; i < ARRAY_SIZE(emu_nid_to_phys); i++)
|
|
|
- emu_nid_to_phys[i] = i;
|
|
|
-}
|
|
|
-#else /* CONFIG_NUMA_EMU */
|
|
|
-static inline void numa_emulation(struct numa_meminfo *numa_meminfo,
|
|
|
- int numa_dist_cnt)
|
|
|
-{ }
|
|
|
-#endif /* CONFIG_NUMA_EMU */
|
|
|
-
|
|
|
static int __init dummy_numa_init(void)
|
|
|
{
|
|
|
printk(KERN_INFO "%s\n",
|
|
|
@@ -994,83 +602,3 @@ int __cpuinit numa_cpu_node(int cpu)
|
|
|
return __apicid_to_node[apicid];
|
|
|
return NUMA_NO_NODE;
|
|
|
}
|
|
|
-
|
|
|
-/*
|
|
|
- * UGLINESS AHEAD: Currently, CONFIG_NUMA_EMU is 64bit only and makes use
|
|
|
- * of 64bit specific data structures. The distinction is artificial and
|
|
|
- * should be removed. numa_{add|remove}_cpu() are implemented in numa.c
|
|
|
- * for both 32 and 64bit when CONFIG_NUMA_EMU is disabled but here when
|
|
|
- * enabled.
|
|
|
- *
|
|
|
- * NUMA emulation is planned to be made generic and the following and other
|
|
|
- * related code should be moved to numa.c.
|
|
|
- */
|
|
|
-#ifdef CONFIG_NUMA_EMU
|
|
|
-# ifndef CONFIG_DEBUG_PER_CPU_MAPS
|
|
|
-void __cpuinit numa_add_cpu(int cpu)
|
|
|
-{
|
|
|
- int physnid, nid;
|
|
|
-
|
|
|
- nid = numa_cpu_node(cpu);
|
|
|
- if (nid == NUMA_NO_NODE)
|
|
|
- nid = early_cpu_to_node(cpu);
|
|
|
- BUG_ON(nid == NUMA_NO_NODE || !node_online(nid));
|
|
|
-
|
|
|
- physnid = emu_nid_to_phys[nid];
|
|
|
-
|
|
|
- /*
|
|
|
- * Map the cpu to each emulated node that is allocated on the physical
|
|
|
- * node of the cpu's apic id.
|
|
|
- */
|
|
|
- for_each_online_node(nid)
|
|
|
- if (emu_nid_to_phys[nid] == physnid)
|
|
|
- cpumask_set_cpu(cpu, node_to_cpumask_map[nid]);
|
|
|
-}
|
|
|
-
|
|
|
-void __cpuinit numa_remove_cpu(int cpu)
|
|
|
-{
|
|
|
- int i;
|
|
|
-
|
|
|
- for_each_online_node(i)
|
|
|
- cpumask_clear_cpu(cpu, node_to_cpumask_map[i]);
|
|
|
-}
|
|
|
-# else /* !CONFIG_DEBUG_PER_CPU_MAPS */
|
|
|
-static void __cpuinit numa_set_cpumask(int cpu, int enable)
|
|
|
-{
|
|
|
- struct cpumask *mask;
|
|
|
- int nid, physnid, i;
|
|
|
-
|
|
|
- nid = early_cpu_to_node(cpu);
|
|
|
- if (nid == NUMA_NO_NODE) {
|
|
|
- /* early_cpu_to_node() already emits a warning and trace */
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- physnid = emu_nid_to_phys[nid];
|
|
|
-
|
|
|
- for_each_online_node(i) {
|
|
|
- if (emu_nid_to_phys[nid] != physnid)
|
|
|
- continue;
|
|
|
-
|
|
|
- mask = debug_cpumask_set_cpu(cpu, enable);
|
|
|
- if (!mask)
|
|
|
- return;
|
|
|
-
|
|
|
- if (enable)
|
|
|
- cpumask_set_cpu(cpu, mask);
|
|
|
- else
|
|
|
- cpumask_clear_cpu(cpu, mask);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void __cpuinit numa_add_cpu(int cpu)
|
|
|
-{
|
|
|
- numa_set_cpumask(cpu, 1);
|
|
|
-}
|
|
|
-
|
|
|
-void __cpuinit numa_remove_cpu(int cpu)
|
|
|
-{
|
|
|
- numa_set_cpumask(cpu, 0);
|
|
|
-}
|
|
|
-# endif /* !CONFIG_DEBUG_PER_CPU_MAPS */
|
|
|
-#endif /* CONFIG_NUMA_EMU */
|
Tejun Heo