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); 938