arch/x86_64/mm/srat.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 #if (defined(CONFIG_ACPI_HOTPLUG_MEMORY) || \
  25         defined(CONFIG_ACPI_HOTPLUG_MEMORY_MODULE)) \
  26                 && !defined(CONFIG_MEMORY_HOTPLUG)
  27 #define RESERVE_HOTADD 1
  28 #endif
  29
  30 static struct acpi_table_slit *acpi_slit;
  31
  32 static nodemask_t nodes_parsed __initdata;
  33 static nodemask_t nodes_found __initdata;
  34 static struct bootnode nodes[MAX_NUMNODES] __initdata;
  35 static struct bootnode nodes_add[MAX_NUMNODES] __initdata;
  36 static int found_add_area __initdata;
  37 int hotadd_percent __initdata = 10;
  38 static u8 pxm2node[256] = { [0 ... 255] = 0xff };
  39
  40 /* Too small nodes confuse the VM badly. Usually they result
  41    from BIOS bugs. */
  42 #define NODE_MIN_SIZE (4*1024*1024)
  43
  44 static int node_to_pxm(int n);
  45
  46 int pxm_to_node(int pxm)
  47 {
  48         if ((unsigned)pxm >= 256)
  49                 return -1;
  50         /* Extend 0xff to (int)-1 */
  51         return (signed char)pxm2node[pxm];
  52 }
  53
  54 static __init int setup_node(int pxm)
  55 {
  56         unsigned node = pxm2node[pxm];
  57         if (node == 0xff) {
  58                 if (nodes_weight(nodes_found) >= MAX_NUMNODES)
  59                         return -1;
  60                 node = first_unset_node(nodes_found);
  61                 node_set(node, nodes_found);
  62                 pxm2node[pxm] = node;
  63         }
  64         return pxm2node[pxm];
  65 }
  66
  67 static __init int conflicting_nodes(unsigned long start, unsigned long end)
  68 {
  69         int i;
  70         for_each_node_mask(i, nodes_parsed) {
  71                 struct bootnode *nd = &nodes[i];
  72                 if (nd->start == nd->end)
  73                         continue;
  74                 if (nd->end > start && nd->start < end)
  75                         return i;
  76                 if (nd->end == end && nd->start == start)
  77                         return i;
  78         }
  79         return -1;
  80 }
  81
  82 static __init void cutoff_node(int i, unsigned long start, unsigned long end)
  83 {
  84         struct bootnode *nd = &nodes[i];
  85
  86         if (found_add_area)
  87                 return;
  88
  89         if (nd->start < start) {
  90                 nd->start = start;
  91                 if (nd->end < nd->start)
  92                         nd->start = nd->end;
  93         }
  94         if (nd->end > end) {
  95                 nd->end = end;
  96                 if (nd->start > nd->end)
  97                         nd->start = nd->end;
  98         }
  99 }
 100
 101 static __init void bad_srat(void)
 102 {
 103         int i;
 104         printk(KERN_ERR "SRAT: SRAT not used.\n");
 105         acpi_numa = -1;
 106         for (i = 0; i < MAX_LOCAL_APIC; i++)
 107                 apicid_to_node[i] = NUMA_NO_NODE;
 108         for (i = 0; i < MAX_NUMNODES; i++)
 109                 nodes_add[i].start = nodes[i].end = 0;
 110 }
 111
 112 static __init inline int srat_disabled(void)
 113 {
 114         return numa_off || acpi_numa < 0;
 115 }
 116
 117 /*
 118  * A lot of BIOS fill in 10 (= no distance) everywhere. This messes
 119  * up the NUMA heuristics which wants the local node to have a smaller
 120  * distance than the others.
 121  * Do some quick checks here and only use the SLIT if it passes.
 122  */
 123 static __init int slit_valid(struct acpi_table_slit *slit)
 124 {
 125         int i, j;
 126         int d = slit->localities;
 127         for (i = 0; i < d; i++) {
 128                 for (j = 0; j < d; j++)  {
 129                         u8 val = slit->entry[d*i + j];
 130                         if (i == j) {
 131                                 if (val != 10)
 132                                         return 0;
 133                         } else if (val <= 10)
 134                                 return 0;
 135                 }
 136         }
 137         return 1;
 138 }
 139
 140 /* Callback for SLIT parsing */
 141 void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
 142 {
 143         if (!slit_valid(slit)) {
 144                 printk(KERN_INFO "ACPI: SLIT table looks invalid. Not used.\n");
 145                 return;
 146         }
 147         acpi_slit = slit;
 148 }
 149
 150 /* Callback for Proximity Domain -> LAPIC mapping */
 151 void __init
 152 acpi_numa_processor_affinity_init(struct acpi_table_processor_affinity *pa)
 153 {
 154         int pxm, node;
 155         if (srat_disabled())
 156                 return;
 157         if (pa->header.length != sizeof(struct acpi_table_processor_affinity)) {                bad_srat();
 158                 return;
 159         }
 160         if (pa->flags.enabled == 0)
 161                 return;
 162         pxm = pa->proximity_domain;
 163         node = setup_node(pxm);
 164         if (node < 0) {
 165                 printk(KERN_ERR "SRAT: Too many proximity domains %x\n", pxm);
 166                 bad_srat();
 167                 return;
 168         }
 169         apicid_to_node[pa->apic_id] = node;
 170         acpi_numa = 1;
 171         printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
 172                pxm, pa->apic_id, node);
 173 }
 174
 175 #ifdef RESERVE_HOTADD
 176 /*
 177  * Protect against too large hotadd areas that would fill up memory.
 178  */
 179 static int hotadd_enough_memory(struct bootnode *nd)
 180 {
 181         static unsigned long allocated;
 182         static unsigned long last_area_end;
 183         unsigned long pages = (nd->end - nd->start) >> PAGE_SHIFT;
 184         long mem = pages * sizeof(struct page);
 185         unsigned long addr;
 186         unsigned long allowed;
 187         unsigned long oldpages = pages;
 188
 189         if (mem < 0)
 190                 return 0;
 191         allowed = (end_pfn - e820_hole_size(0, end_pfn)) * PAGE_SIZE;
 192         allowed = (allowed / 100) * hotadd_percent;
 193         if (allocated + mem > allowed) {
 194                 /* Give them at least part of their hotadd memory upto hotadd_percent
 195                    It would be better to spread the limit out
 196                    over multiple hotplug areas, but that is too complicated
 197                    right now */
 198                 if (allocated >= allowed)
 199                         return 0;
 200                 pages = (allowed - allocated + mem) / sizeof(struct page);
 201                 mem = pages * sizeof(struct page);
 202                 nd->end = nd->start + pages*PAGE_SIZE;
 203         }
 204         /* Not completely fool proof, but a good sanity check */
 205         addr = find_e820_area(last_area_end, end_pfn<<PAGE_SHIFT, mem);
 206         if (addr == -1UL)
 207                 return 0;
 208         if (pages != oldpages)
 209                 printk(KERN_NOTICE "SRAT: Hotadd area limited to %lu bytes\n",
 210                         pages << PAGE_SHIFT);
 211         last_area_end = addr + mem;
 212         allocated += mem;
 213         return 1;
 214 }
 215
 216 /*
 217  * It is fine to add this area to the nodes data it will be used later
 218  * This code supports one contigious hot add area per node.
 219  */
 220 static int reserve_hotadd(int node, unsigned long start, unsigned long end)
 221 {
 222         unsigned long s_pfn = start >> PAGE_SHIFT;
 223         unsigned long e_pfn = end >> PAGE_SHIFT;
 224         int changed = 0;
 225         struct bootnode *nd = &nodes_add[node];
 226
 227         /* I had some trouble with strange memory hotadd regions breaking
 228            the boot. Be very strict here and reject anything unexpected.
 229            If you want working memory hotadd write correct SRATs.
 230
 231            The node size check is a basic sanity check to guard against
 232            mistakes */
 233         if ((signed long)(end - start) < NODE_MIN_SIZE) {
 234                 printk(KERN_ERR "SRAT: Hotplug area too small\n");
 235                 return -1;
 236         }
 237
 238         /* This check might be a bit too strict, but I'm keeping it for now. */
 239         if (e820_hole_size(s_pfn, e_pfn) != e_pfn - s_pfn) {
 240                 printk(KERN_ERR "SRAT: Hotplug area has existing memory\n");
 241                 return -1;
 242         }
 243
 244         if (!hotadd_enough_memory(&nodes_add[node]))  {
 245                 printk(KERN_ERR "SRAT: Hotplug area too large\n");
 246                 return -1;
 247         }
 248
 249         /* Looks good */
 250
 251         found_add_area = 1;
 252         if (nd->start == nd->end) {
 253                 nd->start = start;
 254                 nd->end = end;
 255                 changed = 1;
 256         } else {
 257                 if (nd->start == end) {
 258                         nd->start = start;
 259                         changed = 1;
 260                 }
 261                 if (nd->end == start) {
 262                         nd->end = end;
 263                         changed = 1;
 264                 }
 265                 if (!changed)
 266                         printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
 267         }
 268
 269         if ((nd->end >> PAGE_SHIFT) > end_pfn)
 270                 end_pfn = nd->end >> PAGE_SHIFT;
 271
 272         if (changed)
 273                 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
 274         return 0;
 275 }
 276 #endif
 277
 278 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
 279 void __init
 280 acpi_numa_memory_affinity_init(struct acpi_table_memory_affinity *ma)
 281 {
 282         struct bootnode *nd, oldnode;
 283         unsigned long start, end;
 284         int node, pxm;
 285         int i;
 286
 287         if (srat_disabled())
 288                 return;
 289         if (ma->header.length != sizeof(struct acpi_table_memory_affinity)) {
 290                 bad_srat();
 291                 return;
 292         }
 293         if (ma->flags.enabled == 0)
 294                 return;
 295         if (ma->flags.hot_pluggable && hotadd_percent == 0)
 296                 return;
 297         start = ma->base_addr_lo | ((u64)ma->base_addr_hi << 32);
 298         end = start + (ma->length_lo | ((u64)ma->length_hi << 32));
 299         pxm = ma->proximity_domain;
 300         node = setup_node(pxm);
 301         if (node < 0) {
 302                 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
 303                 bad_srat();
 304                 return;
 305         }
 306         i = conflicting_nodes(start, end);
 307         if (i == node) {
 308                 printk(KERN_WARNING
 309                 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
 310                         pxm, start, end, nodes[i].start, nodes[i].end);
 311         } else if (i >= 0) {
 312                 printk(KERN_ERR
 313                        "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
 314                        pxm, start, end, node_to_pxm(i),
 315                         nodes[i].start, nodes[i].end);
 316                 bad_srat();
 317                 return;
 318         }
 319         nd = &nodes[node];
 320         oldnode = *nd;
 321         if (!node_test_and_set(node, nodes_parsed)) {
 322                 nd->start = start;
 323                 nd->end = end;
 324         } else {
 325                 if (start < nd->start)
 326                         nd->start = start;
 327                 if (nd->end < end)
 328                         nd->end = end;
 329         }
 330
 331         printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
 332                nd->start, nd->end);
 333
 334 #ifdef RESERVE_HOTADD
 335         if (ma->flags.hot_pluggable && reserve_hotadd(node, start, end) < 0) {
 336                 /* Ignore hotadd region. Undo damage */
 337                 printk(KERN_NOTICE "SRAT: Hotplug region ignored\n");
 338                 *nd = oldnode;
 339                 if ((nd->start | nd->end) == 0)
 340                         node_clear(node, nodes_parsed);
 341         }
 342 #endif
 343 }
 344
 345 /* Sanity check to catch more bad SRATs (they are amazingly common).
 346    Make sure the PXMs cover all memory. */
 347 static int nodes_cover_memory(void)
 348 {
 349         int i;
 350         unsigned long pxmram, e820ram;
 351
 352         pxmram = 0;
 353         for_each_node_mask(i, nodes_parsed) {
 354                 unsigned long s = nodes[i].start >> PAGE_SHIFT;
 355                 unsigned long e = nodes[i].end >> PAGE_SHIFT;
 356                 pxmram += e - s;
 357                 pxmram -= e820_hole_size(s, e);
 358                 pxmram -= nodes_add[i].end - nodes_add[i].start;
 359                 if ((long)pxmram < 0)
 360                         pxmram = 0;
 361         }
 362
 363         e820ram = end_pfn - e820_hole_size(0, end_pfn);
 364         /* We seem to lose 3 pages somewhere. Allow a bit of slack. */
 365         if ((long)(e820ram - pxmram) >= 1*1024*1024) {
 366                 printk(KERN_ERR
 367         "SRAT: PXMs only cover %luMB of your %luMB e820 RAM. Not used.\n",
 368                         (pxmram << PAGE_SHIFT) >> 20,
 369                         (e820ram << PAGE_SHIFT) >> 20);
 370                 return 0;
 371         }
 372         return 1;
 373 }
 374
 375 static void unparse_node(int node)
 376 {
 377         int i;
 378         node_clear(node, nodes_parsed);
 379         for (i = 0; i < MAX_LOCAL_APIC; i++) {
 380                 if (apicid_to_node[i] == node)
 381                         apicid_to_node[i] = NUMA_NO_NODE;
 382         }
 383 }
 384
 385 void __init acpi_numa_arch_fixup(void) {}
 386
 387 /* Use the information discovered above to actually set up the nodes. */
 388 int __init acpi_scan_nodes(unsigned long start, unsigned long end)
 389 {
 390         int i;
 391
 392         /* First clean up the node list */
 393         for (i = 0; i < MAX_NUMNODES; i++) {
 394                 cutoff_node(i, start, end);
 395                 if ((nodes[i].end - nodes[i].start) < NODE_MIN_SIZE)
 396                         unparse_node(i);
 397         }
 398
 399         if (acpi_numa <= 0)
 400                 return -1;
 401
 402         if (!nodes_cover_memory()) {
 403                 bad_srat();
 404                 return -1;
 405         }
 406
 407         memnode_shift = compute_hash_shift(nodes, MAX_NUMNODES);
 408         if (memnode_shift < 0) {
 409                 printk(KERN_ERR
 410                      "SRAT: No NUMA node hash function found. Contact maintainer\n");
 411                 bad_srat();
 412                 return -1;
 413         }
 414
 415         /* Finally register nodes */
 416         for_each_node_mask(i, nodes_parsed)
 417                 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 418         /* Try again in case setup_node_bootmem missed one due
 419            to missing bootmem */
 420         for_each_node_mask(i, nodes_parsed)
 421                 if (!node_online(i))
 422                         setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 423
 424         for (i = 0; i < NR_CPUS; i++) {
 425                 if (cpu_to_node[i] == NUMA_NO_NODE)
 426                         continue;
 427                 if (!node_isset(cpu_to_node[i], nodes_parsed))
 428                         numa_set_node(i, NUMA_NO_NODE);
 429         }
 430         numa_init_array();
 431         return 0;
 432 }
 433
 434 static int node_to_pxm(int n)
 435 {
 436        int i;
 437        if (pxm2node[n] == n)
 438                return n;
 439        for (i = 0; i < 256; i++)
 440                if (pxm2node[i] == n)
 441                        return i;
 442        return 0;
 443 }
 444
 445 void __init srat_reserve_add_area(int nodeid)
 446 {
 447         if (found_add_area && nodes_add[nodeid].end) {
 448                 u64 total_mb;
 449
 450                 printk(KERN_INFO "SRAT: Reserving hot-add memory space "
 451                                 "for node %d at %Lx-%Lx\n",
 452                         nodeid, nodes_add[nodeid].start, nodes_add[nodeid].end);
 453                 total_mb = (nodes_add[nodeid].end - nodes_add[nodeid].start)
 454                                         >> PAGE_SHIFT;
 455                 total_mb *= sizeof(struct page);
 456                 total_mb >>= 20;
 457                 printk(KERN_INFO "SRAT: This will cost you %Lu MB of "
 458                                 "pre-allocated memory.\n", (unsigned long long)total_mb);
 459                 reserve_bootmem_node(NODE_DATA(nodeid), nodes_add[nodeid].start,
 460                                nodes_add[nodeid].end - nodes_add[nodeid].start);
 461         }
 462 }
 463
 464 int __node_distance(int a, int b)
 465 {
 466         int index;
 467
 468         if (!acpi_slit)
 469                 return a == b ? 10 : 20;
 470         index = acpi_slit->localities * node_to_pxm(a);
 471         return acpi_slit->entry[index + node_to_pxm(b)];
 472 }
 473
 474 EXPORT_SYMBOL(__node_distance);