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

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