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