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