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

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

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.6 ] ~ [ linux-5.4.22 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.106 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.171 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.214 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.214 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 #include <linux/kernel.h>
 22 #include <linux/interrupt.h>
 23 #include <linux/delay.h>
 24 #include <linux/sched.h>        /* for idle_task_exit */
 25 #include <linux/cpu.h>
 26 #include <linux/of.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 "plpar_wrappers.h"
 34 #include "offline_states.h"
 35 
 36 /* This version can't take the spinlock, because it never returns */
 37 static struct rtas_args rtas_stop_self_args = {
 38         .token = RTAS_UNKNOWN_SERVICE,
 39         .nargs = 0,
 40         .nret = 1,
 41         .rets = &rtas_stop_self_args.args[0],
 42 };
 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 int cede_offline_enabled __read_mostly = 1;
 51 
 52 /*
 53  * Enable/disable cede_offline when available.
 54  */
 55 static int __init setup_cede_offline(char *str)
 56 {
 57         if (!strcmp(str, "off"))
 58                 cede_offline_enabled = 0;
 59         else if (!strcmp(str, "on"))
 60                 cede_offline_enabled = 1;
 61         else
 62                 return 0;
 63         return 1;
 64 }
 65 
 66 __setup("cede_offline=", setup_cede_offline);
 67 
 68 enum cpu_state_vals get_cpu_current_state(int cpu)
 69 {
 70         return per_cpu(current_state, cpu);
 71 }
 72 
 73 void set_cpu_current_state(int cpu, enum cpu_state_vals state)
 74 {
 75         per_cpu(current_state, cpu) = state;
 76 }
 77 
 78 enum cpu_state_vals get_preferred_offline_state(int cpu)
 79 {
 80         return per_cpu(preferred_offline_state, cpu);
 81 }
 82 
 83 void set_preferred_offline_state(int cpu, enum cpu_state_vals state)
 84 {
 85         per_cpu(preferred_offline_state, cpu) = state;
 86 }
 87 
 88 void set_default_offline_state(int cpu)
 89 {
 90         per_cpu(preferred_offline_state, cpu) = default_offline_state;
 91 }
 92 
 93 static void rtas_stop_self(void)
 94 {
 95         struct rtas_args *args = &rtas_stop_self_args;
 96 
 97         local_irq_disable();
 98 
 99         BUG_ON(args->token == RTAS_UNKNOWN_SERVICE);
100 
101         printk("cpu %u (hwid %u) Ready to die...\n",
102                smp_processor_id(), hard_smp_processor_id());
103         enter_rtas(__pa(args));
104 
105         panic("Alas, I survived.\n");
106 }
107 
108 static void pseries_mach_cpu_die(void)
109 {
110         unsigned int cpu = smp_processor_id();
111         unsigned int hwcpu = hard_smp_processor_id();
112         u8 cede_latency_hint = 0;
113 
114         local_irq_disable();
115         idle_task_exit();
116         xics_teardown_cpu();
117 
118         if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
119                 set_cpu_current_state(cpu, CPU_STATE_INACTIVE);
120                 if (ppc_md.suspend_disable_cpu)
121                         ppc_md.suspend_disable_cpu();
122 
123                 cede_latency_hint = 2;
124 
125                 get_lppaca()->idle = 1;
126                 if (!get_lppaca()->shared_proc)
127                         get_lppaca()->donate_dedicated_cpu = 1;
128 
129                 while (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
130                         while (!prep_irq_for_idle()) {
131                                 local_irq_enable();
132                                 local_irq_disable();
133                         }
134 
135                         extended_cede_processor(cede_latency_hint);
136                 }
137 
138                 local_irq_disable();
139 
140                 if (!get_lppaca()->shared_proc)
141                         get_lppaca()->donate_dedicated_cpu = 0;
142                 get_lppaca()->idle = 0;
143 
144                 if (get_preferred_offline_state(cpu) == CPU_STATE_ONLINE) {
145                         unregister_slb_shadow(hwcpu);
146 
147                         hard_irq_disable();
148                         /*
149                          * Call to start_secondary_resume() will not return.
150                          * Kernel stack will be reset and start_secondary()
151                          * will be called to continue the online operation.
152                          */
153                         start_secondary_resume();
154                 }
155         }
156 
157         /* Requested state is CPU_STATE_OFFLINE at this point */
158         WARN_ON(get_preferred_offline_state(cpu) != CPU_STATE_OFFLINE);
159 
160         set_cpu_current_state(cpu, CPU_STATE_OFFLINE);
161         unregister_slb_shadow(hwcpu);
162         rtas_stop_self();
163 
164         /* Should never get here... */
165         BUG();
166         for(;;);
167 }
168 
169 static int pseries_cpu_disable(void)
170 {
171         int cpu = smp_processor_id();
172 
173         set_cpu_online(cpu, false);
174         vdso_data->processorCount--;
175 
176         /*fix boot_cpuid here*/
177         if (cpu == boot_cpuid)
178                 boot_cpuid = cpumask_any(cpu_online_mask);
179 
180         /* FIXME: abstract this to not be platform specific later on */
181         xics_migrate_irqs_away();
182         return 0;
183 }
184 
185 /*
186  * pseries_cpu_die: Wait for the cpu to die.
187  * @cpu: logical processor id of the CPU whose death we're awaiting.
188  *
189  * This function is called from the context of the thread which is performing
190  * the cpu-offline. Here we wait for long enough to allow the cpu in question
191  * to self-destroy so that the cpu-offline thread can send the CPU_DEAD
192  * notifications.
193  *
194  * OTOH, pseries_mach_cpu_die() is called by the @cpu when it wants to
195  * self-destruct.
196  */
197 static void pseries_cpu_die(unsigned int cpu)
198 {
199         int tries;
200         int cpu_status = 1;
201         unsigned int pcpu = get_hard_smp_processor_id(cpu);
202 
203         if (get_preferred_offline_state(cpu) == CPU_STATE_INACTIVE) {
204                 cpu_status = 1;
205                 for (tries = 0; tries < 5000; tries++) {
206                         if (get_cpu_current_state(cpu) == CPU_STATE_INACTIVE) {
207                                 cpu_status = 0;
208                                 break;
209                         }
210                         msleep(1);
211                 }
212         } else if (get_preferred_offline_state(cpu) == CPU_STATE_OFFLINE) {
213 
214                 for (tries = 0; tries < 25; tries++) {
215                         cpu_status = smp_query_cpu_stopped(pcpu);
216                         if (cpu_status == QCSS_STOPPED ||
217                             cpu_status == QCSS_HARDWARE_ERROR)
218                                 break;
219                         cpu_relax();
220                 }
221         }
222 
223         if (cpu_status != 0) {
224                 printk("Querying DEAD? cpu %i (%i) shows %i\n",
225                        cpu, pcpu, cpu_status);
226         }
227 
228         /* Isolation and deallocation are definitely done by
229          * drslot_chrp_cpu.  If they were not they would be
230          * done here.  Change isolate state to Isolate and
231          * change allocation-state to Unusable.
232          */
233         paca[cpu].cpu_start = 0;
234 }
235 
236 /*
237  * Update cpu_present_mask and paca(s) for a new cpu node.  The wrinkle
238  * here is that a cpu device node may represent up to two logical cpus
239  * in the SMT case.  We must honor the assumption in other code that
240  * the logical ids for sibling SMT threads x and y are adjacent, such
241  * that x^1 == y and y^1 == x.
242  */
243 static int pseries_add_processor(struct device_node *np)
244 {
245         unsigned int cpu;
246         cpumask_var_t candidate_mask, tmp;
247         int err = -ENOSPC, len, nthreads, i;
248         const u32 *intserv;
249 
250         intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
251         if (!intserv)
252                 return 0;
253 
254         zalloc_cpumask_var(&candidate_mask, GFP_KERNEL);
255         zalloc_cpumask_var(&tmp, GFP_KERNEL);
256 
257         nthreads = len / sizeof(u32);
258         for (i = 0; i < nthreads; i++)
259                 cpumask_set_cpu(i, tmp);
260 
261         cpu_maps_update_begin();
262 
263         BUG_ON(!cpumask_subset(cpu_present_mask, cpu_possible_mask));
264 
265         /* Get a bitmap of unoccupied slots. */
266         cpumask_xor(candidate_mask, cpu_possible_mask, cpu_present_mask);
267         if (cpumask_empty(candidate_mask)) {
268                 /* If we get here, it most likely means that NR_CPUS is
269                  * less than the partition's max processors setting.
270                  */
271                 printk(KERN_ERR "Cannot add cpu %s; this system configuration"
272                        " supports %d logical cpus.\n", np->full_name,
273                        cpumask_weight(cpu_possible_mask));
274                 goto out_unlock;
275         }
276 
277         while (!cpumask_empty(tmp))
278                 if (cpumask_subset(tmp, candidate_mask))
279                         /* Found a range where we can insert the new cpu(s) */
280                         break;
281                 else
282                         cpumask_shift_left(tmp, tmp, nthreads);
283 
284         if (cpumask_empty(tmp)) {
285                 printk(KERN_ERR "Unable to find space in cpu_present_mask for"
286                        " processor %s with %d thread(s)\n", np->name,
287                        nthreads);
288                 goto out_unlock;
289         }
290 
291         for_each_cpu(cpu, tmp) {
292                 BUG_ON(cpu_present(cpu));
293                 set_cpu_present(cpu, true);
294                 set_hard_smp_processor_id(cpu, *intserv++);
295         }
296         err = 0;
297 out_unlock:
298         cpu_maps_update_done();
299         free_cpumask_var(candidate_mask);
300         free_cpumask_var(tmp);
301         return err;
302 }
303 
304 /*
305  * Update the present map for a cpu node which is going away, and set
306  * the hard id in the paca(s) to -1 to be consistent with boot time
307  * convention for non-present cpus.
308  */
309 static void pseries_remove_processor(struct device_node *np)
310 {
311         unsigned int cpu;
312         int len, nthreads, i;
313         const u32 *intserv;
314 
315         intserv = of_get_property(np, "ibm,ppc-interrupt-server#s", &len);
316         if (!intserv)
317                 return;
318 
319         nthreads = len / sizeof(u32);
320 
321         cpu_maps_update_begin();
322         for (i = 0; i < nthreads; i++) {
323                 for_each_present_cpu(cpu) {
324                         if (get_hard_smp_processor_id(cpu) != intserv[i])
325                                 continue;
326                         BUG_ON(cpu_online(cpu));
327                         set_cpu_present(cpu, false);
328                         set_hard_smp_processor_id(cpu, -1);
329                         break;
330                 }
331                 if (cpu >= nr_cpu_ids)
332                         printk(KERN_WARNING "Could not find cpu to remove "
333                                "with physical id 0x%x\n", intserv[i]);
334         }
335         cpu_maps_update_done();
336 }
337 
338 static int pseries_smp_notifier(struct notifier_block *nb,
339                                 unsigned long action, void *node)
340 {
341         int err = 0;
342 
343         switch (action) {
344         case OF_RECONFIG_ATTACH_NODE:
345                 err = pseries_add_processor(node);
346                 break;
347         case OF_RECONFIG_DETACH_NODE:
348                 pseries_remove_processor(node);
349                 break;
350         }
351         return notifier_from_errno(err);
352 }
353 
354 static struct notifier_block pseries_smp_nb = {
355         .notifier_call = pseries_smp_notifier,
356 };
357 
358 #define MAX_CEDE_LATENCY_LEVELS         4
359 #define CEDE_LATENCY_PARAM_LENGTH       10
360 #define CEDE_LATENCY_PARAM_MAX_LENGTH   \
361         (MAX_CEDE_LATENCY_LEVELS * CEDE_LATENCY_PARAM_LENGTH * sizeof(char))
362 #define CEDE_LATENCY_TOKEN              45
363 
364 static char cede_parameters[CEDE_LATENCY_PARAM_MAX_LENGTH];
365 
366 static int parse_cede_parameters(void)
367 {
368         memset(cede_parameters, 0, CEDE_LATENCY_PARAM_MAX_LENGTH);
369         return rtas_call(rtas_token("ibm,get-system-parameter"), 3, 1,
370                          NULL,
371                          CEDE_LATENCY_TOKEN,
372                          __pa(cede_parameters),
373                          CEDE_LATENCY_PARAM_MAX_LENGTH);
374 }
375 
376 static int __init pseries_cpu_hotplug_init(void)
377 {
378         struct device_node *np;
379         const char *typep;
380         int cpu;
381         int qcss_tok;
382 
383         for_each_node_by_name(np, "interrupt-controller") {
384                 typep = of_get_property(np, "compatible", NULL);
385                 if (strstr(typep, "open-pic")) {
386                         of_node_put(np);
387 
388                         printk(KERN_INFO "CPU Hotplug not supported on "
389                                 "systems using MPIC\n");
390                         return 0;
391                 }
392         }
393 
394         rtas_stop_self_args.token = rtas_token("stop-self");
395         qcss_tok = rtas_token("query-cpu-stopped-state");
396 
397         if (rtas_stop_self_args.token == RTAS_UNKNOWN_SERVICE ||
398                         qcss_tok == RTAS_UNKNOWN_SERVICE) {
399                 printk(KERN_INFO "CPU Hotplug not supported by firmware "
400                                 "- disabling.\n");
401                 return 0;
402         }
403 
404         ppc_md.cpu_die = pseries_mach_cpu_die;
405         smp_ops->cpu_disable = pseries_cpu_disable;
406         smp_ops->cpu_die = pseries_cpu_die;
407 
408         /* Processors can be added/removed only on LPAR */
409         if (firmware_has_feature(FW_FEATURE_LPAR)) {
410                 of_reconfig_notifier_register(&pseries_smp_nb);
411                 cpu_maps_update_begin();
412                 if (cede_offline_enabled && parse_cede_parameters() == 0) {
413                         default_offline_state = CPU_STATE_INACTIVE;
414                         for_each_online_cpu(cpu)
415                                 set_default_offline_state(cpu);
416                 }
417                 cpu_maps_update_done();
418         }
419 
420         return 0;
421 }
422 arch_initcall(pseries_cpu_hotplug_init);
423 

~ [ 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