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 __init
 170 reserve_hotadd(int node, unsigned long start, unsigned long end)
 171 {
 172         unsigned long s_pfn = start >> PAGE_SHIFT;
 173         unsigned long e_pfn = end >> PAGE_SHIFT;
 174         int ret = 0, changed = 0;
 175         struct bootnode *nd = &nodes_add[node];
 176
 177         /* I had some trouble with strange memory hotadd regions breaking
 178            the boot. Be very strict here and reject anything unexpected.
 179            If you want working memory hotadd write correct SRATs.
 180
 181            The node size check is a basic sanity check to guard against
 182            mistakes */
 183         if ((signed long)(end - start) < NODE_MIN_SIZE) {
 184                 printk(KERN_ERR "SRAT: Hotplug area too small\n");
 185                 return -1;
 186         }
 187
 188         /* This check might be a bit too strict, but I'm keeping it for now. */
 189         if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
 190                 printk(KERN_ERR
 191                         "SRAT: Hotplug area %lu -> %lu has existing memory\n",
 192                         s_pfn, e_pfn);
 193                 return -1;
 194         }
 195
 196         if (!hotadd_enough_memory(&nodes_add[node]))  {
 197                 printk(KERN_ERR "SRAT: Hotplug area too large\n");
 198                 return -1;
 199         }
 200
 201         /* Looks good */
 202
 203         if (nd->start == nd->end) {
 204                 nd->start = start;
 205                 nd->end = end;
 206                 changed = 1;
 207         } else {
 208                 if (nd->start == end) {
 209                         nd->start = start;
 210                         changed = 1;
 211                 }
 212                 if (nd->end == start) {
 213                         nd->end = end;
 214                         changed = 1;
 215                 }
 216                 if (!changed)
 217                         printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
 218         }
 219
 220         ret = update_end_of_memory(nd->end);
 221
 222         if (changed)
 223                 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
 224         return ret;
 225 }
 226
 227 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
 228 void __init
 229 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 230 {
 231         struct bootnode *nd, oldnode;
 232         unsigned long start, end;
 233         int node, pxm;
 234         int i;
 235
 236         if (srat_disabled())
 237                 return;
 238         if (ma->header.length != sizeof(struct acpi_srat_mem_affinity)) {
 239                 bad_srat();
 240                 return;
 241         }
 242         if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
 243                 return;
 244
 245         if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
 246                 return;
 247         start = ma->base_address;
 248         end = start + ma->length;
 249         pxm = ma->proximity_domain;
 250         node = setup_node(pxm);
 251         if (node < 0) {
 252                 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
 253                 bad_srat();
 254                 return;
 255         }
 256         i = conflicting_nodes(start, end);
 257         if (i == node) {
 258                 printk(KERN_WARNING
 259                 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
 260                         pxm, start, end, nodes[i].start, nodes[i].end);
 261         } else if (i >= 0) {
 262                 printk(KERN_ERR
 263                        "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
 264                        pxm, start, end, node_to_pxm(i),
 265                         nodes[i].start, nodes[i].end);
 266                 bad_srat();
 267                 return;
 268         }
 269         nd = &nodes[node];
 270         oldnode = *nd;
 271         if (!node_test_and_set(node, nodes_parsed)) {
 272                 nd->start = start;
 273                 nd->end = end;
 274         } else {
 275                 if (start < nd->start)
 276                         nd->start = start;
 277                 if (nd->end < end)
 278                         nd->end = end;
 279         }
 280
 281         printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
 282                nd->start, nd->end);
 283         e820_register_active_regions(node, nd->start >> PAGE_SHIFT,
 284                                                 nd->end >> PAGE_SHIFT);
 285         push_node_boundaries(node, nd->start >> PAGE_SHIFT,
 286                                                 nd->end >> PAGE_SHIFT);
 287
 288         if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) &&
 289             (reserve_hotadd(node, start, end) < 0)) {
 290                 /* Ignore hotadd region. Undo damage */
 291                 printk(KERN_NOTICE "SRAT: Hotplug region ignored\n");
 292                 *nd = oldnode;
 293                 if ((nd->start | nd->end) == 0)
 294                         node_clear(node, nodes_parsed);
 295         }
 296 }
 297
 298 /* Sanity check to catch more bad SRATs (they are amazingly common).
 299    Make sure the PXMs cover all memory. */
 300 static int __init nodes_cover_memory(const struct bootnode *nodes)
 301 {
 302         int i;
 303         unsigned long pxmram, e820ram;
 304
 305         pxmram = 0;
 306         for_each_node_mask(i, nodes_parsed) {
 307                 unsigned long s = nodes[i].start >> PAGE_SHIFT;
 308                 unsigned long e = nodes[i].end >> PAGE_SHIFT;
 309                 pxmram += e - s;
 310                 pxmram -= absent_pages_in_range(s, e);
 311                 if ((long)pxmram < 0)
 312                         pxmram = 0;
 313         }
 314
 315         e820ram = end_pfn - absent_pages_in_range(0, end_pfn);
 316         /* We seem to lose 3 pages somewhere. Allow a bit of slack. */
 317         if ((long)(e820ram - pxmram) >= 1*1024*1024) {
 318                 printk(KERN_ERR
 319         "SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
 320                         (pxmram << PAGE_SHIFT) >> 20,
 321                         (e820ram << PAGE_SHIFT) >> 20);
 322                 return 0;
 323         }
 324         return 1;
 325 }
 326
 327 static void __init unparse_node(int node)
 328 {
 329         int i;
 330         node_clear(node, nodes_parsed);
 331         for (i = 0; i < MAX_LOCAL_APIC; i++) {
 332                 if (apicid_to_node[i] == node)
 333                         apicid_to_node[i] = NUMA_NO_NODE;
 334         }
 335 }
 336
 337 void __init acpi_numa_arch_fixup(void) {}
 338
 339 /* Use the information discovered above to actually set up the nodes. */
 340 int __init acpi_scan_nodes(unsigned long start, unsigned long end)
 341 {
 342         int i;
 343
 344         if (acpi_numa <= 0)
 345                 return -1;
 346
 347         /* First clean up the node list */
 348         for (i = 0; i < MAX_NUMNODES; i++) {
 349                 cutoff_node(i, start, end);
 350                 /*
 351                  * don't confuse VM with a node that doesn't have the
 352                  * minimum memory.
 353                  */
 354                 if (nodes[i].end &&
 355                         (nodes[i].end - nodes[i].start) < NODE_MIN_SIZE) {
 356                         unparse_node(i);
 357                         node_set_offline(i);
 358                 }
 359         }
 360
 361         if (!nodes_cover_memory(nodes)) {
 362                 bad_srat();
 363                 return -1;
 364         }
 365
 366         memnode_shift = compute_hash_shift(nodes, MAX_NUMNODES);
 367         if (memnode_shift < 0) {
 368                 printk(KERN_ERR
 369                      "SRAT: No NUMA node hash function found. Contact maintainer\n");
 370                 bad_srat();
 371                 return -1;
 372         }
 373
 374         node_possible_map = nodes_parsed;
 375
 376         /* Finally register nodes */
 377         for_each_node_mask(i, node_possible_map)
 378                 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 379         /* Try again in case setup_node_bootmem missed one due
 380            to missing bootmem */
 381         for_each_node_mask(i, node_possible_map)
 382                 if (!node_online(i))
 383                         setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 384
 385         for (i = 0; i < NR_CPUS; i++) {
 386                 int node = early_cpu_to_node(i);
 387
 388                 if (node == NUMA_NO_NODE)
 389                         continue;
 390                 if (!node_isset(node, node_possible_map))
 391                         numa_set_node(i, NUMA_NO_NODE);
 392         }
 393         numa_init_array();
 394         return 0;
 395 }
 396
 397 #ifdef CONFIG_NUMA_EMU
 398 static int fake_node_to_pxm_map[MAX_NUMNODES] __initdata = {
 399         [0 ... MAX_NUMNODES-1] = PXM_INVAL
 400 };
 401 static s16 fake_apicid_to_node[MAX_LOCAL_APIC] __initdata = {
 402         [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
 403 };
 404 static int __init find_node_by_addr(unsigned long addr)
 405 {
 406         int ret = NUMA_NO_NODE;
 407         int i;
 408
 409         for_each_node_mask(i, nodes_parsed) {
 410                 /*
 411                  * Find the real node that this emulated node appears on.  For
 412                  * the sake of simplicity, we only use a real node's starting
 413                  * address to determine which emulated node it appears on.
 414                  */
 415                 if (addr >= nodes[i].start && addr < nodes[i].end) {
 416                         ret = i;
 417                         break;
 418                 }
 419         }
 420         return ret;
 421 }
 422
 423 /*
 424  * In NUMA emulation, we need to setup proximity domain (_PXM) to node ID
 425  * mappings that respect the real ACPI topology but reflect our emulated
 426  * environment.  For each emulated node, we find which real node it appears on
 427  * and create PXM to NID mappings for those fake nodes which mirror that
 428  * locality.  SLIT will now represent the correct distances between emulated
 429  * nodes as a result of the real topology.
 430  */
 431 void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
 432 {
 433         int i, j;
 434
 435         printk(KERN_INFO "Faking PXM affinity for fake nodes on real "
 436                          "topology.\n");
 437         for (i = 0; i < num_nodes; i++) {
 438                 int nid, pxm;
 439
 440                 nid = find_node_by_addr(fake_nodes[i].start);
 441                 if (nid == NUMA_NO_NODE)
 442                         continue;
 443                 pxm = node_to_pxm(nid);
 444                 if (pxm == PXM_INVAL)
 445                         continue;
 446                 fake_node_to_pxm_map[i] = pxm;
 447                 /*
 448                  * For each apicid_to_node mapping that exists for this real
 449                  * node, it must now point to the fake node ID.
 450                  */
 451                 for (j = 0; j < MAX_LOCAL_APIC; j++)
 452                         if (apicid_to_node[j] == nid)
 453                                 fake_apicid_to_node[j] = i;
 454         }
 455         for (i = 0; i < num_nodes; i++)
 456                 __acpi_map_pxm_to_node(fake_node_to_pxm_map[i], i);
 457         memcpy(apicid_to_node, fake_apicid_to_node, sizeof(apicid_to_node));
 458
 459         nodes_clear(nodes_parsed);
 460         for (i = 0; i < num_nodes; i++)
 461                 if (fake_nodes[i].start != fake_nodes[i].end)
 462                         node_set(i, nodes_parsed);
 463         WARN_ON(!nodes_cover_memory(fake_nodes));
 464 }
 465
 466 static int null_slit_node_compare(int a, int b)
 467 {
 468         return node_to_pxm(a) == node_to_pxm(b);
 469 }
 470 #else
 471 static int null_slit_node_compare(int a, int b)
 472 {
 473         return a == b;
 474 }
 475 #endif /* CONFIG_NUMA_EMU */
 476
 477 void __init srat_reserve_add_area(int nodeid)
 478 {
 479         if (found_add_area && nodes_add[nodeid].end) {
 480                 u64 total_mb;
 481
 482                 printk(KERN_INFO "SRAT: Reserving hot-add memory space "
 483                                 "for node %d at %Lx-%Lx\n",
 484                         nodeid, nodes_add[nodeid].start, nodes_add[nodeid].end);
 485                 total_mb = (nodes_add[nodeid].end - nodes_add[nodeid].start)
 486                                         >> PAGE_SHIFT;
 487                 total_mb *= sizeof(struct page);
 488                 total_mb >>= 20;
 489                 printk(KERN_INFO "SRAT: This will cost you %Lu MB of "
 490                                 "pre-allocated memory.\n", (unsigned long long)total_mb);
 491                 reserve_bootmem_node(NODE_DATA(nodeid), nodes_add[nodeid].start,
 492                                nodes_add[nodeid].end - nodes_add[nodeid].start,
 493                                BOOTMEM_DEFAULT);
 494         }
 495 }
 496
 497 int __node_distance(int a, int b)
 498 {
 499         int index;
 500
 501         if (!acpi_slit)
 502                 return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
 503                                                       REMOTE_DISTANCE;
 504         index = acpi_slit->locality_count * node_to_pxm(a);
 505         return acpi_slit->entry[index + node_to_pxm(b)];
 506 }
 507
 508 EXPORT_SYMBOL(__node_distance);
 509
 510 int memory_add_physaddr_to_nid(u64 start)
 511 {
 512         int i, ret = 0;
 513
 514         for_each_node(i)
 515                 if (nodes_add[i].start <= start && nodes_add[i].end > start)
 516                         ret = i;
 517
 518         return ret;
 519 }
 520 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
 521