hotplug-cpu.c

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