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