[mirror_ubuntu-bionic-kernel.git] / arch / x86_64 / mm / numa.c

/* 
 * Generic VM initialization for x86-64 NUMA setups.
 * Copyright 2002,2003 Andi Kleen, SuSE Labs.
 */ 
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/bootmem.h>
#include <linux/mmzone.h>
#include <linux/ctype.h>
#include <linux/module.h>
#include <linux/nodemask.h>

#include <asm/e820.h>
#include <asm/proto.h>
#include <asm/dma.h>
#include <asm/numa.h>
#include <asm/acpi.h>

#ifndef Dprintk
#define Dprintk(x...)
#endif

struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
bootmem_data_t plat_node_bdata[MAX_NUMNODES];

int memnode_shift;
u8  memnodemap[NODEMAPSIZE];

unsigned char cpu_to_node[NR_CPUS] __read_mostly = {
	[0 ... NR_CPUS-1] = NUMA_NO_NODE
};
unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata = {
 	[0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
};
cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly;

int numa_off __initdata;

int __init compute_hash_shift(struct node *nodes, int numnodes)
{
	int i; 
	int shift = 20;
	unsigned long addr,maxend=0;
	
	for (i = 0; i < numnodes; i++)
		if ((nodes[i].start != nodes[i].end) && (nodes[i].end > maxend))
				maxend = nodes[i].end;

	while ((1UL << shift) <  (maxend / NODEMAPSIZE))
		shift++;

	printk (KERN_DEBUG"Using %d for the hash shift. Max adder is %lx \n",
			shift,maxend);
	memset(memnodemap,0xff,sizeof(*memnodemap) * NODEMAPSIZE);
	for (i = 0; i < numnodes; i++) {
		if (nodes[i].start == nodes[i].end)
			continue;
		for (addr = nodes[i].start;
		     addr < nodes[i].end;
		     addr += (1UL << shift)) {
			if (memnodemap[addr >> shift] != 0xff) {
				printk(KERN_INFO
	"Your memory is not aligned you need to rebuild your kernel "
	"with a bigger NODEMAPSIZE shift=%d adder=%lu\n",
					shift,addr);
				return -1;
			} 
			memnodemap[addr >> shift] = i;
		} 
	} 
	return shift;
}

#ifdef CONFIG_SPARSEMEM
int early_pfn_to_nid(unsigned long pfn)
{
	return phys_to_nid(pfn << PAGE_SHIFT);
}
#endif

/* Initialize bootmem allocator for a node */
void __init setup_node_bootmem(int nodeid, unsigned long start, unsigned long end)
{ 
	unsigned long start_pfn, end_pfn, bootmap_pages, bootmap_size, bootmap_start; 
	unsigned long nodedata_phys;
	const int pgdat_size = round_up(sizeof(pg_data_t), PAGE_SIZE);

	start = round_up(start, ZONE_ALIGN); 

	printk("Bootmem setup node %d %016lx-%016lx\n", nodeid, start, end);

	start_pfn = start >> PAGE_SHIFT;
	end_pfn = end >> PAGE_SHIFT;

	memory_present(nodeid, start_pfn, end_pfn);
	nodedata_phys = find_e820_area(start, end, pgdat_size); 
	if (nodedata_phys == -1L) 
		panic("Cannot find memory pgdat in node %d\n", nodeid);

	Dprintk("nodedata_phys %lx\n", nodedata_phys); 

	node_data[nodeid] = phys_to_virt(nodedata_phys);
	memset(NODE_DATA(nodeid), 0, sizeof(pg_data_t));
	NODE_DATA(nodeid)->bdata = &plat_node_bdata[nodeid];
	NODE_DATA(nodeid)->node_start_pfn = start_pfn;
	NODE_DATA(nodeid)->node_spanned_pages = end_pfn - start_pfn;

	/* Find a place for the bootmem map */
	bootmap_pages = bootmem_bootmap_pages(end_pfn - start_pfn); 
	bootmap_start = round_up(nodedata_phys + pgdat_size, PAGE_SIZE);
	bootmap_start = find_e820_area(bootmap_start, end, bootmap_pages<<PAGE_SHIFT);
	if (bootmap_start == -1L) 
		panic("Not enough continuous space for bootmap on node %d", nodeid); 
	Dprintk("bootmap start %lu pages %lu\n", bootmap_start, bootmap_pages); 
	
	bootmap_size = init_bootmem_node(NODE_DATA(nodeid),
					 bootmap_start >> PAGE_SHIFT, 
					 start_pfn, end_pfn); 

	e820_bootmem_free(NODE_DATA(nodeid), start, end);

	reserve_bootmem_node(NODE_DATA(nodeid), nodedata_phys, pgdat_size); 
	reserve_bootmem_node(NODE_DATA(nodeid), bootmap_start, bootmap_pages<<PAGE_SHIFT);
	node_set_online(nodeid);
} 

/* Initialize final allocator for a zone */
void __init setup_node_zones(int nodeid)
{ 
	unsigned long start_pfn, end_pfn; 
	unsigned long zones[MAX_NR_ZONES];
	unsigned long holes[MAX_NR_ZONES];
	unsigned long dma_end_pfn;

	memset(zones, 0, sizeof(unsigned long) * MAX_NR_ZONES); 
	memset(holes, 0, sizeof(unsigned long) * MAX_NR_ZONES);

	start_pfn = node_start_pfn(nodeid);
	end_pfn = node_end_pfn(nodeid);

	Dprintk(KERN_INFO "setting up node %d %lx-%lx\n", nodeid, start_pfn, end_pfn);
	
	/* All nodes > 0 have a zero length zone DMA */ 
	dma_end_pfn = __pa(MAX_DMA_ADDRESS) >> PAGE_SHIFT; 
	if (start_pfn < dma_end_pfn) { 
		zones[ZONE_DMA] = dma_end_pfn - start_pfn;
		holes[ZONE_DMA] = e820_hole_size(start_pfn, dma_end_pfn);
		zones[ZONE_NORMAL] = end_pfn - dma_end_pfn; 
		holes[ZONE_NORMAL] = e820_hole_size(dma_end_pfn, end_pfn);

	} else { 
		zones[ZONE_NORMAL] = end_pfn - start_pfn; 
		holes[ZONE_NORMAL] = e820_hole_size(start_pfn, end_pfn);
	} 
    
	free_area_init_node(nodeid, NODE_DATA(nodeid), zones,
			    start_pfn, holes);
} 

void __init numa_init_array(void)
{
	int rr, i;
	/* There are unfortunately some poorly designed mainboards around
	   that only connect memory to a single CPU. This breaks the 1:1 cpu->node
	   mapping. To avoid this fill in the mapping for all possible
	   CPUs, as the number of CPUs is not known yet. 
	   We round robin the existing nodes. */
	rr = 0;
	for (i = 0; i < NR_CPUS; i++) {
		if (cpu_to_node[i] != NUMA_NO_NODE)
			continue;
		rr = next_node(rr, node_online_map);
		if (rr == MAX_NUMNODES)
			rr = first_node(node_online_map);
		cpu_to_node[i] = rr;
		rr++; 
	}

}

#ifdef CONFIG_NUMA_EMU
int numa_fake __initdata = 0;

/* Numa emulation */
static int numa_emulation(unsigned long start_pfn, unsigned long end_pfn)
{
 	int i;
 	struct node nodes[MAX_NUMNODES];
 	unsigned long sz = ((end_pfn - start_pfn)<<PAGE_SHIFT) / numa_fake;

 	/* Kludge needed for the hash function */
 	if (hweight64(sz) > 1) {
 		unsigned long x = 1;
 		while ((x << 1) < sz)
 			x <<= 1;
 		if (x < sz/2)
 			printk("Numa emulation unbalanced. Complain to maintainer\n");
 		sz = x;
 	}

 	memset(&nodes,0,sizeof(nodes));
 	for (i = 0; i < numa_fake; i++) {
 		nodes[i].start = (start_pfn<<PAGE_SHIFT) + i*sz;
 		if (i == numa_fake-1)
 			sz = (end_pfn<<PAGE_SHIFT) - nodes[i].start;
 		nodes[i].end = nodes[i].start + sz;
 		if (i != numa_fake-1)
 			nodes[i].end--;
 		printk(KERN_INFO "Faking node %d at %016Lx-%016Lx (%LuMB)\n",
 		       i,
 		       nodes[i].start, nodes[i].end,
 		       (nodes[i].end - nodes[i].start) >> 20);
		node_set_online(i);
 	}
 	memnode_shift = compute_hash_shift(nodes, numa_fake);
 	if (memnode_shift < 0) {
 		memnode_shift = 0;
 		printk(KERN_ERR "No NUMA hash function found. Emulation disabled.\n");
 		return -1;
 	}
 	for_each_online_node(i)
 		setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 	numa_init_array();
 	return 0;
}
#endif

void __init numa_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
{ 
	int i;

#ifdef CONFIG_NUMA_EMU
	if (numa_fake && !numa_emulation(start_pfn, end_pfn))
 		return;
#endif

#ifdef CONFIG_ACPI_NUMA
	if (!numa_off && !acpi_scan_nodes(start_pfn << PAGE_SHIFT,
					  end_pfn << PAGE_SHIFT))
 		return;
#endif

#ifdef CONFIG_K8_NUMA
	if (!numa_off && !k8_scan_nodes(start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT))
		return;
#endif
	printk(KERN_INFO "%s\n",
	       numa_off ? "NUMA turned off" : "No NUMA configuration found");

	printk(KERN_INFO "Faking a node at %016lx-%016lx\n", 
	       start_pfn << PAGE_SHIFT,
	       end_pfn << PAGE_SHIFT); 
		/* setup dummy node covering all memory */ 
	memnode_shift = 63; 
	memnodemap[0] = 0;
	nodes_clear(node_online_map);
	node_set_online(0);
	for (i = 0; i < NR_CPUS; i++)
		cpu_to_node[i] = 0;
	node_to_cpumask[0] = cpumask_of_cpu(0);
	setup_node_bootmem(0, start_pfn << PAGE_SHIFT, end_pfn << PAGE_SHIFT);
}

__cpuinit void numa_add_cpu(int cpu)
{
	set_bit(cpu, &node_to_cpumask[cpu_to_node(cpu)]);
} 

unsigned long __init numa_free_all_bootmem(void) 
{ 
	int i;
	unsigned long pages = 0;
	for_each_online_node(i) {
		pages += free_all_bootmem_node(NODE_DATA(i));
	}
	return pages;
} 

void __init paging_init(void)
{ 
	int i;
	for_each_online_node(i) {
		setup_node_zones(i); 
	}
} 

/* [numa=off] */
__init int numa_setup(char *opt) 
{ 
	if (!strncmp(opt,"off",3))
		numa_off = 1;
#ifdef CONFIG_NUMA_EMU
	if(!strncmp(opt, "fake=", 5)) {
		numa_fake = simple_strtoul(opt+5,NULL,0); ;
		if (numa_fake >= MAX_NUMNODES)
			numa_fake = MAX_NUMNODES;
	}
#endif
#ifdef CONFIG_ACPI_NUMA
 	if (!strncmp(opt,"noacpi",6))
 		acpi_numa = -1;
#endif
	return 1;
} 

EXPORT_SYMBOL(cpu_to_node);
EXPORT_SYMBOL(node_to_cpumask);
EXPORT_SYMBOL(memnode_shift);
EXPORT_SYMBOL(memnodemap);
EXPORT_SYMBOL(node_data);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Generic VM initialization for x86-64 NUMA setups.
	3	* Copyright 2002,2003 Andi Kleen, SuSE Labs.
	4	*/
	5	#include <linux/kernel.h>
	6	#include <linux/mm.h>
	7	#include <linux/string.h>
	8	#include <linux/init.h>
	9	#include <linux/bootmem.h>
	10	#include <linux/mmzone.h>
	11	#include <linux/ctype.h>
	12	#include <linux/module.h>
	13	#include <linux/nodemask.h>
	14
	15	#include <asm/e820.h>
	16	#include <asm/proto.h>
	17	#include <asm/dma.h>
	18	#include <asm/numa.h>
	19	#include <asm/acpi.h>
	20
	21	#ifndef Dprintk
	22	#define Dprintk(x...)
	23	#endif
	24
6c231b7b	25	struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;
1da177e4 LT	26	bootmem_data_t plat_node_bdata[MAX_NUMNODES];
	27
	28	int memnode_shift;
	29	u8 memnodemap[NODEMAPSIZE];
	30
3f098c26 AK	31	unsigned char cpu_to_node[NR_CPUS] __read_mostly = {
3f098c26 AK	32	[0 ... NR_CPUS-1] = NUMA_NO_NODE
0b07e984	33	};
3f098c26 AK	34	unsigned char apicid_to_node[MAX_LOCAL_APIC] __cpuinitdata = {
	35	[0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
	36	};
	37	cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly;
1da177e4 LT	38
	39	int numa_off __initdata;
	40
	41	int __init compute_hash_shift(struct node *nodes, int numnodes)
	42	{
	43	int i;
b684664f KM	44	int shift = 20;
b684664f KM	45	unsigned long addr,maxend=0;
1da177e4	46
b684664f KM	47	for (i = 0; i < numnodes; i++)
	48	if ((nodes[i].start != nodes[i].end) && (nodes[i].end > maxend))
	49	maxend = nodes[i].end;
	50
	51	while ((1UL << shift) < (maxend / NODEMAPSIZE))
	52	shift++;
	53
	54	printk (KERN_DEBUG"Using %d for the hash shift. Max adder is %lx \n",
	55	shift,maxend);
	56	memset(memnodemap,0xff,sizeof(memnodemap) NODEMAPSIZE);
	57	for (i = 0; i < numnodes; i++) {
	58	if (nodes[i].start == nodes[i].end)
	59	continue;
	60	for (addr = nodes[i].start;
	61	addr < nodes[i].end;
	62	addr += (1UL << shift)) {
	63	if (memnodemap[addr >> shift] != 0xff) {
	64	printk(KERN_INFO
	65	"Your memory is not aligned you need to rebuild your kernel "
	66	"with a bigger NODEMAPSIZE shift=%d adder=%lu\n",
	67	shift,addr);
	68	return -1;
1da177e4	69	}
b684664f	70	memnodemap[addr >> shift] = i;
1da177e4	71	}
1da177e4	72	}
b684664f	73	return shift;
1da177e4 LT	74	}
1da177e4 LT	75
bbfceef4 MT	76	#ifdef CONFIG_SPARSEMEM
	77	int early_pfn_to_nid(unsigned long pfn)
	78	{
	79	return phys_to_nid(pfn << PAGE_SHIFT);
	80	}
	81	#endif
	82
1da177e4 LT	83	/* Initialize bootmem allocator for a node */
	84	void __init setup_node_bootmem(int nodeid, unsigned long start, unsigned long end)
	85	{
	86	unsigned long start_pfn, end_pfn, bootmap_pages, bootmap_size, bootmap_start;
	87	unsigned long nodedata_phys;
	88	const int pgdat_size = round_up(sizeof(pg_data_t), PAGE_SIZE);
	89
	90	start = round_up(start, ZONE_ALIGN);
	91
	92	printk("Bootmem setup node %d %016lx-%016lx\n", nodeid, start, end);
	93
	94	start_pfn = start >> PAGE_SHIFT;
	95	end_pfn = end >> PAGE_SHIFT;
	96
bbfceef4	97	memory_present(nodeid, start_pfn, end_pfn);
1da177e4 LT	98	nodedata_phys = find_e820_area(start, end, pgdat_size);
	99	if (nodedata_phys == -1L)
	100	panic("Cannot find memory pgdat in node %d\n", nodeid);
	101
	102	Dprintk("nodedata_phys %lx\n", nodedata_phys);
	103
	104	node_data[nodeid] = phys_to_virt(nodedata_phys);
	105	memset(NODE_DATA(nodeid), 0, sizeof(pg_data_t));
	106	NODE_DATA(nodeid)->bdata = &plat_node_bdata[nodeid];
	107	NODE_DATA(nodeid)->node_start_pfn = start_pfn;
	108	NODE_DATA(nodeid)->node_spanned_pages = end_pfn - start_pfn;
	109
	110	/* Find a place for the bootmem map */
	111	bootmap_pages = bootmem_bootmap_pages(end_pfn - start_pfn);
	112	bootmap_start = round_up(nodedata_phys + pgdat_size, PAGE_SIZE);
	113	bootmap_start = find_e820_area(bootmap_start, end, bootmap_pages<<PAGE_SHIFT);
	114	if (bootmap_start == -1L)
	115	panic("Not enough continuous space for bootmap on node %d", nodeid);
	116	Dprintk("bootmap start %lu pages %lu\n", bootmap_start, bootmap_pages);
	117
	118	bootmap_size = init_bootmem_node(NODE_DATA(nodeid),
	119	bootmap_start >> PAGE_SHIFT,
	120	start_pfn, end_pfn);
	121
	122	e820_bootmem_free(NODE_DATA(nodeid), start, end);
	123
	124	reserve_bootmem_node(NODE_DATA(nodeid), nodedata_phys, pgdat_size);
	125	reserve_bootmem_node(NODE_DATA(nodeid), bootmap_start, bootmap_pages<<PAGE_SHIFT);
	126	node_set_online(nodeid);
	127	}
	128
	129	/* Initialize final allocator for a zone */
	130	void __init setup_node_zones(int nodeid)
	131	{
	132	unsigned long start_pfn, end_pfn;
	133	unsigned long zones[MAX_NR_ZONES];
485761bd	134	unsigned long holes[MAX_NR_ZONES];
1da177e4 LT	135	unsigned long dma_end_pfn;
	136
	137	memset(zones, 0, sizeof(unsigned long) * MAX_NR_ZONES);
485761bd	138	memset(holes, 0, sizeof(unsigned long) * MAX_NR_ZONES);
1da177e4 LT	139
	140	start_pfn = node_start_pfn(nodeid);
	141	end_pfn = node_end_pfn(nodeid);
	142
	143	Dprintk(KERN_INFO "setting up node %d %lx-%lx\n", nodeid, start_pfn, end_pfn);
	144
	145	/* All nodes > 0 have a zero length zone DMA */
	146	dma_end_pfn = __pa(MAX_DMA_ADDRESS) >> PAGE_SHIFT;
	147	if (start_pfn < dma_end_pfn) {
	148	zones[ZONE_DMA] = dma_end_pfn - start_pfn;
485761bd	149	holes[ZONE_DMA] = e820_hole_size(start_pfn, dma_end_pfn);
1da177e4	150	zones[ZONE_NORMAL] = end_pfn - dma_end_pfn;
485761bd AK	151	holes[ZONE_NORMAL] = e820_hole_size(dma_end_pfn, end_pfn);
485761bd AK	152
1da177e4 LT	153	} else {
1da177e4 LT	154	zones[ZONE_NORMAL] = end_pfn - start_pfn;
485761bd	155	holes[ZONE_NORMAL] = e820_hole_size(start_pfn, end_pfn);
1da177e4 LT	156	}
	157
	158	free_area_init_node(nodeid, NODE_DATA(nodeid), zones,
485761bd	159	start_pfn, holes);
1da177e4 LT	160	}
	161
	162	void __init numa_init_array(void)
	163	{
	164	int rr, i;
	165	/* There are unfortunately some poorly designed mainboards around
	166	that only connect memory to a single CPU. This breaks the 1:1 cpu->node
	167	mapping. To avoid this fill in the mapping for all possible
	168	CPUs, as the number of CPUs is not known yet.
	169	We round robin the existing nodes. */
	170	rr = 0;
	171	for (i = 0; i < NR_CPUS; i++) {
	172	if (cpu_to_node[i] != NUMA_NO_NODE)
	173	continue;
	174	rr = next_node(rr, node_online_map);
	175	if (rr == MAX_NUMNODES)
	176	rr = first_node(node_online_map);
	177	cpu_to_node[i] = rr;
	178	rr++;
	179	}
	180
1da177e4 LT	181	}
	182
	183	#ifdef CONFIG_NUMA_EMU
	184	int numa_fake __initdata = 0;
	185
	186	/* Numa emulation */
	187	static int numa_emulation(unsigned long start_pfn, unsigned long end_pfn)
	188	{
	189	int i;
	190	struct node nodes[MAX_NUMNODES];
	191	unsigned long sz = ((end_pfn - start_pfn)<<PAGE_SHIFT) / numa_fake;
	192
	193	/* Kludge needed for the hash function */
	194	if (hweight64(sz) > 1) {
	195	unsigned long x = 1;
	196	while ((x << 1) < sz)
	197	x <<= 1;
	198	if (x < sz/2)
	199	printk("Numa emulation unbalanced. Complain to maintainer\n");
	200	sz = x;
	201	}
	202
	203	memset(&nodes,0,sizeof(nodes));
	204	for (i = 0; i < numa_fake; i++) {
	205	nodes[i].start = (start_pfn<<PAGE_SHIFT) + i*sz;
	206	if (i == numa_fake-1)
	207	sz = (end_pfn<<PAGE_SHIFT) - nodes[i].start;
	208	nodes[i].end = nodes[i].start + sz;
	209	if (i != numa_fake-1)
	210	nodes[i].end--;
	211	printk(KERN_INFO "Faking node %d at %016Lx-%016Lx (%LuMB)\n",
	212	i,
	213	nodes[i].start, nodes[i].end,
	214	(nodes[i].end - nodes[i].start) >> 20);
	215	node_set_online(i);
	216	}
	217	memnode_shift = compute_hash_shift(nodes, numa_fake);
	218	if (memnode_shift < 0) {
	219	memnode_shift = 0;
	220	printk(KERN_ERR "No NUMA hash function found. Emulation disabled.\n");
	221	return -1;
	222	}
	223	for_each_online_node(i)
	224	setup_node_bootmem(i, nodes[i].start, nodes[i].end);
	225	numa_init_array();
	226	return 0;
	227	}
	228	#endif
	229
	230	void __init numa_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
	231	{
	232	int i;
	233
	234	#ifdef CONFIG_NUMA_EMU
	235	if (numa_fake && !numa_emulation(start_pfn, end_pfn))
	236	return;
	237	#endif
	238
	239	#ifdef CONFIG_ACPI_NUMA
	240	if (!numa_off && !acpi_scan_nodes(start_pfn << PAGE_SHIFT,
	241	end_pfn << PAGE_SHIFT))
	242	return;
	243	#endif
	244
245	#ifdef CONFIG_K8_NUMA
246	if (!numa_off && !k8_scan_nodes(start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT))
247	return;
248	#endif
249	printk(KERN_INFO "%s\n",
250	numa_off ? "NUMA turned off" : "No NUMA configuration found");
251
252	printk(KERN_INFO "Faking a node at %016lx-%016lx\n",
253	start_pfn << PAGE_SHIFT,
254	end_pfn << PAGE_SHIFT);
255	/* setup dummy node covering all memory */
256	memnode_shift = 63;
257	memnodemap[0] = 0;
258	nodes_clear(node_online_map);
259	node_set_online(0);
260	for (i = 0; i < NR_CPUS; i++)
261	cpu_to_node[i] = 0;
262	node_to_cpumask[0] = cpumask_of_cpu(0);
263	setup_node_bootmem(0, start_pfn << PAGE_SHIFT, end_pfn << PAGE_SHIFT);
264	}
265
e6982c67	266	__cpuinit void numa_add_cpu(int cpu)
1da177e4	267	{
e6a045a5	268	set_bit(cpu, &node_to_cpumask[cpu_to_node(cpu)]);
1da177e4 LT	269	}
	270
	271	unsigned long __init numa_free_all_bootmem(void)
	272	{
	273	int i;
	274	unsigned long pages = 0;
	275	for_each_online_node(i) {
	276	pages += free_all_bootmem_node(NODE_DATA(i));
	277	}
	278	return pages;
	279	}
	280
	281	void __init paging_init(void)
	282	{
	283	int i;
	284	for_each_online_node(i) {
	285	setup_node_zones(i);
	286	}
	287	}
	288
	289	/* [numa=off] */
	290	__init int numa_setup(char *opt)
	291	{
	292	if (!strncmp(opt,"off",3))
	293	numa_off = 1;
	294	#ifdef CONFIG_NUMA_EMU
	295	if(!strncmp(opt, "fake=", 5)) {
	296	numa_fake = simple_strtoul(opt+5,NULL,0); ;
	297	if (numa_fake >= MAX_NUMNODES)
	298	numa_fake = MAX_NUMNODES;
	299	}
	300	#endif
	301	#ifdef CONFIG_ACPI_NUMA
	302	if (!strncmp(opt,"noacpi",6))
	303	acpi_numa = -1;
	304	#endif
	305	return 1;
	306	}
	307
	308	EXPORT_SYMBOL(cpu_to_node);
	309	EXPORT_SYMBOL(node_to_cpumask);
	310	EXPORT_SYMBOL(memnode_shift);
	311	EXPORT_SYMBOL(memnodemap);
	312	EXPORT_SYMBOL(node_data);