arch/powerpc/platforms/pseries/hotplug-cpu.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * pseries CPU Hotplug infrastructure.
   4  *
   5  * Split out from arch/powerpc/platforms/pseries/setup.c
   6  *  arch/powerpc/kernel/rtas.c, and arch/powerpc/platforms/pseries/smp.c
   7  *
   8  * Peter Bergner, IBM   March 2001.
   9  * Copyright (C) 2001 IBM.
  10  * Dave Engebretsen, Peter Bergner, and
  11  * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com
  12  * Plus various changes from other IBM teams...
  13  *
  14  * Copyright (C) 2006 Michael Ellerman, IBM Corporation
  15  */
  16
  17 #define pr_fmt(fmt)     "pseries-hotplug-cpu: " fmt
  18
  19 #include <linux/kernel.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/delay.h>
  22 #include <linux/sched.h>        /* for idle_task_exit */
  23 #include <linux/sched/hotplug.h>
  24 #include <linux/cpu.h>
  25 #include <linux/of.h>
  26 #include <linux/slab.h>
  27 #include <asm/prom.h>
  28 #include <asm/rtas.h>
  29 #include <asm/firmware.h>
  30 #include <asm/machdep.h>
  31 #include <asm/vdso_datapage.h>
  32 #include <asm/xics.h>
  33 #include <asm/xive.h>
  34 #include <asm/plpar_wrappers.h>
  35 #include <asm/topology.h>
  36
  37 #include "pseries.h"
  38
  39 /* This version can't take the spinlock, because it never returns */
  40 static int rtas_stop_self_token = RTAS_UNKNOWN_SERVICE;
  41
  42 static void rtas_stop_self(void)
  43 {
  44         static struct rtas_args args;
  45
  46         local_irq_disable();
  47
  48         BUG_ON(rtas_stop_self_token == RTAS_UNKNOWN_SERVICE);
  49
  50         rtas_call_unlocked(&args, rtas_stop_self_token, 0, 1, NULL);
  51
  52         panic("Alas, I survived.\n");
  53 }
  54
  55 static void pseries_cpu_offline_self(void)
  56 {
  57         unsigned int hwcpu = hard_smp_processor_id();
  58
  59         local_irq_disable();
  60         idle_task_exit();
  61         if (xive_enabled())
  62                 xive_teardown_cpu();
  63         else
  64                 xics_teardown_cpu();
  65
  66         unregister_slb_shadow(hwcpu);
  67         rtas_stop_self();
  68
  69         /* Should never get here... */
  70         BUG();
  71         for(;;);
  72 }
  73
  74 static int pseries_cpu_disable(void)
  75 {
  76         int cpu = smp_processor_id();
  77
  78         set_cpu_online(cpu, false);
  79         vdso_data->processorCount--;
  80
  81         /*fix boot_cpuid here*/
  82         if (cpu == boot_cpuid)
  83                 boot_cpuid = cpumask_any(cpu_online_mask);
  84
  85         /* FIXME: abstract this to not be platform specific later on */
  86         if (xive_enabled())
  87                 xive_smp_disable_cpu();
  88         else
  89                 xics_migrate_irqs_away();
  90
  91         cleanup_cpu_mmu_context();
  92
  93         return 0;
  94 }
  95
  96 /*
  97  * pseries_cpu_die: Wait for the cpu to die.
  98  * @cpu: logical processor id of the CPU whose death we're awaiting.
  99  *
 100  * This function is called from the context of the thread which is performing
 101  * the cpu-offline. Here we wait for long enough to allow the cpu in question
 102  * to self-destroy so that the cpu-offline thread can send the CPU_DEAD
 103  * notifications.
 104  *
 105  * OTOH, pseries_cpu_offline_self() is called by the @cpu when it wants to
 106  * self-destruct.
 107  */
 108 static void pseries_cpu_die(unsigned int cpu)
 109 {
 110         int cpu_status = 1;
 111         unsigned int pcpu = get_hard_smp_processor_id(cpu);
 112         unsigned long timeout = jiffies + msecs_to_jiffies(120000);
 113
 114         while (true) {
 115                 cpu_status = smp_query_cpu_stopped(pcpu);
 116                 if (cpu_status == QCSS_STOPPED ||
 117                     cpu_status == QCSS_HARDWARE_ERROR)
 118                         break;
 119
 120                 if (time_after(jiffies, timeout)) {
 121                         pr_warn("CPU %i (hwid %i) didn't die after 120 seconds\n",
 122                                 cpu, pcpu);
 123                         timeout = jiffies + msecs_to_jiffies(120000);
 124                 }
 125
 126                 cond_resched();
 127         }
 128
 129         if (cpu_status == QCSS_HARDWARE_ERROR) {
 130                 pr_warn("CPU %i (hwid %i) reported error while dying\n",
 131                         cpu, pcpu);
 132         }
 133
 134         /* Isolation and deallocation are definitely done by
 135          * drslot_chrp_cpu.  If they were not they would be
 136          * done here.  Change isolate state to Isolate and
 137          * change allocation-state to Unusable.
 138          */
 139         paca_ptrs[cpu]->cpu_start = 0;
 140 }
 141
 142 /*
 143  * Update cpu_present_mask and paca(s) for a new cpu node.  The wrinkle
 144  * here is that a cpu device node may represent up to two logical cpus
 145  * in the SMT case.  We must honor the assumption in other code that
 146  * the logical ids for sibling SMT threads x and y are adjacent, such
 147  * that x^1 == y and y^1 == x.
 148  */
 149 static int pseries_add_processor(struct device_node *np)
 150 {
 151         unsigned int cpu;
 152         cpumask_var_t candidate_mask, tmp;
 153         int err = -ENOSPC, len, nthreads, i;
 154         const __be32 *intserv;
 155
 156         intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
 157         if (!intserv)
 158                 return 0;
 159
 160         zalloc_cpumask_var(&candidate_mask, GFP_KERNEL);
 161         zalloc_cpumask_var(&tmp, GFP_KERNEL);
 162
 163         nthreads = len / sizeof(u32);
 164         for (i = 0; i < nthreads; i++)
 165                 cpumask_set_cpu(i, tmp);
 166
 167         cpu_maps_update_begin();
 168
 169         BUG_ON(!cpumask_subset(cpu_present_mask, cpu_possible_mask));
 170
 171         /* Get a bitmap of unoccupied slots. */
 172         cpumask_xor(candidate_mask, cpu_possible_mask, cpu_present_mask);
 173         if (cpumask_empty(candidate_mask)) {
 174                 /* If we get here, it most likely means that NR_CPUS is
 175                  * less than the partition's max processors setting.
 176                  */
 177                 printk(KERN_ERR "Cannot add cpu %pOF; this system configuration"
 178                        " supports %d logical cpus.\n", np,
 179                        num_possible_cpus());
 180                 goto out_unlock;
 181         }
 182
 183         while (!cpumask_empty(tmp))
 184                 if (cpumask_subset(tmp, candidate_mask))
 185                         /* Found a range where we can insert the new cpu(s) */
 186                         break;
 187                 else
 188                         cpumask_shift_left(tmp, tmp, nthreads);
 189
 190         if (cpumask_empty(tmp)) {
 191                 printk(KERN_ERR "Unable to find space in cpu_present_mask for"
 192                        " processor %pOFn with %d thread(s)\n", np,
 193                        nthreads);
 194                 goto out_unlock;
 195         }
 196
 197         for_each_cpu(cpu, tmp) {
 198                 BUG_ON(cpu_present(cpu));
 199                 set_cpu_present(cpu, true);
 200                 set_hard_smp_processor_id(cpu, be32_to_cpu(*intserv++));
 201         }
 202         err = 0;
 203 out_unlock:
 204         cpu_maps_update_done();
 205         free_cpumask_var(candidate_mask);
 206         free_cpumask_var(tmp);
 207         return err;
 208 }
 209
 210 /*
 211  * Update the present map for a cpu node which is going away, and set
 212  * the hard id in the paca(s) to -1 to be consistent with boot time
 213  * convention for non-present cpus.
 214  */
 215 static void pseries_remove_processor(struct device_node *np)
 216 {
 217         unsigned int cpu;
 218         int len, nthreads, i;
 219         const __be32 *intserv;
 220         u32 thread;
 221
 222         intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
 223         if (!intserv)
 224                 return;
 225
 226         nthreads = len / sizeof(u32);
 227
 228         cpu_maps_update_begin();
 229         for (i = 0; i < nthreads; i++) {
 230                 thread = be32_to_cpu(intserv[i]);
 231                 for_each_present_cpu(cpu) {
 232                         if (get_hard_smp_processor_id(cpu) != thread)
 233                                 continue;
 234                         BUG_ON(cpu_online(cpu));
 235                         set_cpu_present(cpu, false);
 236                         set_hard_smp_processor_id(cpu, -1);
 237                         update_numa_cpu_lookup_table(cpu, -1);
 238                         break;
 239                 }
 240                 if (cpu >= nr_cpu_ids)
 241                         printk(KERN_WARNING "Could not find cpu to remove "
 242                                "with physical id 0x%x\n", thread);
 243         }
 244         cpu_maps_update_done();
 245 }
 246
 247 static int dlpar_offline_cpu(struct device_node *dn)
 248 {
 249         int rc = 0;
 250         unsigned int cpu;
 251         int len, nthreads, i;
 252         const __be32 *intserv;
 253         u32 thread;
 254
 255         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
 256         if (!intserv)
 257                 return -EINVAL;
 258
 259         nthreads = len / sizeof(u32);
 260
 261         cpu_maps_update_begin();
 262         for (i = 0; i < nthreads; i++) {
 263                 thread = be32_to_cpu(intserv[i]);
 264                 for_each_present_cpu(cpu) {
 265                         if (get_hard_smp_processor_id(cpu) != thread)
 266                                 continue;
 267
 268                         if (!cpu_online(cpu))
 269                                 break;
 270
 271                         /*
 272                          * device_offline() will return -EBUSY (via cpu_down()) if there
 273                          * is only one CPU left. Check it here to fail earlier and with a
 274                          * more informative error message, while also retaining the
 275                          * cpu_add_remove_lock to be sure that no CPUs are being
 276                          * online/offlined during this check.
 277                          */
 278                         if (num_online_cpus() == 1) {
 279                                 pr_warn("Unable to remove last online CPU %pOFn\n", dn);
 280                                 rc = -EBUSY;
 281                                 goto out_unlock;
 282                         }
 283
 284                         cpu_maps_update_done();
 285                         rc = device_offline(get_cpu_device(cpu));
 286                         if (rc)
 287                                 goto out;
 288                         cpu_maps_update_begin();
 289                         break;
 290                 }
 291                 if (cpu == num_possible_cpus()) {
 292                         pr_warn("Could not find cpu to offline with physical id 0x%x\n",
 293                                 thread);
 294                 }
 295         }
 296 out_unlock:
 297         cpu_maps_update_done();
 298
 299 out:
 300         return rc;
 301 }
 302
 303 static int dlpar_online_cpu(struct device_node *dn)
 304 {
 305         int rc = 0;
 306         unsigned int cpu;
 307         int len, nthreads, i;
 308         const __be32 *intserv;
 309         u32 thread;
 310
 311         intserv = of_get_property(dn, "ibm,ppc-interrupt-server#s", &len);
 312         if (!intserv)
 313                 return -EINVAL;
 314
 315         nthreads = len / sizeof(u32);
 316
 317         cpu_maps_update_begin();
 318         for (i = 0; i < nthreads; i++) {
 319                 thread = be32_to_cpu(intserv[i]);
 320                 for_each_present_cpu(cpu) {
 321                         if (get_hard_smp_processor_id(cpu) != thread)
 322                                 continue;
 323                         cpu_maps_update_done();
 324                         find_and_online_cpu_nid(cpu);
 325                         rc = device_online(get_cpu_device(cpu));
 326                         if (rc) {
 327                                 dlpar_offline_cpu(dn);
 328                                 goto out;
 329                         }
 330                         cpu_maps_update_begin();
 331
 332                         break;
 333                 }
 334                 if (cpu == num_possible_cpus())
 335                         printk(KERN_WARNING "Could not find cpu to online "
 336                                "with physical id 0x%x\n", thread);
 337         }
 338         cpu_maps_update_done();
 339
 340 out:
 341         return rc;
 342
 343 }
 344
 345 static bool dlpar_cpu_exists(struct device_node *parent, u32 drc_index)
 346 {
 347         struct device_node *child = NULL;
 348         u32 my_drc_index;
 349         bool found;
 350         int rc;
 351
 352         /* Assume cpu doesn't exist */
 353         found = false;
 354
 355         for_each_child_of_node(parent, child) {
 356                 rc = of_property_read_u32(child, "ibm,my-drc-index",
 357                                           &my_drc_index);
 358                 if (rc)
 359                         continue;
 360
 361                 if (my_drc_index == drc_index) {
 362                         of_node_put(child);
 363                         found = true;
 364                         break;
 365                 }
 366         }
 367
 368         return found;
 369 }
 370
 371 static bool drc_info_valid_index(struct device_node *parent, u32 drc_index)
 372 {
 373         struct property *info;
 374         struct of_drc_info drc;
 375         const __be32 *value;
 376         u32 index;
 377         int count, i, j;
 378
 379         info = of_find_property(parent, "ibm,drc-info", NULL);
 380         if (!info)
 381                 return false;
 382
 383         value = of_prop_next_u32(info, NULL, &count);
 384
 385         /* First value of ibm,drc-info is number of drc-info records */
 386         if (value)
 387                 value++;
 388         else
 389                 return false;
 390
 391         for (i = 0; i < count; i++) {
 392                 if (of_read_drc_info_cell(&info, &value, &drc))
 393                         return false;
 394
 395                 if (strncmp(drc.drc_type, "CPU", 3))
 396                         break;
 397
 398                 if (drc_index > drc.last_drc_index)
 399                         continue;
 400
 401                 index = drc.drc_index_start;
 402                 for (j = 0; j < drc.num_sequential_elems; j++) {
 403                         if (drc_index == index)
 404                                 return true;
 405
 406                         index += drc.sequential_inc;
 407                 }
 408         }
 409
 410         return false;
 411 }
 412
 413 static bool valid_cpu_drc_index(struct device_node *parent, u32 drc_index)
 414 {
 415         bool found = false;
 416         int rc, index;
 417
 418         if (of_find_property(parent, "ibm,drc-info", NULL))
 419                 return drc_info_valid_index(parent, drc_index);
 420
 421         /* Note that the format of the ibm,drc-indexes array is
 422          * the number of entries in the array followed by the array
 423          * of drc values so we start looking at index = 1.
 424          */
 425         index = 1;
 426         while (!found) {
 427                 u32 drc;
 428
 429                 rc = of_property_read_u32_index(parent, "ibm,drc-indexes",
 430                                                 index++, &drc);
 431
 432                 if (rc)
 433                         break;
 434
 435                 if (drc == drc_index)
 436                         found = true;
 437         }
 438
 439         return found;
 440 }
 441
 442 static ssize_t dlpar_cpu_add(u32 drc_index)
 443 {
 444         struct device_node *dn, *parent;
 445         int rc, saved_rc;
 446
 447         pr_debug("Attempting to add CPU, drc index: %x\n", drc_index);
 448
 449         parent = of_find_node_by_path("/cpus");
 450         if (!parent) {
 451                 pr_warn("Failed to find CPU root node \"/cpus\"\n");
 452                 return -ENODEV;
 453         }
 454
 455         if (dlpar_cpu_exists(parent, drc_index)) {
 456                 of_node_put(parent);
 457                 pr_warn("CPU with drc index %x already exists\n", drc_index);
 458                 return -EINVAL;
 459         }
 460
 461         if (!valid_cpu_drc_index(parent, drc_index)) {
 462                 of_node_put(parent);
 463                 pr_warn("Cannot find CPU (drc index %x) to add.\n", drc_index);
 464                 return -EINVAL;
 465         }
 466
 467         rc = dlpar_acquire_drc(drc_index);
 468         if (rc) {
 469                 pr_warn("Failed to acquire DRC, rc: %d, drc index: %x\n",
 470                         rc, drc_index);
 471                 of_node_put(parent);
 472                 return -EINVAL;
 473         }
 474
 475         dn = dlpar_configure_connector(cpu_to_be32(drc_index), parent);
 476         if (!dn) {
 477                 pr_warn("Failed call to configure-connector, drc index: %x\n",
 478                         drc_index);
 479                 dlpar_release_drc(drc_index);
 480                 of_node_put(parent);
 481                 return -EINVAL;
 482         }
 483
 484         rc = dlpar_attach_node(dn, parent);
 485
 486         /* Regardless we are done with parent now */
 487         of_node_put(parent);
 488
 489         if (rc) {
 490                 saved_rc = rc;
 491                 pr_warn("Failed to attach node %pOFn, rc: %d, drc index: %x\n",
 492                         dn, rc, drc_index);
 493
 494                 rc = dlpar_release_drc(drc_index);
 495                 if (!rc)
 496                         dlpar_free_cc_nodes(dn);
 497
 498                 return saved_rc;
 499         }
 500
 501         rc = dlpar_online_cpu(dn);
 502         if (rc) {
 503                 saved_rc = rc;
 504                 pr_warn("Failed to online cpu %pOFn, rc: %d, drc index: %x\n",
 505                         dn, rc, drc_index);
 506
 507                 rc = dlpar_detach_node(dn);
 508                 if (!rc)
 509                         dlpar_release_drc(drc_index);
 510
 511                 return saved_rc;
 512         }
 513
 514         pr_debug("Successfully added CPU %pOFn, drc index: %x\n", dn,
 515                  drc_index);
 516         return rc;
 517 }
 518
 519 static ssize_t dlpar_cpu_remove(struct device_node *dn, u32 drc_index)
 520 {
 521         int rc;
 522
 523         pr_debug("Attempting to remove CPU %pOFn, drc index: %x\n",
 524                  dn, drc_index);
 525
 526         rc = dlpar_offline_cpu(dn);
 527         if (rc) {
 528                 pr_warn("Failed to offline CPU %pOFn, rc: %d\n", dn, rc);
 529                 return -EINVAL;
 530         }
 531
 532         rc = dlpar_release_drc(drc_index);
 533         if (rc) {
 534                 pr_warn("Failed to release drc (%x) for CPU %pOFn, rc: %d\n",
 535                         drc_index, dn, rc);
 536                 dlpar_online_cpu(dn);
 537                 return rc;
 538         }
 539
 540         rc = dlpar_detach_node(dn);
 541         if (rc) {
 542                 int saved_rc = rc;
 543
 544                 pr_warn("Failed to detach CPU %pOFn, rc: %d", dn, rc);
 545
 546                 rc = dlpar_acquire_drc(drc_index);
 547                 if (!rc)
 548                         dlpar_online_cpu(dn);
 549
 550                 return saved_rc;
 551         }
 552
 553         pr_debug("Successfully removed CPU, drc index: %x\n", drc_index);
 554         return 0;
 555 }
 556
 557 static struct device_node *cpu_drc_index_to_dn(u32 drc_index)
 558 {
 559         struct device_node *dn;
 560         u32 my_index;
 561         int rc;
 562
 563         for_each_node_by_type(dn, "cpu") {
 564                 rc = of_property_read_u32(dn, "ibm,my-drc-index", &my_index);
 565                 if (rc)
 566                         continue;
 567
 568                 if (my_index == drc_index)
 569                         break;
 570         }
 571
 572         return dn;
 573 }
 574
 575 static int dlpar_cpu_remove_by_index(u32 drc_index)
 576 {
 577         struct device_node *dn;
 578         int rc;
 579
 580         dn = cpu_drc_index_to_dn(drc_index);
 581         if (!dn) {
 582                 pr_warn("Cannot find CPU (drc index %x) to remove\n",
 583                         drc_index);
 584                 return -ENODEV;
 585         }
 586
 587         rc = dlpar_cpu_remove(dn, drc_index);
 588         of_node_put(dn);
 589         return rc;
 590 }
 591
 592 static int find_dlpar_cpus_to_remove(u32 *cpu_drcs, int cpus_to_remove)
 593 {
 594         struct device_node *dn;
 595         int cpus_found = 0;
 596         int rc;
 597
 598         /* We want to find cpus_to_remove + 1 CPUs to ensure we do not
 599          * remove the last CPU.
 600          */
 601         for_each_node_by_type(dn, "cpu") {
 602                 cpus_found++;
 603
 604                 if (cpus_found > cpus_to_remove) {
 605                         of_node_put(dn);
 606                         break;
 607                 }
 608
 609                 /* Note that cpus_found is always 1 ahead of the index
 610                  * into the cpu_drcs array, so we use cpus_found - 1
 611                  */
 612                 rc = of_property_read_u32(dn, "ibm,my-drc-index",
 613                                           &cpu_drcs[cpus_found - 1]);
 614                 if (rc) {
 615                         pr_warn("Error occurred getting drc-index for %pOFn\n",
 616                                 dn);
 617                         of_node_put(dn);
 618                         return -1;
 619                 }
 620         }
 621
 622         if (cpus_found < cpus_to_remove) {
 623                 pr_warn("Failed to find enough CPUs (%d of %d) to remove\n",
 624                         cpus_found, cpus_to_remove);
 625         } else if (cpus_found == cpus_to_remove) {
 626                 pr_warn("Cannot remove all CPUs\n");
 627         }
 628
 629         return cpus_found;
 630 }
 631
 632 static int dlpar_cpu_remove_by_count(u32 cpus_to_remove)
 633 {
 634         u32 *cpu_drcs;
 635         int cpus_found;
 636         int cpus_removed = 0;
 637         int i, rc;
 638
 639         pr_debug("Attempting to hot-remove %d CPUs\n", cpus_to_remove);
 640
 641         cpu_drcs = kcalloc(cpus_to_remove, sizeof(*cpu_drcs), GFP_KERNEL);
 642         if (!cpu_drcs)
 643                 return -EINVAL;
 644
 645         cpus_found = find_dlpar_cpus_to_remove(cpu_drcs, cpus_to_remove);
 646         if (cpus_found <= cpus_to_remove) {
 647                 kfree(cpu_drcs);
 648                 return -EINVAL;
 649         }
 650
 651         for (i = 0; i < cpus_to_remove; i++) {
 652                 rc = dlpar_cpu_remove_by_index(cpu_drcs[i]);
 653                 if (rc)
 654                         break;
 655
 656                 cpus_removed++;
 657         }
 658
 659         if (cpus_removed != cpus_to_remove) {
 660                 pr_warn("CPU hot-remove failed, adding back removed CPUs\n");
 661
 662                 for (i = 0; i < cpus_removed; i++)
 663                         dlpar_cpu_add(cpu_drcs[i]);
 664
 665                 rc = -EINVAL;
 666         } else {
 667                 rc = 0;
 668         }
 669
 670         kfree(cpu_drcs);
 671         return rc;
 672 }
 673
 674 static int find_drc_info_cpus_to_add(struct device_node *cpus,
 675                                      struct property *info,
 676                                      u32 *cpu_drcs, u32 cpus_to_add)
 677 {
 678         struct of_drc_info drc;
 679         const __be32 *value;
 680         u32 count, drc_index;
 681         int cpus_found = 0;
 682         int i, j;
 683
 684         if (!info)
 685                 return -1;
 686
 687         value = of_prop_next_u32(info, NULL, &count);
 688         if (value)
 689                 value++;
 690
 691         for (i = 0; i < count; i++) {
 692                 of_read_drc_info_cell(&info, &value, &drc);
 693                 if (strncmp(drc.drc_type, "CPU", 3))
 694                         break;
 695
 696                 drc_index = drc.drc_index_start;
 697                 for (j = 0; j < drc.num_sequential_elems; j++) {
 698                         if (dlpar_cpu_exists(cpus, drc_index))
 699                                 continue;
 700
 701                         cpu_drcs[cpus_found++] = drc_index;
 702
 703                         if (cpus_found == cpus_to_add)
 704                                 return cpus_found;
 705
 706                         drc_index += drc.sequential_inc;
 707                 }
 708         }
 709
 710         return cpus_found;
 711 }
 712
 713 static int find_drc_index_cpus_to_add(struct device_node *cpus,
 714                                       u32 *cpu_drcs, u32 cpus_to_add)
 715 {
 716         int cpus_found = 0;
 717         int index, rc;
 718         u32 drc_index;
 719
 720         /* Search the ibm,drc-indexes array for possible CPU drcs to
 721          * add. Note that the format of the ibm,drc-indexes array is
 722          * the number of entries in the array followed by the array
 723          * of drc values so we start looking at index = 1.
 724          */
 725         index = 1;
 726         while (cpus_found < cpus_to_add) {
 727                 rc = of_property_read_u32_index(cpus, "ibm,drc-indexes",
 728                                                 index++, &drc_index);
 729
 730                 if (rc)
 731                         break;
 732
 733                 if (dlpar_cpu_exists(cpus, drc_index))
 734                         continue;
 735
 736                 cpu_drcs[cpus_found++] = drc_index;
 737         }
 738
 739         return cpus_found;
 740 }
 741
 742 static int dlpar_cpu_add_by_count(u32 cpus_to_add)
 743 {
 744         struct device_node *parent;
 745         struct property *info;
 746         u32 *cpu_drcs;
 747         int cpus_added = 0;
 748         int cpus_found;
 749         int i, rc;
 750
 751         pr_debug("Attempting to hot-add %d CPUs\n", cpus_to_add);
 752
 753         cpu_drcs = kcalloc(cpus_to_add, sizeof(*cpu_drcs), GFP_KERNEL);
 754         if (!cpu_drcs)
 755                 return -EINVAL;
 756
 757         parent = of_find_node_by_path("/cpus");
 758         if (!parent) {
 759                 pr_warn("Could not find CPU root node in device tree\n");
 760                 kfree(cpu_drcs);
 761                 return -1;
 762         }
 763
 764         info = of_find_property(parent, "ibm,drc-info", NULL);
 765         if (info)
 766                 cpus_found = find_drc_info_cpus_to_add(parent, info, cpu_drcs, cpus_to_add);
 767         else
 768                 cpus_found = find_drc_index_cpus_to_add(parent, cpu_drcs, cpus_to_add);
 769
 770         of_node_put(parent);
 771
 772         if (cpus_found < cpus_to_add) {
 773                 pr_warn("Failed to find enough CPUs (%d of %d) to add\n",
 774                         cpus_found, cpus_to_add);
 775                 kfree(cpu_drcs);
 776                 return -EINVAL;
 777         }
 778
 779         for (i = 0; i < cpus_to_add; i++) {
 780                 rc = dlpar_cpu_add(cpu_drcs[i]);
 781                 if (rc)
 782                         break;
 783
 784                 cpus_added++;
 785         }
 786
 787         if (cpus_added < cpus_to_add) {
 788                 pr_warn("CPU hot-add failed, removing any added CPUs\n");
 789
 790                 for (i = 0; i < cpus_added; i++)
 791                         dlpar_cpu_remove_by_index(cpu_drcs[i]);
 792
 793                 rc = -EINVAL;
 794         } else {
 795                 rc = 0;
 796         }
 797
 798         kfree(cpu_drcs);
 799         return rc;
 800 }
 801
 802 int dlpar_cpu(struct pseries_hp_errorlog *hp_elog)
 803 {
 804         u32 count, drc_index;
 805         int rc;
 806
 807         count = hp_elog->_drc_u.drc_count;
 808         drc_index = hp_elog->_drc_u.drc_index;
 809
 810         lock_device_hotplug();
 811
 812         switch (hp_elog->action) {
 813         case PSERIES_HP_ELOG_ACTION_REMOVE:
 814                 if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_COUNT)
 815                         rc = dlpar_cpu_remove_by_count(count);
 816                 else if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_INDEX) {
 817                         rc = dlpar_cpu_remove_by_index(drc_index);
 818                         /*
 819                          * Setting the isolation state of an UNISOLATED/CONFIGURED
 820                          * device to UNISOLATE is a no-op, but the hypervisor can
 821                          * use it as a hint that the CPU removal failed.
 822                          */
 823                         if (rc)
 824                                 dlpar_unisolate_drc(drc_index);
 825                 }
 826                 else
 827                         rc = -EINVAL;
 828                 break;
 829         case PSERIES_HP_ELOG_ACTION_ADD:
 830                 if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_COUNT)
 831                         rc = dlpar_cpu_add_by_count(count);
 832                 else if (hp_elog->id_type == PSERIES_HP_ELOG_ID_DRC_INDEX)
 833                         rc = dlpar_cpu_add(drc_index);
 834                 else
 835                         rc = -EINVAL;
 836                 break;
 837         default:
 838                 pr_err("Invalid action (%d) specified\n", hp_elog->action);
 839                 rc = -EINVAL;
 840                 break;
 841         }
 842
 843         unlock_device_hotplug();
 844         return rc;
 845 }
 846
 847 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
 848
 849 static ssize_t dlpar_cpu_probe(const char *buf, size_t count)
 850 {
 851         u32 drc_index;
 852         int rc;
 853
 854         rc = kstrtou32(buf, 0, &drc_index);
 855         if (rc)
 856                 return -EINVAL;
 857
 858         rc = dlpar_cpu_add(drc_index);
 859
 860         return rc ? rc : count;
 861 }
 862
 863 static ssize_t dlpar_cpu_release(const char *buf, size_t count)
 864 {
 865         struct device_node *dn;
 866         u32 drc_index;
 867         int rc;
 868
 869         dn = of_find_node_by_path(buf);
 870         if (!dn)
 871                 return -EINVAL;
 872
 873         rc = of_property_read_u32(dn, "ibm,my-drc-index", &drc_index);
 874         if (rc) {
 875                 of_node_put(dn);
 876                 return -EINVAL;
 877         }
 878
 879         rc = dlpar_cpu_remove(dn, drc_index);
 880         of_node_put(dn);
 881
 882         return rc ? rc : count;
 883 }
 884
 885 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
 886
 887 static int pseries_smp_notifier(struct notifier_block *nb,
 888                                 unsigned long action, void *data)
 889 {
 890         struct of_reconfig_data *rd = data;
 891         int err = 0;
 892
 893         switch (action) {
 894         case OF_RECONFIG_ATTACH_NODE:
 895                 err = pseries_add_processor(rd->dn);
 896                 break;
 897         case OF_RECONFIG_DETACH_NODE:
 898                 pseries_remove_processor(rd->dn);
 899                 break;
 900         }
 901         return notifier_from_errno(err);
 902 }
 903
 904 static struct notifier_block pseries_smp_nb = {
 905         .notifier_call = pseries_smp_notifier,
 906 };
 907
 908 static int __init pseries_cpu_hotplug_init(void)
 909 {
 910         int qcss_tok;
 911
 912 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
 913         ppc_md.cpu_probe = dlpar_cpu_probe;
 914         ppc_md.cpu_release = dlpar_cpu_release;
 915 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
 916
 917         rtas_stop_self_token = rtas_token("stop-self");
 918         qcss_tok = rtas_token("query-cpu-stopped-state");
 919
 920         if (rtas_stop_self_token == RTAS_UNKNOWN_SERVICE ||
 921                         qcss_tok == RTAS_UNKNOWN_SERVICE) {
 922                 printk(KERN_INFO "CPU Hotplug not supported by firmware "
 923                                 "- disabling.\n");
 924                 return 0;
 925         }
 926
 927         smp_ops->cpu_offline_self = pseries_cpu_offline_self;
 928         smp_ops->cpu_disable = pseries_cpu_disable;
 929         smp_ops->cpu_die = pseries_cpu_die;
 930
 931         /* Processors can be added/removed only on LPAR */
 932         if (firmware_has_feature(FW_FEATURE_LPAR))
 933                 of_reconfig_notifier_register(&pseries_smp_nb);
 934
 935         return 0;
 936 }
 937 machine_arch_initcall(pseries, pseries_cpu_hotplug_init);