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