arch/powerpc/mm/numa.c

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