1 /* 2 * pSeries NUMA support 3 * 4 * Copyright (C) 2002 Anton Blanchard <anton@au.ibm.com>, IBM 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 */ 11 #include <linux/threads.h> 12 #include <linux/bootmem.h> 13 #include <linux/init.h> 14 #include <linux/mm.h> 15 #include <linux/mmzone.h> 16 #include <linux/export.h> 17 #include <linux/nodemask.h> 18 #include <linux/cpu.h> 19 #include <linux/notifier.h> 20 #include <linux/memblock.h> 21 #include <linux/of.h> 22 #include <linux/pfn.h> 23 #include <linux/cpuset.h> 24 #include <linux/node.h> 25 #include <linux/stop_machine.h> 26 #include <linux/proc_fs.h> 27 #include <linux/seq_file.h> 28 #include <linux/uaccess.h> 29 #include <linux/slab.h> 30 #include <asm/cputhreads.h> 31 #include <asm/sparsemem.h> 32 #include <asm/prom.h> 33 #include <asm/smp.h> 34 #include <asm/cputhreads.h> 35 #include <asm/topology.h> 36 #include <asm/firmware.h> 37 #include <asm/paca.h> 38 #include <asm/hvcall.h> 39 #include <asm/setup.h> 40 #include <asm/vdso.h> 41 42 static int numa_enabled = 1; 43 44 static char *cmdline __initdata; 45 46 static int numa_debug; 47 #define dbg(args...) if (numa_debug) { printk(KERN_INFO args); } 48 49 int numa_cpu_lookup_table[NR_CPUS]; 50 cpumask_var_t node_to_cpumask_map[MAX_NUMNODES]; 51 struct pglist_data *node_data[MAX_NUMNODES]; 52 53 EXPORT_SYMBOL(numa_cpu_lookup_table); 54 EXPORT_SYMBOL(node_to_cpumask_map); 55 EXPORT_SYMBOL(node_data); 56 57 static int min_common_depth; 58 static int n_mem_addr_cells, n_mem_size_cells; 59 static int form1_affinity; 60 61 #define MAX_DISTANCE_REF_POINTS 4 62 static int distance_ref_points_depth; 63 static const __be32 *distance_ref_points; 64 static int distance_lookup_table[MAX_NUMNODES][MAX_DISTANCE_REF_POINTS]; 65 66 /* 67 * Allocate node_to_cpumask_map based on number of available nodes 68 * Requires node_possible_map to be valid. 69 * 70 * Note: cpumask_of_node() is not valid until after this is done. 71 */ 72 static void __init setup_node_to_cpumask_map(void) 73 { 74 unsigned int node; 75 76 /* setup nr_node_ids if not done yet */ 77 if (nr_node_ids == MAX_NUMNODES) 78 setup_nr_node_ids(); 79 80 /* allocate the map */ 81 for (node = 0; node < nr_node_ids; node++) 82 alloc_bootmem_cpumask_var(&node_to_cpumask_map[node]); 83 84 /* cpumask_of_node() will now work */ 85 dbg("Node to cpumask map for %d nodes\n", nr_node_ids); 86 } 87 88 static int __init fake_numa_create_new_node(unsigned long end_pfn, 89 unsigned int *nid) 90 { 91 unsigned long long mem; 92 char *p = cmdline; 93 static unsigned int fake_nid; 94 static unsigned long long curr_boundary; 95 96 /* 97 * Modify node id, iff we started creating NUMA nodes 98 * We want to continue from where we left of the last time 99 */ 100 if (fake_nid) 101 *nid = fake_nid; 102 /* 103 * In case there are no more arguments to parse, the 104 * node_id should be the same as the last fake node id 105 * (we've handled this above). 106 */ 107 if (!p) 108 return 0; 109 110 mem = memparse(p, &p); 111 if (!mem) 112 return 0; 113 114 if (mem < curr_boundary) 115 return 0; 116 117 curr_boundary = mem; 118 119 if ((end_pfn << PAGE_SHIFT) > mem) { 120 /* 121 * Skip commas and spaces 122 */ 123 while (*p == ',' || *p == ' ' || *p == '\t') 124 p++; 125 126 cmdline = p; 127 fake_nid++; 128 *nid = fake_nid; 129 dbg("created new fake_node with id %d\n", fake_nid); 130 return 1; 131 } 132 return 0; 133 } 134 135 /* 136 * get_node_active_region - Return active region containing pfn 137 * Active range returned is empty if none found. 138 * @pfn: The page to return the region for 139 * @node_ar: Returned set to the active region containing @pfn 140 */ 141 static void __init get_node_active_region(unsigned long pfn, 142 struct node_active_region *node_ar) 143 { 144 unsigned long start_pfn, end_pfn; 145 int i, nid; 146 147 for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid) { 148 if (pfn >= start_pfn && pfn < end_pfn) { 149 node_ar->nid = nid; 150 node_ar->start_pfn = start_pfn; 151 node_ar->end_pfn = end_pfn; 152 break; 153 } 154 } 155 } 156 157 static void reset_numa_cpu_lookup_table(void) 158 { 159 unsigned int cpu; 160 161 for_each_possible_cpu(cpu) 162 numa_cpu_lookup_table[cpu] = -1; 163 } 164 165 static void update_numa_cpu_lookup_table(unsigned int cpu, int node) 166 { 167 numa_cpu_lookup_table[cpu] = node; 168 } 169 170 static void map_cpu_to_node(int cpu, int node) 171 { 172 update_numa_cpu_lookup_table(cpu, node); 173 174 dbg("adding cpu %d to node %d\n", cpu, node); 175 176 if (!(cpumask_test_cpu(cpu, node_to_cpumask_map[node]))) 177 cpumask_set_cpu(cpu, node_to_cpumask_map[node]); 178 } 179 180 #if defined(CONFIG_HOTPLUG_CPU) || defined(CONFIG_PPC_SPLPAR) 181 static void unmap_cpu_from_node(unsigned long cpu) 182 { 183 int node = numa_cpu_lookup_table[cpu]; 184 185 dbg("removing cpu %lu from node %d\n", cpu, node); 186 187 if (cpumask_test_cpu(cpu, node_to_cpumask_map[node])) { 188 cpumask_clear_cpu(cpu, node_to_cpumask_map[node]); 189 } else { 190 printk(KERN_ERR "WARNING: cpu %lu not found in node %d\n", 191 cpu, node); 192 } 193 } 194 #endif /* CONFIG_HOTPLUG_CPU || CONFIG_PPC_SPLPAR */ 195 196 /* must hold reference to node during call */ 197 static const __be32 *of_get_associativity(struct device_node *dev) 198 { 199 return of_get_property(dev, "ibm,associativity", NULL); 200 } 201 202 /* 203 * Returns the property linux,drconf-usable-memory if 204 * it exists (the property exists only in kexec/kdump kernels, 205 * added by kexec-tools) 206 */ 207 static const __be32 *of_get_usable_memory(struct device_node *memory) 208 { 209 const __be32 *prop; 210 u32 len; 211 prop = of_get_property(memory, "linux,drconf-usable-memory", &len); 212 if (!prop || len < sizeof(unsigned int)) 213 return NULL; 214 return prop; 215 } 216 217 int __node_distance(int a, int b) 218 { 219 int i; 220 int distance = LOCAL_DISTANCE; 221 222 if (!form1_affinity) 223 return ((a == b) ? LOCAL_DISTANCE : REMOTE_DISTANCE); 224 225 for (i = 0; i < distance_ref_points_depth; i++) { 226 if (distance_lookup_table[a][i] == distance_lookup_table[b][i]) 227 break; 228 229 /* Double the distance for each NUMA level */ 230 distance *= 2; 231 } 232 233 return distance; 234 } 235 EXPORT_SYMBOL(__node_distance); 236 237 static void initialize_distance_lookup_table(int nid, 238 const __be32 *associativity) 239 { 240 int i; 241 242 if (!form1_affinity) 243 return; 244 245 for (i = 0; i < distance_ref_points_depth; i++) { 246 const __be32 *entry; 247 248 entry = &associativity[be32_to_cpu(distance_ref_points[i])]; 249 distance_lookup_table[nid][i] = of_read_number(entry, 1); 250 } 251 } 252 253 /* Returns nid in the range [0..MAX_NUMNODES-1], or -1 if no useful numa 254 * info is found. 255 */ 256 static int associativity_to_nid(const __be32 *associativity) 257 { 258 int nid = -1; 259 260 if (min_common_depth == -1) 261 goto out; 262 263 if (of_read_number(associativity, 1) >= min_common_depth) 264 nid = of_read_number(&associativity[min_common_depth], 1); 265 266 /* POWER4 LPAR uses 0xffff as invalid node */ 267 if (nid == 0xffff || nid >= MAX_NUMNODES) 268 nid = -1; 269 270 if (nid > 0 && 271 of_read_number(associativity, 1) >= distance_ref_points_depth) 272 initialize_distance_lookup_table(nid, associativity); 273 274 out: 275 return nid; 276 } 277 278 /* Returns the nid associated with the given device tree node, 279 * or -1 if not found. 280 */ 281 static int of_node_to_nid_single(struct device_node *device) 282 { 283 int nid = -1; 284 const __be32 *tmp; 285 286 tmp = of_get_associativity(device); 287 if (tmp) 288 nid = associativity_to_nid(tmp); 289 return nid; 290 } 291 292 /* Walk the device tree upwards, looking for an associativity id */ 293 int of_node_to_nid(struct device_node *device) 294 { 295 struct device_node *tmp; 296 int nid = -1; 297 298 of_node_get(device); 299 while (device) { 300 nid = of_node_to_nid_single(device); 301 if (nid != -1) 302 break; 303 304 tmp = device; 305 device = of_get_parent(tmp); 306 of_node_put(tmp); 307 } 308 of_node_put(device); 309 310 return nid; 311 } 312 EXPORT_SYMBOL_GPL(of_node_to_nid); 313 314 static int __init find_min_common_depth(void) 315 { 316 int depth; 317 struct device_node *root; 318 319 if (firmware_has_feature(FW_FEATURE_OPAL)) 320 root = of_find_node_by_path("/ibm,opal"); 321 else 322 root = of_find_node_by_path("/rtas"); 323 if (!root) 324 root = of_find_node_by_path("/"); 325 326 /* 327 * This property is a set of 32-bit integers, each representing 328 * an index into the ibm,associativity nodes. 329 * 330 * With form 0 affinity the first integer is for an SMP configuration 331 * (should be all 0's) and the second is for a normal NUMA 332 * configuration. We have only one level of NUMA. 333 * 334 * With form 1 affinity the first integer is the most significant 335 * NUMA boundary and the following are progressively less significant 336 * boundaries. There can be more than one level of NUMA. 337 */ 338 distance_ref_points = of_get_property(root, 339 "ibm,associativity-reference-points", 340 &distance_ref_points_depth); 341 342 if (!distance_ref_points) { 343 dbg("NUMA: ibm,associativity-reference-points not found.\n"); 344 goto err; 345 } 346 347 distance_ref_points_depth /= sizeof(int); 348 349 if (firmware_has_feature(FW_FEATURE_OPAL) || 350 firmware_has_feature(FW_FEATURE_TYPE1_AFFINITY)) { 351 dbg("Using form 1 affinity\n"); 352 form1_affinity = 1; 353 } 354 355 if (form1_affinity) { 356 depth = of_read_number(distance_ref_points, 1); 357 } else { 358 if (distance_ref_points_depth < 2) { 359 printk(KERN_WARNING "NUMA: " 360 "short ibm,associativity-reference-points\n"); 361 goto err; 362 } 363 364 depth = of_read_number(&distance_ref_points[1], 1); 365 } 366 367 /* 368 * Warn and cap if the hardware supports more than 369 * MAX_DISTANCE_REF_POINTS domains. 370 */ 371 if (distance_ref_points_depth > MAX_DISTANCE_REF_POINTS) { 372 printk(KERN_WARNING "NUMA: distance array capped at " 373 "%d entries\n", MAX_DISTANCE_REF_POINTS); 374 distance_ref_points_depth = MAX_DISTANCE_REF_POINTS; 375 } 376 377 of_node_put(root); 378 return depth; 379 380 err: 381 of_node_put(root); 382 return -1; 383 } 384 385 static void __init get_n_mem_cells(int *n_addr_cells, int *n_size_cells) 386 { 387 struct device_node *memory = NULL; 388 389 memory = of_find_node_by_type(memory, "memory"); 390 if (!memory) 391 panic("numa.c: No memory nodes found!"); 392 393 *n_addr_cells = of_n_addr_cells(memory); 394 *n_size_cells = of_n_size_cells(memory); 395 of_node_put(memory); 396 } 397 398 static unsigned long read_n_cells(int n, const __be32 **buf) 399 { 400 unsigned long result = 0; 401 402 while (n--) { 403 result = (result << 32) | of_read_number(*buf, 1); 404 (*buf)++; 405 } 406 return result; 407 } 408 409 /* 410 * Read the next memblock list entry from the ibm,dynamic-memory property 411 * and return the information in the provided of_drconf_cell structure. 412 */ 413 static void read_drconf_cell(struct of_drconf_cell *drmem, const __be32 **cellp) 414 { 415 const __be32 *cp; 416 417 drmem->base_addr = read_n_cells(n_mem_addr_cells, cellp); 418 419 cp = *cellp; 420 drmem->drc_index = of_read_number(cp, 1); 421 drmem->reserved = of_read_number(&cp[1], 1); 422 drmem->aa_index = of_read_number(&cp[2], 1); 423 drmem->flags = of_read_number(&cp[3], 1); 424 425 *cellp = cp + 4; 426 } 427 428 /* 429 * Retrieve and validate the ibm,dynamic-memory property of the device tree. 430 * 431 * The layout of the ibm,dynamic-memory property is a number N of memblock 432 * list entries followed by N memblock list entries. Each memblock list entry 433 * contains information as laid out in the of_drconf_cell struct above. 434 */ 435 static int of_get_drconf_memory(struct device_node *memory, const __be32 **dm) 436 { 437 const __be32 *prop; 438 u32 len, entries; 439 440 prop = of_get_property(memory, "ibm,dynamic-memory", &len); 441 if (!prop || len < sizeof(unsigned int)) 442 return 0; 443 444 entries = of_read_number(prop++, 1); 445 446 /* Now that we know the number of entries, revalidate the size 447 * of the property read in to ensure we have everything 448 */ 449 if (len < (entries * (n_mem_addr_cells + 4) + 1) * sizeof(unsigned int)) 450 return 0; 451 452 *dm = prop; 453 return entries; 454 } 455 456 /* 457 * Retrieve and validate the ibm,lmb-size property for drconf memory 458 * from the device tree. 459 */ 460 static u64 of_get_lmb_size(struct device_node *memory) 461 { 462 const __be32 *prop; 463 u32 len; 464 465 prop = of_get_property(memory, "ibm,lmb-size", &len); 466 if (!prop || len < sizeof(unsigned int)) 467 return 0; 468 469 return read_n_cells(n_mem_size_cells, &prop); 470 } 471 472 struct assoc_arrays { 473 u32 n_arrays; 474 u32 array_sz; 475 const __be32 *arrays; 476 }; 477 478 /* 479 * Retrieve and validate the list of associativity arrays for drconf 480 * memory from the ibm,associativity-lookup-arrays property of the 481 * device tree.. 482 * 483 * The layout of the ibm,associativity-lookup-arrays property is a number N 484 * indicating the number of associativity arrays, followed by a number M 485 * indicating the size of each associativity array, followed by a list 486 * of N associativity arrays. 487 */ 488 static int of_get_assoc_arrays(struct device_node *memory, 489 struct assoc_arrays *aa) 490 { 491 const __be32 *prop; 492 u32 len; 493 494 prop = of_get_property(memory, "ibm,associativity-lookup-arrays", &len); 495 if (!prop || len < 2 * sizeof(unsigned int)) 496 return -1; 497 498 aa->n_arrays = of_read_number(prop++, 1); 499 aa->array_sz = of_read_number(prop++, 1); 500 501 /* Now that we know the number of arrays and size of each array, 502 * revalidate the size of the property read in. 503 */ 504 if (len < (aa->n_arrays * aa->array_sz + 2) * sizeof(unsigned int)) 505 return -1; 506 507 aa->arrays = prop; 508 return 0; 509 } 510 511 /* 512 * This is like of_node_to_nid_single() for memory represented in the 513 * ibm,dynamic-reconfiguration-memory node. 514 */ 515 static int of_drconf_to_nid_single(struct of_drconf_cell *drmem, 516 struct assoc_arrays *aa) 517 { 518 int default_nid = 0; 519 int nid = default_nid; 520 int index; 521 522 if (min_common_depth > 0 && min_common_depth <= aa->array_sz && 523 !(drmem->flags & DRCONF_MEM_AI_INVALID) && 524 drmem->aa_index < aa->n_arrays) { 525 index = drmem->aa_index * aa->array_sz + min_common_depth - 1; 526 nid = of_read_number(&aa->arrays[index], 1); 527 528 if (nid == 0xffff || nid >= MAX_NUMNODES) 529 nid = default_nid; 530 } 531 532 return nid; 533 } 534 535 /* 536 * Figure out to which domain a cpu belongs and stick it there. 537 * Return the id of the domain used. 538 */ 539 static int numa_setup_cpu(unsigned long lcpu) 540 { 541 int nid; 542 struct device_node *cpu; 543 544 /* 545 * If a valid cpu-to-node mapping is already available, use it 546 * directly instead of querying the firmware, since it represents 547 * the most recent mapping notified to us by the platform (eg: VPHN). 548 */ 549 if ((nid = numa_cpu_lookup_table[lcpu]) >= 0) { 550 map_cpu_to_node(lcpu, nid); 551 return nid; 552 } 553 554 cpu = of_get_cpu_node(lcpu, NULL); 555 556 if (!cpu) { 557 WARN_ON(1); 558 nid = 0; 559 goto out; 560 } 561 562 nid = of_node_to_nid_single(cpu); 563 564 if (nid < 0 || !node_online(nid)) 565 nid = first_online_node; 566 out: 567 map_cpu_to_node(lcpu, nid); 568 569 of_node_put(cpu); 570 571 return nid; 572 } 573 574 static void verify_cpu_node_mapping(int cpu, int node) 575 { 576 int base, sibling, i; 577 578 /* Verify that all the threads in the core belong to the same node */ 579 base = cpu_first_thread_sibling(cpu); 580 581 for (i = 0; i < threads_per_core; i++) { 582 sibling = base + i; 583 584 if (sibling == cpu || cpu_is_offline(sibling)) 585 continue; 586 587 if (cpu_to_node(sibling) != node) { 588 WARN(1, "CPU thread siblings %d and %d don't belong" 589 " to the same node!\n", cpu, sibling); 590 break; 591 } 592 } 593 } 594 595 static int cpu_numa_callback(struct notifier_block *nfb, unsigned long action, 596 void *hcpu) 597 { 598 unsigned long lcpu = (unsigned long)hcpu; 599 int ret = NOTIFY_DONE, nid; 600 601 switch (action) { 602 case CPU_UP_PREPARE: 603 case CPU_UP_PREPARE_FROZEN: 604 nid = numa_setup_cpu(lcpu); 605 verify_cpu_node_mapping((int)lcpu, nid); 606 ret = NOTIFY_OK; 607 break; 608 #ifdef CONFIG_HOTPLUG_CPU 609 case CPU_DEAD: 610 case CPU_DEAD_FROZEN: 611 case CPU_UP_CANCELED: 612 case CPU_UP_CANCELED_FROZEN: 613 unmap_cpu_from_node(lcpu); 614 break; 615 ret = NOTIFY_OK; 616 #endif 617 } 618 return ret; 619 } 620 621 /* 622 * Check and possibly modify a memory region to enforce the memory limit. 623 * 624 * Returns the size the region should have to enforce the memory limit. 625 * This will either be the original value of size, a truncated value, 626 * or zero. If the returned value of size is 0 the region should be 627 * discarded as it lies wholly above the memory limit. 628 */ 629 static unsigned long __init numa_enforce_memory_limit(unsigned long start, 630 unsigned long size) 631 { 632 /* 633 * We use memblock_end_of_DRAM() in here instead of memory_limit because 634 * we've already adjusted it for the limit and it takes care of 635 * having memory holes below the limit. Also, in the case of 636 * iommu_is_off, memory_limit is not set but is implicitly enforced. 637 */ 638 639 if (start + size <= memblock_end_of_DRAM()) 640 return size; 641 642 if (start >= memblock_end_of_DRAM()) 643 return 0; 644 645 return memblock_end_of_DRAM() - start; 646 } 647 648 /* 649 * Reads the counter for a given entry in 650 * linux,drconf-usable-memory property 651 */ 652 static inline int __init read_usm_ranges(const __be32 **usm) 653 { 654 /* 655 * For each lmb in ibm,dynamic-memory a corresponding 656 * entry in linux,drconf-usable-memory property contains 657 * a counter followed by that many (base, size) duple. 658 * read the counter from linux,drconf-usable-memory 659 */ 660 return read_n_cells(n_mem_size_cells, usm); 661 } 662 663 /* 664 * Extract NUMA information from the ibm,dynamic-reconfiguration-memory 665 * node. This assumes n_mem_{addr,size}_cells have been set. 666 */ 667 static void __init parse_drconf_memory(struct device_node *memory) 668 { 669 const __be32 *uninitialized_var(dm), *usm; 670 unsigned int n, rc, ranges, is_kexec_kdump = 0; 671 unsigned long lmb_size, base, size, sz; 672 int nid; 673 struct assoc_arrays aa = { .arrays = NULL }; 674 675 n = of_get_drconf_memory(memory, &dm); 676 if (!n) 677 return; 678 679 lmb_size = of_get_lmb_size(memory); 680 if (!lmb_size) 681 return; 682 683 rc = of_get_assoc_arrays(memory, &aa); 684 if (rc) 685 return; 686 687 /* check if this is a kexec/kdump kernel */ 688 usm = of_get_usable_memory(memory); 689 if (usm != NULL) 690 is_kexec_kdump = 1; 691 692 for (; n != 0; --n) { 693 struct of_drconf_cell drmem; 694 695 read_drconf_cell(&drmem, &dm); 696 697 /* skip this block if the reserved bit is set in flags (0x80) 698 or if the block is not assigned to this partition (0x8) */ 699 if ((drmem.flags & DRCONF_MEM_RESERVED) 700 || !(drmem.flags & DRCONF_MEM_ASSIGNED)) 701 continue; 702 703 base = drmem.base_addr; 704 size = lmb_size; 705 ranges = 1; 706 707 if (is_kexec_kdump) { 708 ranges = read_usm_ranges(&usm); 709 if (!ranges) /* there are no (base, size) duple */ 710 continue; 711 } 712 do { 713 if (is_kexec_kdump) { 714 base = read_n_cells(n_mem_addr_cells, &usm); 715 size = read_n_cells(n_mem_size_cells, &usm); 716 } 717 nid = of_drconf_to_nid_single(&drmem, &aa); 718 fake_numa_create_new_node( 719 ((base + size) >> PAGE_SHIFT), 720 &nid); 721 node_set_online(nid); 722 sz = numa_enforce_memory_limit(base, size); 723 if (sz) 724 memblock_set_node(base, sz, 725 &memblock.memory, nid); 726 } while (--ranges); 727 } 728 } 729 730 static int __init parse_numa_properties(void) 731 { 732 struct device_node *memory; 733 int default_nid = 0; 734 unsigned long i; 735 736 if (numa_enabled == 0) { 737 printk(KERN_WARNING "NUMA disabled by user\n"); 738 return -1; 739 } 740 741 min_common_depth = find_min_common_depth(); 742 743 if (min_common_depth < 0) 744 return min_common_depth; 745 746 dbg("NUMA associativity depth for CPU/Memory: %d\n", min_common_depth); 747 748 /* 749 * Even though we connect cpus to numa domains later in SMP 750 * init, we need to know the node ids now. This is because 751 * each node to be onlined must have NODE_DATA etc backing it. 752 */ 753 for_each_present_cpu(i) { 754 struct device_node *cpu; 755 int nid; 756 757 cpu = of_get_cpu_node(i, NULL); 758 BUG_ON(!cpu); 759 nid = of_node_to_nid_single(cpu); 760 of_node_put(cpu); 761 762 /* 763 * Don't fall back to default_nid yet -- we will plug 764 * cpus into nodes once the memory scan has discovered 765 * the topology. 766 */ 767 if (nid < 0) 768 continue; 769 node_set_online(nid); 770 } 771 772 get_n_mem_cells(&n_mem_addr_cells, &n_mem_size_cells); 773 774 for_each_node_by_type(memory, "memory") { 775 unsigned long start; 776 unsigned long size; 777 int nid; 778 int ranges; 779 const __be32 *memcell_buf; 780 unsigned int len; 781 782 memcell_buf = of_get_property(memory, 783 "linux,usable-memory", &len); 784 if (!memcell_buf || len <= 0) 785 memcell_buf = of_get_property(memory, "reg", &len); 786 if (!memcell_buf || len <= 0) 787 continue; 788 789 /* ranges in cell */ 790 ranges = (len >> 2) / (n_mem_addr_cells + n_mem_size_cells); 791 new_range: 792 /* these are order-sensitive, and modify the buffer pointer */ 793 start = read_n_cells(n_mem_addr_cells, &memcell_buf); 794 size = read_n_cells(n_mem_size_cells, &memcell_buf); 795 796 /* 797 * Assumption: either all memory nodes or none will 798 * have associativity properties. If none, then 799 * everything goes to default_nid. 800 */ 801 nid = of_node_to_nid_single(memory); 802 if (nid < 0) 803 nid = default_nid; 804 805 fake_numa_create_new_node(((start + size) >> PAGE_SHIFT), &nid); 806 node_set_online(nid); 807 808 if (!(size = numa_enforce_memory_limit(start, size))) { 809 if (--ranges) 810 goto new_range; 811 else 812 continue; 813 } 814 815 memblock_set_node(start, size, &memblock.memory, nid); 816 817 if (--ranges) 818 goto new_range; 819 } 820 821 /* 822 * Now do the same thing for each MEMBLOCK listed in the 823 * ibm,dynamic-memory property in the 824 * ibm,dynamic-reconfiguration-memory node. 825 */ 826 memory = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory"); 827 if (memory) 828 parse_drconf_memory(memory); 829 830 return 0; 831 } 832 833 static void __init setup_nonnuma(void) 834 { 835 unsigned long top_of_ram = memblock_end_of_DRAM(); 836 unsigned long total_ram = memblock_phys_mem_size(); 837 unsigned long start_pfn, end_pfn; 838 unsigned int nid = 0; 839 struct memblock_region *reg; 840 841 printk(KERN_DEBUG "Top of RAM: 0x%lx, Total RAM: 0x%lx\n", 842 top_of_ram, total_ram); 843 printk(KERN_DEBUG "Memory hole size: %ldMB\n", 844 (top_of_ram - total_ram) >> 20); 845 846 for_each_memblock(memory, reg) { 847 start_pfn = memblock_region_memory_base_pfn(reg); 848 end_pfn = memblock_region_memory_end_pfn(reg); 849 850 fake_numa_create_new_node(end_pfn, &nid); 851 memblock_set_node(PFN_PHYS(start_pfn), 852 PFN_PHYS(end_pfn - start_pfn), 853 &memblock.memory, nid); 854 node_set_online(nid); 855 } 856 } 857 858 void __init dump_numa_cpu_topology(void) 859 { 860 unsigned int node; 861 unsigned int cpu, count; 862 863 if (min_common_depth == -1 || !numa_enabled) 864 return; 865 866 for_each_online_node(node) { 867 printk(KERN_DEBUG "Node %d CPUs:", node); 868 869 count = 0; 870 /* 871 * If we used a CPU iterator here we would miss printing 872 * the holes in the cpumap. 873 */ 874 for (cpu = 0; cpu < nr_cpu_ids; cpu++) { 875 if (cpumask_test_cpu(cpu, 876 node_to_cpumask_map[node])) { 877 if (count == 0) 878 printk(" %u", cpu); 879 ++count; 880 } else { 881 if (count > 1) 882 printk("-%u", cpu - 1); 883 count = 0; 884 } 885 } 886 887 if (count > 1) 888 printk("-%u", nr_cpu_ids - 1); 889 printk("\n"); 890 } 891 } 892 893 static void __init dump_numa_memory_topology(void) 894 { 895 unsigned int node; 896 unsigned int count; 897 898 if (min_common_depth == -1 || !numa_enabled) 899 return; 900 901 for_each_online_node(node) { 902 unsigned long i; 903 904 printk(KERN_DEBUG "Node %d Memory:", node); 905 906 count = 0; 907 908 for (i = 0; i < memblock_end_of_DRAM(); 909 i += (1 << SECTION_SIZE_BITS)) { 910 if (early_pfn_to_nid(i >> PAGE_SHIFT) == node) { 911 if (count == 0) 912 printk(" 0x%lx", i); 913 ++count; 914 } else { 915 if (count > 0) 916 printk("-0x%lx", i); 917 count = 0; 918 } 919 } 920 921 if (count > 0) 922 printk("-0x%lx", i); 923 printk("\n"); 924 } 925 } 926 927 /* 928 * Allocate some memory, satisfying the memblock or bootmem allocator where 929 * required. nid is the preferred node and end is the physical address of 930 * the highest address in the node. 931 * 932 * Returns the virtual address of the memory. 933 */ 934 static void __init *careful_zallocation(int nid, unsigned long size, 935 unsigned long align, 936 unsigned long end_pfn) 937 { 938 void *ret; 939 int new_nid; 940 unsigned long ret_paddr; 941 942 ret_paddr = __memblock_alloc_base(size, align, end_pfn << PAGE_SHIFT); 943 944 /* retry over all memory */ 945 if (!ret_paddr) 946 ret_paddr = __memblock_alloc_base(size, align, memblock_end_of_DRAM()); 947 948 if (!ret_paddr) 949 panic("numa.c: cannot allocate %lu bytes for node %d", 950 size, nid); 951 952 ret = __va(ret_paddr); 953 954 /* 955 * We initialize the nodes in numeric order: 0, 1, 2... 956 * and hand over control from the MEMBLOCK allocator to the 957 * bootmem allocator. If this function is called for 958 * node 5, then we know that all nodes <5 are using the 959 * bootmem allocator instead of the MEMBLOCK allocator. 960 * 961 * So, check the nid from which this allocation came 962 * and double check to see if we need to use bootmem 963 * instead of the MEMBLOCK. We don't free the MEMBLOCK memory 964 * since it would be useless. 965 */ 966 new_nid = early_pfn_to_nid(ret_paddr >> PAGE_SHIFT); 967 if (new_nid < nid) { 968 ret = __alloc_bootmem_node(NODE_DATA(new_nid), 969 size, align, 0); 970 971 dbg("alloc_bootmem %p %lx\n", ret, size); 972 } 973 974 memset(ret, 0, size); 975 return ret; 976 } 977 978 static struct notifier_block ppc64_numa_nb = { 979 .notifier_call = cpu_numa_callback, 980 .priority = 1 /* Must run before sched domains notifier. */ 981 }; 982 983 static void __init mark_reserved_regions_for_nid(int nid) 984 { 985 struct pglist_data *node = NODE_DATA(nid); 986 struct memblock_region *reg; 987 988 for_each_memblock(reserved, reg) { 989 unsigned long physbase = reg->base; 990 unsigned long size = reg->size; 991 unsigned long start_pfn = physbase >> PAGE_SHIFT; 992 unsigned long end_pfn = PFN_UP(physbase + size); 993 struct node_active_region node_ar; 994 unsigned long node_end_pfn = pgdat_end_pfn(node); 995 996 /* 997 * Check to make sure that this memblock.reserved area is 998 * within the bounds of the node that we care about. 999 * Checking the nid of the start and end points is not 1000 * sufficient because the reserved area could span the 1001 * entire node. 1002 */ 1003 if (end_pfn <= node->node_start_pfn || 1004 start_pfn >= node_end_pfn) 1005 continue; 1006 1007 get_node_active_region(start_pfn, &node_ar); 1008 while (start_pfn < end_pfn && 1009 node_ar.start_pfn < node_ar.end_pfn) { 1010 unsigned long reserve_size = size; 1011 /* 1012 * if reserved region extends past active region 1013 * then trim size to active region 1014 */ 1015 if (end_pfn > node_ar.end_pfn) 1016 reserve_size = (node_ar.end_pfn << PAGE_SHIFT) 1017 - physbase; 1018 /* 1019 * Only worry about *this* node, others may not 1020 * yet have valid NODE_DATA(). 1021 */ 1022 if (node_ar.nid == nid) { 1023 dbg("reserve_bootmem %lx %lx nid=%d\n", 1024 physbase, reserve_size, node_ar.nid); 1025 reserve_bootmem_node(NODE_DATA(node_ar.nid), 1026 physbase, reserve_size, 1027 BOOTMEM_DEFAULT); 1028 } 1029 /* 1030 * if reserved region is contained in the active region 1031 * then done. 1032 */ 1033 if (end_pfn <= node_ar.end_pfn) 1034 break; 1035 1036 /* 1037 * reserved region extends past the active region 1038 * get next active region that contains this 1039 * reserved region 1040 */ 1041 start_pfn = node_ar.end_pfn; 1042 physbase = start_pfn << PAGE_SHIFT; 1043 size = size - reserve_size; 1044 get_node_active_region(start_pfn, &node_ar); 1045 } 1046 } 1047 } 1048 1049 1050 void __init do_init_bootmem(void) 1051 { 1052 int nid; 1053 1054 min_low_pfn = 0; 1055 max_low_pfn = memblock_end_of_DRAM() >> PAGE_SHIFT; 1056 max_pfn = max_low_pfn; 1057 1058 if (parse_numa_properties()) 1059 setup_nonnuma(); 1060 else 1061 dump_numa_memory_topology(); 1062 1063 for_each_online_node(nid) { 1064 unsigned long start_pfn, end_pfn; 1065 void *bootmem_vaddr; 1066 unsigned long bootmap_pages; 1067 1068 get_pfn_range_for_nid(nid, &start_pfn, &end_pfn); 1069 1070 /* 1071 * Allocate the node structure node local if possible 1072 * 1073 * Be careful moving this around, as it relies on all 1074 * previous nodes' bootmem to be initialized and have 1075 * all reserved areas marked. 1076 */ 1077 NODE_DATA(nid) = careful_zallocation(nid, 1078 sizeof(struct pglist_data), 1079 SMP_CACHE_BYTES, end_pfn); 1080 1081 dbg("node %d\n", nid); 1082 dbg("NODE_DATA() = %p\n", NODE_DATA(nid)); 1083 1084 NODE_DATA(nid)->bdata = &bootmem_node_data[nid]; 1085 NODE_DATA(nid)->node_start_pfn = start_pfn; 1086 NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn; 1087 1088 if (NODE_DATA(nid)->node_spanned_pages == 0) 1089 continue; 1090 1091 dbg("start_paddr = %lx\n", start_pfn << PAGE_SHIFT); 1092 dbg("end_paddr = %lx\n", end_pfn << PAGE_SHIFT); 1093 1094 bootmap_pages = bootmem_bootmap_pages(end_pfn - start_pfn); 1095 bootmem_vaddr = careful_zallocation(nid, 1096 bootmap_pages << PAGE_SHIFT, 1097 PAGE_SIZE, end_pfn); 1098 1099 dbg("bootmap_vaddr = %p\n", bootmem_vaddr); 1100 1101 init_bootmem_node(NODE_DATA(nid), 1102 __pa(bootmem_vaddr) >> PAGE_SHIFT, 1103 start_pfn, end_pfn); 1104 1105 free_bootmem_with_active_regions(nid, end_pfn); 1106 /* 1107 * Be very careful about moving this around. Future 1108 * calls to careful_zallocation() depend on this getting 1109 * done correctly. 1110 */ 1111 mark_reserved_regions_for_nid(nid); 1112 sparse_memory_present_with_active_regions(nid); 1113 } 1114 1115 init_bootmem_done = 1; 1116 1117 /* 1118 * Now bootmem is initialised we can create the node to cpumask 1119 * lookup tables and setup the cpu callback to populate them. 1120 */ 1121 setup_node_to_cpumask_map(); 1122 1123 reset_numa_cpu_lookup_table(); 1124 register_cpu_notifier(&ppc64_numa_nb); 1125 cpu_numa_callback(&ppc64_numa_nb, CPU_UP_PREPARE, 1126 (void *)(unsigned long)boot_cpuid); 1127 } 1128 1129 void __init paging_init(void) 1130 { 1131 unsigned long max_zone_pfns[MAX_NR_ZONES]; 1132 memset(max_zone_pfns, 0, sizeof(max_zone_pfns)); 1133 max_zone_pfns[ZONE_DMA] = memblock_end_of_DRAM() >> PAGE_SHIFT; 1134 free_area_init_nodes(max_zone_pfns); 1135 } 1136 1137 static int __init early_numa(char *p) 1138 { 1139 if (!p) 1140 return 0; 1141 1142 if (strstr(p, "off")) 1143 numa_enabled = 0; 1144 1145 if (strstr(p, "debug")) 1146 numa_debug = 1; 1147 1148 p = strstr(p, "fake="); 1149 if (p) 1150 cmdline = p + strlen("fake="); 1151 1152 return 0; 1153 } 1154 early_param("numa", early_numa); 1155 1156 #ifdef CONFIG_MEMORY_HOTPLUG 1157 /* 1158 * Find the node associated with a hot added memory section for 1159 * memory represented in the device tree by the property 1160 * ibm,dynamic-reconfiguration-memory/ibm,dynamic-memory. 1161 */ 1162 static int hot_add_drconf_scn_to_nid(struct device_node *memory, 1163 unsigned long scn_addr) 1164 { 1165 const __be32 *dm; 1166 unsigned int drconf_cell_cnt, rc; 1167 unsigned long lmb_size; 1168 struct assoc_arrays aa; 1169 int nid = -1; 1170 1171 drconf_cell_cnt = of_get_drconf_memory(memory, &dm); 1172 if (!drconf_cell_cnt) 1173 return -1; 1174 1175 lmb_size = of_get_lmb_size(memory); 1176 if (!lmb_size) 1177 return -1; 1178 1179 rc = of_get_assoc_arrays(memory, &aa); 1180 if (rc) 1181 return -1; 1182 1183 for (; drconf_cell_cnt != 0; --drconf_cell_cnt) { 1184 struct of_drconf_cell drmem; 1185 1186 read_drconf_cell(&drmem, &dm); 1187 1188 /* skip this block if it is reserved or not assigned to 1189 * this partition */ 1190 if ((drmem.flags & DRCONF_MEM_RESERVED) 1191 || !(drmem.flags & DRCONF_MEM_ASSIGNED)) 1192 continue; 1193 1194 if ((scn_addr < drmem.base_addr) 1195 || (scn_addr >= (drmem.base_addr + lmb_size))) 1196 continue; 1197 1198 nid = of_drconf_to_nid_single(&drmem, &aa); 1199 break; 1200 } 1201 1202 return nid; 1203 } 1204 1205 /* 1206 * Find the node associated with a hot added memory section for memory 1207 * represented in the device tree as a node (i.e. memory@XXXX) for 1208 * each memblock. 1209 */ 1210 static int hot_add_node_scn_to_nid(unsigned long scn_addr) 1211 { 1212 struct device_node *memory; 1213 int nid = -1; 1214 1215 for_each_node_by_type(memory, "memory") { 1216 unsigned long start, size; 1217 int ranges; 1218 const __be32 *memcell_buf; 1219 unsigned int len; 1220 1221 memcell_buf = of_get_property(memory, "reg", &len); 1222 if (!memcell_buf || len <= 0) 1223 continue; 1224 1225 /* ranges in cell */ 1226 ranges = (len >> 2) / (n_mem_addr_cells + n_mem_size_cells); 1227 1228 while (ranges--) { 1229 start = read_n_cells(n_mem_addr_cells, &memcell_buf); 1230 size = read_n_cells(n_mem_size_cells, &memcell_buf); 1231 1232 if ((scn_addr < start) || (scn_addr >= (start + size))) 1233 continue; 1234 1235 nid = of_node_to_nid_single(memory); 1236 break; 1237 } 1238 1239 if (nid >= 0) 1240 break; 1241 } 1242 1243 of_node_put(memory); 1244 1245 return nid; 1246 } 1247 1248 /* 1249 * Find the node associated with a hot added memory section. Section 1250 * corresponds to a SPARSEMEM section, not an MEMBLOCK. It is assumed that 1251 * sections are fully contained within a single MEMBLOCK. 1252 */ 1253 int hot_add_scn_to_nid(unsigned long scn_addr) 1254 { 1255 struct device_node *memory = NULL; 1256 int nid, found = 0; 1257 1258 if (!numa_enabled || (min_common_depth < 0)) 1259 return first_online_node; 1260 1261 memory = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory"); 1262 if (memory) { 1263 nid = hot_add_drconf_scn_to_nid(memory, scn_addr); 1264 of_node_put(memory); 1265 } else { 1266 nid = hot_add_node_scn_to_nid(scn_addr); 1267 } 1268 1269 if (nid < 0 || !node_online(nid)) 1270 nid = first_online_node; 1271 1272 if (NODE_DATA(nid)->node_spanned_pages) 1273 return nid; 1274 1275 for_each_online_node(nid) { 1276 if (NODE_DATA(nid)->node_spanned_pages) { 1277 found = 1; 1278 break; 1279 } 1280 } 1281 1282 BUG_ON(!found); 1283 return nid; 1284 } 1285 1286 static u64 hot_add_drconf_memory_max(void) 1287 { 1288 struct device_node *memory = NULL; 1289 unsigned int drconf_cell_cnt = 0; 1290 u64 lmb_size = 0; 1291 const __be32 *dm = NULL; 1292 1293 memory = of_find_node_by_path("/ibm,dynamic-reconfiguration-memory"); 1294 if (memory) { 1295 drconf_cell_cnt = of_get_drconf_memory(memory, &dm); 1296 lmb_size = of_get_lmb_size(memory); 1297 of_node_put(memory); 1298 } 1299 return lmb_size * drconf_cell_cnt; 1300 } 1301 1302 /* 1303 * memory_hotplug_max - return max address of memory that may be added 1304 * 1305 * This is currently only used on systems that support drconfig memory 1306 * hotplug. 1307 */ 1308 u64 memory_hotplug_max(void) 1309 { 1310 return max(hot_add_drconf_memory_max(), memblock_end_of_DRAM()); 1311 } 1312 #endif /* CONFIG_MEMORY_HOTPLUG */ 1313 1314 /* Virtual Processor Home Node (VPHN) support */ 1315 #ifdef CONFIG_PPC_SPLPAR 1316 struct topology_update_data { 1317 struct topology_update_data *next; 1318 unsigned int cpu; 1319 int old_nid; 1320 int new_nid; 1321 }; 1322 1323 static u8 vphn_cpu_change_counts[NR_CPUS][MAX_DISTANCE_REF_POINTS]; 1324 static cpumask_t cpu_associativity_changes_mask; 1325 static int vphn_enabled; 1326 static int prrn_enabled; 1327 static void reset_topology_timer(void); 1328 1329 /* 1330 * Store the current values of the associativity change counters in the 1331 * hypervisor. 1332 */ 1333 static void setup_cpu_associativity_change_counters(void) 1334 { 1335 int cpu; 1336 1337 /* The VPHN feature supports a maximum of 8 reference points */ 1338 BUILD_BUG_ON(MAX_DISTANCE_REF_POINTS > 8); 1339 1340 for_each_possible_cpu(cpu) { 1341 int i; 1342 u8 *counts = vphn_cpu_change_counts[cpu]; 1343 volatile u8 *hypervisor_counts = lppaca[cpu].vphn_assoc_counts; 1344 1345 for (i = 0; i < distance_ref_points_depth; i++) 1346 counts[i] = hypervisor_counts[i]; 1347 } 1348 } 1349 1350 /* 1351 * The hypervisor maintains a set of 8 associativity change counters in 1352 * the VPA of each cpu that correspond to the associativity levels in the 1353 * ibm,associativity-reference-points property. When an associativity 1354 * level changes, the corresponding counter is incremented. 1355 * 1356 * Set a bit in cpu_associativity_changes_mask for each cpu whose home 1357 * node associativity levels have changed. 1358 * 1359 * Returns the number of cpus with unhandled associativity changes. 1360 */ 1361 static int update_cpu_associativity_changes_mask(void) 1362 { 1363 int cpu; 1364 cpumask_t *changes = &cpu_associativity_changes_mask; 1365 1366 for_each_possible_cpu(cpu) { 1367 int i, changed = 0; 1368 u8 *counts = vphn_cpu_change_counts[cpu]; 1369 volatile u8 *hypervisor_counts = lppaca[cpu].vphn_assoc_counts; 1370 1371 for (i = 0; i < distance_ref_points_depth; i++) { 1372 if (hypervisor_counts[i] != counts[i]) { 1373 counts[i] = hypervisor_counts[i]; 1374 changed = 1; 1375 } 1376 } 1377 if (changed) { 1378 cpumask_or(changes, changes, cpu_sibling_mask(cpu)); 1379 cpu = cpu_last_thread_sibling(cpu); 1380 } 1381 } 1382 1383 return cpumask_weight(changes); 1384 } 1385 1386 /* 1387 * 6 64-bit registers unpacked into 12 32-bit associativity values. To form 1388 * the complete property we have to add the length in the first cell. 1389 */ 1390 #define VPHN_ASSOC_BUFSIZE (6*sizeof(u64)/sizeof(u32) + 1) 1391 1392 /* 1393 * Convert the associativity domain numbers returned from the hypervisor 1394 * to the sequence they would appear in the ibm,associativity property. 1395 */ 1396 static int vphn_unpack_associativity(const long *packed, __be32 *unpacked) 1397 { 1398 int i, nr_assoc_doms = 0; 1399 const __be16 *field = (const __be16 *) packed; 1400 1401 #define VPHN_FIELD_UNUSED (0xffff) 1402 #define VPHN_FIELD_MSB (0x8000) 1403 #define VPHN_FIELD_MASK (~VPHN_FIELD_MSB) 1404 1405 for (i = 1; i < VPHN_ASSOC_BUFSIZE; i++) { 1406 if (be16_to_cpup(field) == VPHN_FIELD_UNUSED) { 1407 /* All significant fields processed, and remaining 1408 * fields contain the reserved value of all 1's. 1409 * Just store them. 1410 */ 1411 unpacked[i] = *((__be32 *)field); 1412 field += 2; 1413 } else if (be16_to_cpup(field) & VPHN_FIELD_MSB) { 1414 /* Data is in the lower 15 bits of this field */ 1415 unpacked[i] = cpu_to_be32( 1416 be16_to_cpup(field) & VPHN_FIELD_MASK); 1417 field++; 1418 nr_assoc_doms++; 1419 } else { 1420 /* Data is in the lower 15 bits of this field 1421 * concatenated with the next 16 bit field 1422 */ 1423 unpacked[i] = *((__be32 *)field); 1424 field += 2; 1425 nr_assoc_doms++; 1426 } 1427 } 1428 1429 /* The first cell contains the length of the property */ 1430 unpacked[0] = cpu_to_be32(nr_assoc_doms); 1431 1432 return nr_assoc_doms; 1433 } 1434 1435 /* 1436 * Retrieve the new associativity information for a virtual processor's 1437 * home node. 1438 */ 1439 static long hcall_vphn(unsigned long cpu, __be32 *associativity) 1440 { 1441 long rc; 1442 long retbuf[PLPAR_HCALL9_BUFSIZE] = {0}; 1443 u64 flags = 1; 1444 int hwcpu = get_hard_smp_processor_id(cpu); 1445 1446 rc = plpar_hcall9(H_HOME_NODE_ASSOCIATIVITY, retbuf, flags, hwcpu); 1447 vphn_unpack_associativity(retbuf, associativity); 1448 1449 return rc; 1450 } 1451 1452 static long vphn_get_associativity(unsigned long cpu, 1453 __be32 *associativity) 1454 { 1455 long rc; 1456 1457 rc = hcall_vphn(cpu, associativity); 1458 1459 switch (rc) { 1460 case H_FUNCTION: 1461 printk(KERN_INFO 1462 "VPHN is not supported. Disabling polling...\n"); 1463 stop_topology_update(); 1464 break; 1465 case H_HARDWARE: 1466 printk(KERN_ERR 1467 "hcall_vphn() experienced a hardware fault " 1468 "preventing VPHN. Disabling polling...\n"); 1469 stop_topology_update(); 1470 } 1471 1472 return rc; 1473 } 1474 1475 /* 1476 * Update the CPU maps and sysfs entries for a single CPU when its NUMA 1477 * characteristics change. This function doesn't perform any locking and is 1478 * only safe to call from stop_machine(). 1479 */ 1480 static int update_cpu_topology(void *data) 1481 { 1482 struct topology_update_data *update; 1483 unsigned long cpu; 1484 1485 if (!data) 1486 return -EINVAL; 1487 1488 cpu = smp_processor_id(); 1489 1490 for (update = data; update; update = update->next) { 1491 if (cpu != update->cpu) 1492 continue; 1493 1494 unmap_cpu_from_node(update->cpu); 1495 map_cpu_to_node(update->cpu, update->new_nid); 1496 vdso_getcpu_init(); 1497 } 1498 1499 return 0; 1500 } 1501 1502 static int update_lookup_table(void *data) 1503 { 1504 struct topology_update_data *update; 1505 1506 if (!data) 1507 return -EINVAL; 1508 1509 /* 1510 * Upon topology update, the numa-cpu lookup table needs to be updated 1511 * for all threads in the core, including offline CPUs, to ensure that 1512 * future hotplug operations respect the cpu-to-node associativity 1513 * properly. 1514 */ 1515 for (update = data; update; update = update->next) { 1516 int nid, base, j; 1517 1518 nid = update->new_nid; 1519 base = cpu_first_thread_sibling(update->cpu); 1520 1521 for (j = 0; j < threads_per_core; j++) { 1522 update_numa_cpu_lookup_table(base + j, nid); 1523 } 1524 } 1525 1526 return 0; 1527 } 1528 1529 /* 1530 * Update the node maps and sysfs entries for each cpu whose home node 1531 * has changed. Returns 1 when the topology has changed, and 0 otherwise. 1532 */ 1533 int arch_update_cpu_topology(void) 1534 { 1535 unsigned int cpu, sibling, changed = 0; 1536 struct topology_update_data *updates, *ud; 1537 __be32 associativity[VPHN_ASSOC_BUFSIZE] = {0}; 1538 cpumask_t updated_cpus; 1539 struct device *dev; 1540 int weight, new_nid, i = 0; 1541 1542 weight = cpumask_weight(&cpu_associativity_changes_mask); 1543 if (!weight) 1544 return 0; 1545 1546 updates = kzalloc(weight * (sizeof(*updates)), GFP_KERNEL); 1547 if (!updates) 1548 return 0; 1549 1550 cpumask_clear(&updated_cpus); 1551 1552 for_each_cpu(cpu, &cpu_associativity_changes_mask) { 1553 /* 1554 * If siblings aren't flagged for changes, updates list 1555 * will be too short. Skip on this update and set for next 1556 * update. 1557 */ 1558 if (!cpumask_subset(cpu_sibling_mask(cpu), 1559 &cpu_associativity_changes_mask)) { 1560 pr_info("Sibling bits not set for associativity " 1561 "change, cpu%d\n", cpu); 1562 cpumask_or(&cpu_associativity_changes_mask, 1563 &cpu_associativity_changes_mask, 1564 cpu_sibling_mask(cpu)); 1565 cpu = cpu_last_thread_sibling(cpu); 1566 continue; 1567 } 1568 1569 /* Use associativity from first thread for all siblings */ 1570 vphn_get_associativity(cpu, associativity); 1571 new_nid = associativity_to_nid(associativity); 1572 if (new_nid < 0 || !node_online(new_nid)) 1573 new_nid = first_online_node; 1574 1575 if (new_nid == numa_cpu_lookup_table[cpu]) { 1576 cpumask_andnot(&cpu_associativity_changes_mask, 1577 &cpu_associativity_changes_mask, 1578 cpu_sibling_mask(cpu)); 1579 cpu = cpu_last_thread_sibling(cpu); 1580 continue; 1581 } 1582 1583 for_each_cpu(sibling, cpu_sibling_mask(cpu)) { 1584 ud = &updates[i++]; 1585 ud->cpu = sibling; 1586 ud->new_nid = new_nid; 1587 ud->old_nid = numa_cpu_lookup_table[sibling]; 1588 cpumask_set_cpu(sibling, &updated_cpus); 1589 if (i < weight) 1590 ud->next = &updates[i]; 1591 } 1592 cpu = cpu_last_thread_sibling(cpu); 1593 } 1594 1595 /* 1596 * In cases where we have nothing to update (because the updates list 1597 * is too short or because the new topology is same as the old one), 1598 * skip invoking update_cpu_topology() via stop-machine(). This is 1599 * necessary (and not just a fast-path optimization) since stop-machine 1600 * can end up electing a random CPU to run update_cpu_topology(), and 1601 * thus trick us into setting up incorrect cpu-node mappings (since 1602 * 'updates' is kzalloc()'ed). 1603 * 1604 * And for the similar reason, we will skip all the following updating. 1605 */ 1606 if (!cpumask_weight(&updated_cpus)) 1607 goto out; 1608 1609 stop_machine(update_cpu_topology, &updates[0], &updated_cpus); 1610 1611 /* 1612 * Update the numa-cpu lookup table with the new mappings, even for 1613 * offline CPUs. It is best to perform this update from the stop- 1614 * machine context. 1615 */ 1616 stop_machine(update_lookup_table, &updates[0], 1617 cpumask_of(raw_smp_processor_id())); 1618 1619 for (ud = &updates[0]; ud; ud = ud->next) { 1620 unregister_cpu_under_node(ud->cpu, ud->old_nid); 1621 register_cpu_under_node(ud->cpu, ud->new_nid); 1622 1623 dev = get_cpu_device(ud->cpu); 1624 if (dev) 1625 kobject_uevent(&dev->kobj, KOBJ_CHANGE); 1626 cpumask_clear_cpu(ud->cpu, &cpu_associativity_changes_mask); 1627 changed = 1; 1628 } 1629 1630 out: 1631 kfree(updates); 1632 return changed; 1633 } 1634 1635 static void topology_work_fn(struct work_struct *work) 1636 { 1637 rebuild_sched_domains(); 1638 } 1639 static DECLARE_WORK(topology_work, topology_work_fn); 1640 1641 static void topology_schedule_update(void) 1642 { 1643 schedule_work(&topology_work); 1644 } 1645 1646 static void topology_timer_fn(unsigned long ignored) 1647 { 1648 if (prrn_enabled && cpumask_weight(&cpu_associativity_changes_mask)) 1649 topology_schedule_update(); 1650 else if (vphn_enabled) { 1651 if (update_cpu_associativity_changes_mask() > 0) 1652 topology_schedule_update(); 1653 reset_topology_timer(); 1654 } 1655 } 1656 static struct timer_list topology_timer = 1657 TIMER_INITIALIZER(topology_timer_fn, 0, 0); 1658 1659 static void reset_topology_timer(void) 1660 { 1661 topology_timer.data = 0; 1662 topology_timer.expires = jiffies + 60 * HZ; 1663 mod_timer(&topology_timer, topology_timer.expires); 1664 } 1665 1666 #ifdef CONFIG_SMP 1667 1668 static void stage_topology_update(int core_id) 1669 { 1670 cpumask_or(&cpu_associativity_changes_mask, 1671 &cpu_associativity_changes_mask, cpu_sibling_mask(core_id)); 1672 reset_topology_timer(); 1673 } 1674 1675 static int dt_update_callback(struct notifier_block *nb, 1676 unsigned long action, void *data) 1677 { 1678 struct of_prop_reconfig *update; 1679 int rc = NOTIFY_DONE; 1680 1681 switch (action) { 1682 case OF_RECONFIG_UPDATE_PROPERTY: 1683 update = (struct of_prop_reconfig *)data; 1684 if (!of_prop_cmp(update->dn->type, "cpu") && 1685 !of_prop_cmp(update->prop->name, "ibm,associativity")) { 1686 u32 core_id; 1687 of_property_read_u32(update->dn, "reg", &core_id); 1688 stage_topology_update(core_id); 1689 rc = NOTIFY_OK; 1690 } 1691 break; 1692 } 1693 1694 return rc; 1695 } 1696 1697 static struct notifier_block dt_update_nb = { 1698 .notifier_call = dt_update_callback, 1699 }; 1700 1701 #endif 1702 1703 /* 1704 * Start polling for associativity changes. 1705 */ 1706 int start_topology_update(void) 1707 { 1708 int rc = 0; 1709 1710 if (firmware_has_feature(FW_FEATURE_PRRN)) { 1711 if (!prrn_enabled) { 1712 prrn_enabled = 1; 1713 vphn_enabled = 0; 1714 #ifdef CONFIG_SMP 1715 rc = of_reconfig_notifier_register(&dt_update_nb); 1716 #endif 1717 } 1718 } else if (firmware_has_feature(FW_FEATURE_VPHN) && 1719 lppaca_shared_proc(get_lppaca())) { 1720 if (!vphn_enabled) { 1721 prrn_enabled = 0; 1722 vphn_enabled = 1; 1723 setup_cpu_associativity_change_counters(); 1724 init_timer_deferrable(&topology_timer); 1725 reset_topology_timer(); 1726 } 1727 } 1728 1729 return rc; 1730 } 1731 1732 /* 1733 * Disable polling for VPHN associativity changes. 1734 */ 1735 int stop_topology_update(void) 1736 { 1737 int rc = 0; 1738 1739 if (prrn_enabled) { 1740 prrn_enabled = 0; 1741 #ifdef CONFIG_SMP 1742 rc = of_reconfig_notifier_unregister(&dt_update_nb); 1743 #endif 1744 } else if (vphn_enabled) { 1745 vphn_enabled = 0; 1746 rc = del_timer_sync(&topology_timer); 1747 } 1748 1749 return rc; 1750 } 1751 1752 int prrn_is_enabled(void) 1753 { 1754 return prrn_enabled; 1755 } 1756 1757 static int topology_read(struct seq_file *file, void *v) 1758 { 1759 if (vphn_enabled || prrn_enabled) 1760 seq_puts(file, "on\n"); 1761 else 1762 seq_puts(file, "off\n"); 1763 1764 return 0; 1765 } 1766 1767 static int topology_open(struct inode *inode, struct file *file) 1768 { 1769 return single_open(file, topology_read, NULL); 1770 } 1771 1772 static ssize_t topology_write(struct file *file, const char __user *buf, 1773 size_t count, loff_t *off) 1774 { 1775 char kbuf[4]; /* "on" or "off" plus null. */ 1776 int read_len; 1777 1778 read_len = count < 3 ? count : 3; 1779 if (copy_from_user(kbuf, buf, read_len)) 1780 return -EINVAL; 1781 1782 kbuf[read_len] = '\0'; 1783 1784 if (!strncmp(kbuf, "on", 2)) 1785 start_topology_update(); 1786 else if (!strncmp(kbuf, "off", 3)) 1787 stop_topology_update(); 1788 else 1789 return -EINVAL; 1790 1791 return count; 1792 } 1793 1794 static const struct file_operations topology_ops = { 1795 .read = seq_read, 1796 .write = topology_write, 1797 .open = topology_open, 1798 .release = single_release 1799 }; 1800 1801 static int topology_update_init(void) 1802 { 1803 start_topology_update(); 1804 proc_create("powerpc/topology_updates", 0644, NULL, &topology_ops); 1805 1806 return 0; 1807 } 1808 device_initcall(topology_update_init); 1809 #endif /* CONFIG_PPC_SPLPAR */ 1810