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