~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/platforms/pseries/hotplug-cpu.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp