arch/x86/mm/srat_64.c

   1 /*
   2  * ACPI 3.0 based NUMA setup
   3  * Copyright 2004 Andi Kleen, SuSE Labs.
   4  *
   5  * Reads the ACPI SRAT table to figure out what memory belongs to which CPUs.
   6  *
   7  * Called from acpi_numa_init while reading the SRAT and SLIT tables.
   8  * Assumes all memory regions belonging to a single proximity domain
   9  * are in one chunk. Holes between them will be included in the node.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/acpi.h>
  14 #include <linux/mmzone.h>
  15 #include <linux/bitmap.h>
  16 #include <linux/module.h>
  17 #include <linux/topology.h>
  18 #include <linux/bootmem.h>
  19 #include <linux/mm.h>
  20 #include <asm/proto.h>
  21 #include <asm/numa.h>
  22 #include <asm/e820.h>
  23 #include <asm/apic.h>
  24 #include <asm/uv/uv.h>
  25
  26 int acpi_numa __initdata;
  27
  28 static struct acpi_table_slit *acpi_slit;
  29
  30 static nodemask_t nodes_parsed __initdata;
  31 static nodemask_t cpu_nodes_parsed __initdata;
  32 static struct bootnode nodes[MAX_NUMNODES] __initdata;
  33 static struct bootnode nodes_add[MAX_NUMNODES];
  34
  35 static int num_node_memblks __initdata;
  36 static struct bootnode node_memblk_range[NR_NODE_MEMBLKS] __initdata;
  37 static int memblk_nodeid[NR_NODE_MEMBLKS] __initdata;
  38
  39 static __init int setup_node(int pxm)
  40 {
  41         return acpi_map_pxm_to_node(pxm);
  42 }
  43
  44 static __init int conflicting_memblks(unsigned long start, unsigned long end)
  45 {
  46         int i;
  47         for (i = 0; i < num_node_memblks; i++) {
  48                 struct bootnode *nd = &node_memblk_range[i];
  49                 if (nd->start == nd->end)
  50                         continue;
  51                 if (nd->end > start && nd->start < end)
  52                         return memblk_nodeid[i];
  53                 if (nd->end == end && nd->start == start)
  54                         return memblk_nodeid[i];
  55         }
  56         return -1;
  57 }
  58
  59 static __init void cutoff_node(int i, unsigned long start, unsigned long end)
  60 {
  61         struct bootnode *nd = &nodes[i];
  62
  63         if (nd->start < start) {
  64                 nd->start = start;
  65                 if (nd->end < nd->start)
  66                         nd->start = nd->end;
  67         }
  68         if (nd->end > end) {
  69                 nd->end = end;
  70                 if (nd->start > nd->end)
  71                         nd->start = nd->end;
  72         }
  73 }
  74
  75 static __init void bad_srat(void)
  76 {
  77         int i;
  78         printk(KERN_ERR "SRAT: SRAT not used.\n");
  79         acpi_numa = -1;
  80         for (i = 0; i < MAX_LOCAL_APIC; i++)
  81                 apicid_to_node[i] = NUMA_NO_NODE;
  82         for (i = 0; i < MAX_NUMNODES; i++) {
  83                 nodes[i].start = nodes[i].end = 0;
  84                 nodes_add[i].start = nodes_add[i].end = 0;
  85         }
  86         remove_all_active_ranges();
  87 }
  88
  89 static __init inline int srat_disabled(void)
  90 {
  91         return numa_off || acpi_numa < 0;
  92 }
  93
  94 /* Callback for SLIT parsing */
  95 void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
  96 {
  97         unsigned length;
  98         unsigned long phys;
  99
 100         length = slit->header.length;
 101         phys = find_e820_area(0, max_pfn_mapped<<PAGE_SHIFT, length,
 102                  PAGE_SIZE);
 103
 104         if (phys == -1L)
 105                 panic(" Can not save slit!\n");
 106
 107         acpi_slit = __va(phys);
 108         memcpy(acpi_slit, slit, length);
 109         reserve_early(phys, phys + length, "ACPI SLIT");
 110 }
 111
 112 /* Callback for Proximity Domain -> x2APIC mapping */
 113 void __init
 114 acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa)
 115 {
 116         int pxm, node;
 117         int apic_id;
 118
 119         if (srat_disabled())
 120                 return;
 121         if (pa->header.length < sizeof(struct acpi_srat_x2apic_cpu_affinity)) {
 122                 bad_srat();
 123                 return;
 124         }
 125         if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
 126                 return;
 127         pxm = pa->proximity_domain;
 128         node = setup_node(pxm);
 129         if (node < 0) {
 130                 printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
 131                 bad_srat();
 132                 return;
 133         }
 134
 135         apic_id = pa->apic_id;
 136         apicid_to_node[apic_id] = node;
 137         node_set(node, cpu_nodes_parsed);
 138         acpi_numa = 1;
 139         printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%04x -> Node %u\n",
 140                pxm, apic_id, node);
 141 }
 142
 143 /* Callback for Proximity Domain -> LAPIC mapping */
 144 void __init
 145 acpi_numa_processor_affinity_init(struct acpi_srat_cpu_affinity *pa)
 146 {
 147         int pxm, node;
 148         int apic_id;
 149
 150         if (srat_disabled())
 151                 return;
 152         if (pa->header.length != sizeof(struct acpi_srat_cpu_affinity)) {
 153                 bad_srat();
 154                 return;
 155         }
 156         if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
 157                 return;
 158         pxm = pa->proximity_domain_lo;
 159         node = setup_node(pxm);
 160         if (node < 0) {
 161                 printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
 162                 bad_srat();
 163                 return;
 164         }
 165
 166         if (get_uv_system_type() >= UV_X2APIC)
 167                 apic_id = (pa->apic_id << 8) | pa->local_sapic_eid;
 168         else
 169                 apic_id = pa->apic_id;
 170         apicid_to_node[apic_id] = node;
 171         node_set(node, cpu_nodes_parsed);
 172         acpi_numa = 1;
 173         printk(KERN_INFO "SRAT: PXM %u -> APIC 0x%02x -> Node %u\n",
 174                pxm, apic_id, node);
 175 }
 176
 177 #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
 178 static inline int save_add_info(void) {return 1;}
 179 #else
 180 static inline int save_add_info(void) {return 0;}
 181 #endif
 182 /*
 183  * Update nodes_add[]
 184  * This code supports one contiguous hot add area per node
 185  */
 186 static void __init
 187 update_nodes_add(int node, unsigned long start, unsigned long end)
 188 {
 189         unsigned long s_pfn = start >> PAGE_SHIFT;
 190         unsigned long e_pfn = end >> PAGE_SHIFT;
 191         int changed = 0;
 192         struct bootnode *nd = &nodes_add[node];
 193
 194         /* I had some trouble with strange memory hotadd regions breaking
 195            the boot. Be very strict here and reject anything unexpected.
 196            If you want working memory hotadd write correct SRATs.
 197
 198            The node size check is a basic sanity check to guard against
 199            mistakes */
 200         if ((signed long)(end - start) < NODE_MIN_SIZE) {
 201                 printk(KERN_ERR "SRAT: Hotplug area too small\n");
 202                 return;
 203         }
 204
 205         /* This check might be a bit too strict, but I'm keeping it for now. */
 206         if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
 207                 printk(KERN_ERR
 208                         "SRAT: Hotplug area %lu -> %lu has existing memory\n",
 209                         s_pfn, e_pfn);
 210                 return;
 211         }
 212
 213         /* Looks good */
 214
 215         if (nd->start == nd->end) {
 216                 nd->start = start;
 217                 nd->end = end;
 218                 changed = 1;
 219         } else {
 220                 if (nd->start == end) {
 221                         nd->start = start;
 222                         changed = 1;
 223                 }
 224                 if (nd->end == start) {
 225                         nd->end = end;
 226                         changed = 1;
 227                 }
 228                 if (!changed)
 229                         printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
 230         }
 231
 232         if (changed)
 233                 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n",
 234                                  nd->start, nd->end);
 235 }
 236
 237 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
 238 void __init
 239 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 240 {
 241         struct bootnode *nd, oldnode;
 242         unsigned long start, end;
 243         int node, pxm;
 244         int i;
 245
 246         if (srat_disabled())
 247                 return;
 248         if (ma->header.length != sizeof(struct acpi_srat_mem_affinity)) {
 249                 bad_srat();
 250                 return;
 251         }
 252         if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
 253                 return;
 254
 255         if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
 256                 return;
 257         start = ma->base_address;
 258         end = start + ma->length;
 259         pxm = ma->proximity_domain;
 260         node = setup_node(pxm);
 261         if (node < 0) {
 262                 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
 263                 bad_srat();
 264                 return;
 265         }
 266         i = conflicting_memblks(start, end);
 267         if (i == node) {
 268                 printk(KERN_WARNING
 269                 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
 270                         pxm, start, end, nodes[i].start, nodes[i].end);
 271         } else if (i >= 0) {
 272                 printk(KERN_ERR
 273                        "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
 274                        pxm, start, end, node_to_pxm(i),
 275                         nodes[i].start, nodes[i].end);
 276                 bad_srat();
 277                 return;
 278         }
 279         nd = &nodes[node];
 280         oldnode = *nd;
 281         if (!node_test_and_set(node, nodes_parsed)) {
 282                 nd->start = start;
 283                 nd->end = end;
 284         } else {
 285                 if (start < nd->start)
 286                         nd->start = start;
 287                 if (nd->end < end)
 288                         nd->end = end;
 289         }
 290
 291         printk(KERN_INFO "SRAT: Node %u PXM %u %lx-%lx\n", node, pxm,
 292                start, end);
 293
 294         if (ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) {
 295                 update_nodes_add(node, start, end);
 296                 /* restore nodes[node] */
 297                 *nd = oldnode;
 298                 if ((nd->start | nd->end) == 0)
 299                         node_clear(node, nodes_parsed);
 300         }
 301
 302         node_memblk_range[num_node_memblks].start = start;
 303         node_memblk_range[num_node_memblks].end = end;
 304         memblk_nodeid[num_node_memblks] = node;
 305         num_node_memblks++;
 306 }
 307
 308 /* Sanity check to catch more bad SRATs (they are amazingly common).
 309    Make sure the PXMs cover all memory. */
 310 static int __init nodes_cover_memory(const struct bootnode *nodes)
 311 {
 312         int i;
 313         unsigned long pxmram, e820ram;
 314
 315         pxmram = 0;
 316         for_each_node_mask(i, nodes_parsed) {
 317                 unsigned long s = nodes[i].start >> PAGE_SHIFT;
 318                 unsigned long e = nodes[i].end >> PAGE_SHIFT;
 319                 pxmram += e - s;
 320                 pxmram -= __absent_pages_in_range(i, s, e);
 321                 if ((long)pxmram < 0)
 322                         pxmram = 0;
 323         }
 324
 325         e820ram = max_pfn - (e820_hole_size(0, max_pfn<<PAGE_SHIFT)>>PAGE_SHIFT);
 326         /* We seem to lose 3 pages somewhere. Allow 1M of slack. */
 327         if ((long)(e820ram - pxmram) >= (1<<(20 - PAGE_SHIFT))) {
 328                 printk(KERN_ERR
 329         "SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
 330                         (pxmram << PAGE_SHIFT) >> 20,
 331                         (e820ram << PAGE_SHIFT) >> 20);
 332                 return 0;
 333         }
 334         return 1;
 335 }
 336
 337 void __init acpi_numa_arch_fixup(void) {}
 338
 339 int __init acpi_get_nodes(struct bootnode *physnodes)
 340 {
 341         int i;
 342         int ret = 0;
 343
 344         for_each_node_mask(i, nodes_parsed) {
 345                 physnodes[ret].start = nodes[i].start;
 346                 physnodes[ret].end = nodes[i].end;
 347                 ret++;
 348         }
 349         return ret;
 350 }
 351
 352 /* Use the information discovered above to actually set up the nodes. */
 353 int __init acpi_scan_nodes(unsigned long start, unsigned long end)
 354 {
 355         int i;
 356
 357         if (acpi_numa <= 0)
 358                 return -1;
 359
 360         /* First clean up the node list */
 361         for (i = 0; i < MAX_NUMNODES; i++)
 362                 cutoff_node(i, start, end);
 363
 364         memnode_shift = compute_hash_shift(node_memblk_range, num_node_memblks,
 365                                            memblk_nodeid);
 366         if (memnode_shift < 0) {
 367                 printk(KERN_ERR
 368                      "SRAT: No NUMA node hash function found. Contact maintainer\n");
 369                 bad_srat();
 370                 return -1;
 371         }
 372
 373         for_each_node_mask(i, nodes_parsed)
 374                 e820_register_active_regions(i, nodes[i].start >> PAGE_SHIFT,
 375                                                 nodes[i].end >> PAGE_SHIFT);
 376         /* for out of order entries in SRAT */
 377         sort_node_map();
 378         if (!nodes_cover_memory(nodes)) {
 379                 bad_srat();
 380                 return -1;
 381         }
 382
 383         /* Account for nodes with cpus and no memory */
 384         nodes_or(node_possible_map, nodes_parsed, cpu_nodes_parsed);
 385
 386         /* Finally register nodes */
 387         for_each_node_mask(i, node_possible_map)
 388                 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 389         /* Try again in case setup_node_bootmem missed one due
 390            to missing bootmem */
 391         for_each_node_mask(i, node_possible_map)
 392                 if (!node_online(i))
 393                         setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 394
 395         for (i = 0; i < nr_cpu_ids; i++) {
 396                 int node = early_cpu_to_node(i);
 397
 398                 if (node == NUMA_NO_NODE)
 399                         continue;
 400                 if (!node_online(node))
 401                         numa_clear_node(i);
 402         }
 403         numa_init_array();
 404         return 0;
 405 }
 406
 407 #ifdef CONFIG_NUMA_EMU
 408 static int fake_node_to_pxm_map[MAX_NUMNODES] __initdata = {
 409         [0 ... MAX_NUMNODES-1] = PXM_INVAL
 410 };
 411 static s16 fake_apicid_to_node[MAX_LOCAL_APIC] __initdata = {
 412         [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
 413 };
 414 static int __init find_node_by_addr(unsigned long addr)
 415 {
 416         int ret = NUMA_NO_NODE;
 417         int i;
 418
 419         for_each_node_mask(i, nodes_parsed) {
 420                 /*
 421                  * Find the real node that this emulated node appears on.  For
 422                  * the sake of simplicity, we only use a real node's starting
 423                  * address to determine which emulated node it appears on.
 424                  */
 425                 if (addr >= nodes[i].start && addr < nodes[i].end) {
 426                         ret = i;
 427                         break;
 428                 }
 429         }
 430         return ret;
 431 }
 432
 433 /*
 434  * In NUMA emulation, we need to setup proximity domain (_PXM) to node ID
 435  * mappings that respect the real ACPI topology but reflect our emulated
 436  * environment.  For each emulated node, we find which real node it appears on
 437  * and create PXM to NID mappings for those fake nodes which mirror that
 438  * locality.  SLIT will now represent the correct distances between emulated
 439  * nodes as a result of the real topology.
 440  */
 441 void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
 442 {
 443         int i, j;
 444
 445         printk(KERN_INFO "Faking PXM affinity for fake nodes on real "
 446                          "topology.\n");
 447         for (i = 0; i < num_nodes; i++) {
 448                 int nid, pxm;
 449
 450                 nid = find_node_by_addr(fake_nodes[i].start);
 451                 if (nid == NUMA_NO_NODE)
 452                         continue;
 453                 pxm = node_to_pxm(nid);
 454                 if (pxm == PXM_INVAL)
 455                         continue;
 456                 fake_node_to_pxm_map[i] = pxm;
 457                 /*
 458                  * For each apicid_to_node mapping that exists for this real
 459                  * node, it must now point to the fake node ID.
 460                  */
 461                 for (j = 0; j < MAX_LOCAL_APIC; j++)
 462                         if (apicid_to_node[j] == nid)
 463                                 fake_apicid_to_node[j] = i;
 464         }
 465         for (i = 0; i < num_nodes; i++)
 466                 __acpi_map_pxm_to_node(fake_node_to_pxm_map[i], i);
 467         memcpy(apicid_to_node, fake_apicid_to_node, sizeof(apicid_to_node));
 468
 469         nodes_clear(nodes_parsed);
 470         for (i = 0; i < num_nodes; i++)
 471                 if (fake_nodes[i].start != fake_nodes[i].end)
 472                         node_set(i, nodes_parsed);
 473 }
 474
 475 static int null_slit_node_compare(int a, int b)
 476 {
 477         return node_to_pxm(a) == node_to_pxm(b);
 478 }
 479 #else
 480 static int null_slit_node_compare(int a, int b)
 481 {
 482         return a == b;
 483 }
 484 #endif /* CONFIG_NUMA_EMU */
 485
 486 int __node_distance(int a, int b)
 487 {
 488         int index;
 489
 490         if (!acpi_slit)
 491                 return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
 492                                                       REMOTE_DISTANCE;
 493         index = acpi_slit->locality_count * node_to_pxm(a);
 494         return acpi_slit->entry[index + node_to_pxm(b)];
 495 }
 496
 497 EXPORT_SYMBOL(__node_distance);
 498
 499 #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) || defined(CONFIG_ACPI_HOTPLUG_MEMORY)
 500 int memory_add_physaddr_to_nid(u64 start)
 501 {
 502         int i, ret = 0;
 503
 504         for_each_node(i)
 505                 if (nodes_add[i].start <= start && nodes_add[i].end > start)
 506                         ret = i;
 507
 508         return ret;
 509 }
 510 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
 511 #endif