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