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 -> LAPIC mapping */
 120 void __init
 121 acpi_numa_processor_affinity_init(struct acpi_srat_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_cpu_affinity)) {
 129                 bad_srat();
 130                 return;
 131         }
 132         if ((pa->flags & ACPI_SRAT_CPU_ENABLED) == 0)
 133                 return;
 134         pxm = pa->proximity_domain_lo;
 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         if (get_uv_system_type() >= UV_X2APIC)
 143                 apic_id = (pa->apic_id << 8) | pa->local_sapic_eid;
 144         else
 145                 apic_id = pa->apic_id;
 146         apicid_to_node[apic_id] = node;
 147         acpi_numa = 1;
 148         printk(KERN_INFO "SRAT: PXM %u -> APIC %u -> Node %u\n",
 149                pxm, apic_id, node);
 150 }
 151
 152 static int update_end_of_memory(unsigned long end) {return -1;}
 153 static int hotadd_enough_memory(struct bootnode *nd) {return 1;}
 154 #ifdef CONFIG_MEMORY_HOTPLUG_SPARSE
 155 static inline int save_add_info(void) {return 1;}
 156 #else
 157 static inline int save_add_info(void) {return 0;}
 158 #endif
 159 /*
 160  * Update nodes_add and decide if to include add are in the zone.
 161  * Both SPARSE and RESERVE need nodes_add information.
 162  * This code supports one contiguous hot add area per node.
 163  */
 164 static int __init
 165 reserve_hotadd(int node, unsigned long start, unsigned long end)
 166 {
 167         unsigned long s_pfn = start >> PAGE_SHIFT;
 168         unsigned long e_pfn = end >> PAGE_SHIFT;
 169         int ret = 0, changed = 0;
 170         struct bootnode *nd = &nodes_add[node];
 171
 172         /* I had some trouble with strange memory hotadd regions breaking
 173            the boot. Be very strict here and reject anything unexpected.
 174            If you want working memory hotadd write correct SRATs.
 175
 176            The node size check is a basic sanity check to guard against
 177            mistakes */
 178         if ((signed long)(end - start) < NODE_MIN_SIZE) {
 179                 printk(KERN_ERR "SRAT: Hotplug area too small\n");
 180                 return -1;
 181         }
 182
 183         /* This check might be a bit too strict, but I'm keeping it for now. */
 184         if (absent_pages_in_range(s_pfn, e_pfn) != e_pfn - s_pfn) {
 185                 printk(KERN_ERR
 186                         "SRAT: Hotplug area %lu -> %lu has existing memory\n",
 187                         s_pfn, e_pfn);
 188                 return -1;
 189         }
 190
 191         if (!hotadd_enough_memory(&nodes_add[node]))  {
 192                 printk(KERN_ERR "SRAT: Hotplug area too large\n");
 193                 return -1;
 194         }
 195
 196         /* Looks good */
 197
 198         if (nd->start == nd->end) {
 199                 nd->start = start;
 200                 nd->end = end;
 201                 changed = 1;
 202         } else {
 203                 if (nd->start == end) {
 204                         nd->start = start;
 205                         changed = 1;
 206                 }
 207                 if (nd->end == start) {
 208                         nd->end = end;
 209                         changed = 1;
 210                 }
 211                 if (!changed)
 212                         printk(KERN_ERR "SRAT: Hotplug zone not continuous. Partly ignored\n");
 213         }
 214
 215         ret = update_end_of_memory(nd->end);
 216
 217         if (changed)
 218                 printk(KERN_INFO "SRAT: hot plug zone found %Lx - %Lx\n", nd->start, nd->end);
 219         return ret;
 220 }
 221
 222 /* Callback for parsing of the Proximity Domain <-> Memory Area mappings */
 223 void __init
 224 acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 225 {
 226         struct bootnode *nd, oldnode;
 227         unsigned long start, end;
 228         int node, pxm;
 229         int i;
 230
 231         if (srat_disabled())
 232                 return;
 233         if (ma->header.length != sizeof(struct acpi_srat_mem_affinity)) {
 234                 bad_srat();
 235                 return;
 236         }
 237         if ((ma->flags & ACPI_SRAT_MEM_ENABLED) == 0)
 238                 return;
 239
 240         if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) && !save_add_info())
 241                 return;
 242         start = ma->base_address;
 243         end = start + ma->length;
 244         pxm = ma->proximity_domain;
 245         node = setup_node(pxm);
 246         if (node < 0) {
 247                 printk(KERN_ERR "SRAT: Too many proximity domains.\n");
 248                 bad_srat();
 249                 return;
 250         }
 251         i = conflicting_memblks(start, end);
 252         if (i == node) {
 253                 printk(KERN_WARNING
 254                 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
 255                         pxm, start, end, nodes[i].start, nodes[i].end);
 256         } else if (i >= 0) {
 257                 printk(KERN_ERR
 258                        "SRAT: PXM %d (%lx-%lx) overlaps with PXM %d (%Lx-%Lx)\n",
 259                        pxm, start, end, node_to_pxm(i),
 260                         nodes[i].start, nodes[i].end);
 261                 bad_srat();
 262                 return;
 263         }
 264         nd = &nodes[node];
 265         oldnode = *nd;
 266         if (!node_test_and_set(node, nodes_parsed)) {
 267                 nd->start = start;
 268                 nd->end = end;
 269         } else {
 270                 if (start < nd->start)
 271                         nd->start = start;
 272                 if (nd->end < end)
 273                         nd->end = end;
 274         }
 275
 276         printk(KERN_INFO "SRAT: Node %u PXM %u %lx-%lx\n", node, pxm,
 277                start, end);
 278         e820_register_active_regions(node, start >> PAGE_SHIFT,
 279                                      end >> PAGE_SHIFT);
 280         push_node_boundaries(node, nd->start >> PAGE_SHIFT,
 281                                                 nd->end >> PAGE_SHIFT);
 282
 283         if ((ma->flags & ACPI_SRAT_MEM_HOT_PLUGGABLE) &&
 284             (reserve_hotadd(node, start, end) < 0)) {
 285                 /* Ignore hotadd region. Undo damage */
 286                 printk(KERN_NOTICE "SRAT: Hotplug region ignored\n");
 287                 *nd = oldnode;
 288                 if ((nd->start | nd->end) == 0)
 289                         node_clear(node, nodes_parsed);
 290         }
 291
 292         node_memblk_range[num_node_memblks].start = start;
 293         node_memblk_range[num_node_memblks].end = end;
 294         memblk_nodeid[num_node_memblks] = node;
 295         num_node_memblks++;
 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 = max_pfn - absent_pages_in_range(0, max_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(node_memblk_range, num_node_memblks,
 367                                            memblk_nodeid);
 368         if (memnode_shift < 0) {
 369                 printk(KERN_ERR
 370                      "SRAT: No NUMA node hash function found. Contact maintainer\n");
 371                 bad_srat();
 372                 return -1;
 373         }
 374
 375         node_possible_map = nodes_parsed;
 376
 377         /* Finally register nodes */
 378         for_each_node_mask(i, node_possible_map)
 379                 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 380         /* Try again in case setup_node_bootmem missed one due
 381            to missing bootmem */
 382         for_each_node_mask(i, node_possible_map)
 383                 if (!node_online(i))
 384                         setup_node_bootmem(i, nodes[i].start, nodes[i].end);
 385
 386         for (i = 0; i < nr_cpu_ids; i++) {
 387                 int node = early_cpu_to_node(i);
 388
 389                 if (node == NUMA_NO_NODE)
 390                         continue;
 391                 if (!node_isset(node, node_possible_map))
 392                         numa_clear_node(i);
 393         }
 394         numa_init_array();
 395         return 0;
 396 }
 397
 398 #ifdef CONFIG_NUMA_EMU
 399 static int fake_node_to_pxm_map[MAX_NUMNODES] __initdata = {
 400         [0 ... MAX_NUMNODES-1] = PXM_INVAL
 401 };
 402 static s16 fake_apicid_to_node[MAX_LOCAL_APIC] __initdata = {
 403         [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
 404 };
 405 static int __init find_node_by_addr(unsigned long addr)
 406 {
 407         int ret = NUMA_NO_NODE;
 408         int i;
 409
 410         for_each_node_mask(i, nodes_parsed) {
 411                 /*
 412                  * Find the real node that this emulated node appears on.  For
 413                  * the sake of simplicity, we only use a real node's starting
 414                  * address to determine which emulated node it appears on.
 415                  */
 416                 if (addr >= nodes[i].start && addr < nodes[i].end) {
 417                         ret = i;
 418                         break;
 419                 }
 420         }
 421         return ret;
 422 }
 423
 424 /*
 425  * In NUMA emulation, we need to setup proximity domain (_PXM) to node ID
 426  * mappings that respect the real ACPI topology but reflect our emulated
 427  * environment.  For each emulated node, we find which real node it appears on
 428  * and create PXM to NID mappings for those fake nodes which mirror that
 429  * locality.  SLIT will now represent the correct distances between emulated
 430  * nodes as a result of the real topology.
 431  */
 432 void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
 433 {
 434         int i, j;
 435
 436         printk(KERN_INFO "Faking PXM affinity for fake nodes on real "
 437                          "topology.\n");
 438         for (i = 0; i < num_nodes; i++) {
 439                 int nid, pxm;
 440
 441                 nid = find_node_by_addr(fake_nodes[i].start);
 442                 if (nid == NUMA_NO_NODE)
 443                         continue;
 444                 pxm = node_to_pxm(nid);
 445                 if (pxm == PXM_INVAL)
 446                         continue;
 447                 fake_node_to_pxm_map[i] = pxm;
 448                 /*
 449                  * For each apicid_to_node mapping that exists for this real
 450                  * node, it must now point to the fake node ID.
 451                  */
 452                 for (j = 0; j < MAX_LOCAL_APIC; j++)
 453                         if (apicid_to_node[j] == nid)
 454                                 fake_apicid_to_node[j] = i;
 455         }
 456         for (i = 0; i < num_nodes; i++)
 457                 __acpi_map_pxm_to_node(fake_node_to_pxm_map[i], i);
 458         memcpy(apicid_to_node, fake_apicid_to_node, sizeof(apicid_to_node));
 459
 460         nodes_clear(nodes_parsed);
 461         for (i = 0; i < num_nodes; i++)
 462                 if (fake_nodes[i].start != fake_nodes[i].end)
 463                         node_set(i, nodes_parsed);
 464         WARN_ON(!nodes_cover_memory(fake_nodes));
 465 }
 466
 467 static int null_slit_node_compare(int a, int b)
 468 {
 469         return node_to_pxm(a) == node_to_pxm(b);
 470 }
 471 #else
 472 static int null_slit_node_compare(int a, int b)
 473 {
 474         return a == b;
 475 }
 476 #endif /* CONFIG_NUMA_EMU */
 477
 478 void __init srat_reserve_add_area(int nodeid)
 479 {
 480         if (found_add_area && nodes_add[nodeid].end) {
 481                 u64 total_mb;
 482
 483                 printk(KERN_INFO "SRAT: Reserving hot-add memory space "
 484                                 "for node %d at %Lx-%Lx\n",
 485                         nodeid, nodes_add[nodeid].start, nodes_add[nodeid].end);
 486                 total_mb = (nodes_add[nodeid].end - nodes_add[nodeid].start)
 487                                         >> PAGE_SHIFT;
 488                 total_mb *= sizeof(struct page);
 489                 total_mb >>= 20;
 490                 printk(KERN_INFO "SRAT: This will cost you %Lu MB of "
 491                                 "pre-allocated memory.\n", (unsigned long long)total_mb);
 492                 reserve_bootmem_node(NODE_DATA(nodeid), nodes_add[nodeid].start,
 493                                nodes_add[nodeid].end - nodes_add[nodeid].start,
 494                                BOOTMEM_DEFAULT);
 495         }
 496 }
 497
 498 int __node_distance(int a, int b)
 499 {
 500         int index;
 501
 502         if (!acpi_slit)
 503                 return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
 504                                                       REMOTE_DISTANCE;
 505         index = acpi_slit->locality_count * node_to_pxm(a);
 506         return acpi_slit->entry[index + node_to_pxm(b)];
 507 }
 508
 509 EXPORT_SYMBOL(__node_distance);
 510
 511 #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) || defined(CONFIG_ACPI_HOTPLUG_MEMORY)
 512 int memory_add_physaddr_to_nid(u64 start)
 513 {
 514         int i, ret = 0;
 515
 516         for_each_node(i)
 517                 if (nodes_add[i].start <= start && nodes_add[i].end > start)
 518                         ret = i;
 519
 520         return ret;
 521 }
 522 EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid);
 523 #endif