1 /* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * This file contains NUMA specific variables and functions which can 7 * be split away from DISCONTIGMEM and are used on NUMA machines with 8 * contiguous memory. 9 * 10 * 2002/08/07 Erich Focht <efocht@ess.nec.de> 11 */ 12 13 #include <linux/cpu.h> 14 #include <linux/kernel.h> 15 #include <linux/mm.h> 16 #include <linux/node.h> 17 #include <linux/init.h> 18 #include <linux/bootmem.h> 19 #include <linux/module.h> 20 #include <asm/mmzone.h> 21 #include <asm/numa.h> 22 23 24 /* 25 * The following structures are usually initialized by ACPI or 26 * similar mechanisms and describe the NUMA characteristics of the machine. 27 */ 28 int num_node_memblks; 29 struct node_memblk_s node_memblk[NR_NODE_MEMBLKS]; 30 struct node_cpuid_s node_cpuid[NR_CPUS] = 31 { [0 ... NR_CPUS-1] = { .phys_id = 0, .nid = NUMA_NO_NODE } }; 32 33 /* 34 * This is a matrix with "distances" between nodes, they should be 35 * proportional to the memory access latency ratios. 36 */ 37 u8 numa_slit[MAX_NUMNODES * MAX_NUMNODES]; 38 39 /* Identify which cnode a physical address resides on */ 40 int 41 paddr_to_nid(unsigned long paddr) 42 { 43 int i; 44 45 for (i = 0; i < num_node_memblks; i++) 46 if (paddr >= node_memblk[i].start_paddr && 47 paddr < node_memblk[i].start_paddr + node_memblk[i].size) 48 break; 49 50 return (i < num_node_memblks) ? node_memblk[i].nid : (num_node_memblks ? -1 : 0); 51 } 52 53 #if defined(CONFIG_SPARSEMEM) && defined(CONFIG_NUMA) 54 /* 55 * Because of holes evaluate on section limits. 56 * If the section of memory exists, then return the node where the section 57 * resides. Otherwise return node 0 as the default. This is used by 58 * SPARSEMEM to allocate the SPARSEMEM sectionmap on the NUMA node where 59 * the section resides. 60 */ 61 int __meminit __early_pfn_to_nid(unsigned long pfn) 62 { 63 int i, section = pfn >> PFN_SECTION_SHIFT, ssec, esec; 64 /* 65 * NOTE: The following SMP-unsafe globals are only used early in boot 66 * when the kernel is running single-threaded. 67 */ 68 static int __meminitdata last_ssec, last_esec; 69 static int __meminitdata last_nid; 70 71 if (section >= last_ssec && section < last_esec) 72 return last_nid; 73 74 for (i = 0; i < num_node_memblks; i++) { 75 ssec = node_memblk[i].start_paddr >> PA_SECTION_SHIFT; 76 esec = (node_memblk[i].start_paddr + node_memblk[i].size + 77 ((1L << PA_SECTION_SHIFT) - 1)) >> PA_SECTION_SHIFT; 78 if (section >= ssec && section < esec) { 79 last_ssec = ssec; 80 last_esec = esec; 81 last_nid = node_memblk[i].nid; 82 return node_memblk[i].nid; 83 } 84 } 85 86 return -1; 87 } 88 89 void numa_clear_node(int cpu) 90 { 91 unmap_cpu_from_node(cpu, NUMA_NO_NODE); 92 } 93 94 #ifdef CONFIG_MEMORY_HOTPLUG 95 /* 96 * SRAT information is stored in node_memblk[], then we can use SRAT 97 * information at memory-hot-add if necessary. 98 */ 99 100 int memory_add_physaddr_to_nid(u64 addr) 101 { 102 int nid = paddr_to_nid(addr); 103 if (nid < 0) 104 return 0; 105 return nid; 106 } 107 108 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid); 109 #endif 110 #endif 111