2 * SMP related functions
4 * Copyright IBM Corp. 1999,2012
5 * Author(s): Denis Joseph Barrow,
6 * Martin Schwidefsky <schwidefsky@de.ibm.com>,
7 * Heiko Carstens <heiko.carstens@de.ibm.com>,
9 * based on other smp stuff by
10 * (c) 1995 Alan Cox, CymruNET Ltd <alan@cymru.net>
11 * (c) 1998 Ingo Molnar
13 * The code outside of smp.c uses logical cpu numbers, only smp.c does
14 * the translation of logical to physical cpu ids. All new code that
15 * operates on physical cpu numbers needs to go into smp.c.
18 #define KMSG_COMPONENT "cpu"
19 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
21 #include <linux/workqueue.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
25 #include <linux/err.h>
26 #include <linux/spinlock.h>
27 #include <linux/kernel_stat.h>
28 #include <linux/delay.h>
29 #include <linux/interrupt.h>
30 #include <linux/irqflags.h>
31 #include <linux/cpu.h>
32 #include <linux/slab.h>
33 #include <linux/crash_dump.h>
34 #include <asm/asm-offsets.h>
35 #include <asm/switch_to.h>
36 #include <asm/facility.h>
38 #include <asm/setup.h>
40 #include <asm/tlbflush.h>
41 #include <asm/timer.h>
42 #include <asm/lowcore.h>
45 #include <asm/debug.h>
46 #include <asm/os_info.h>
51 sigp_external_call
= 2,
52 sigp_emergency_signal
= 3,
56 sigp_stop_and_store_status
= 9,
57 sigp_initial_cpu_reset
= 11,
60 sigp_store_status_at_address
= 14,
61 sigp_store_extended_status_at_address
= 15,
62 sigp_set_architecture
= 18,
63 sigp_conditional_emergency_signal
= 19,
64 sigp_sense_running
= 21,
68 sigp_order_code_accepted
= 0,
69 sigp_status_stored
= 1,
71 sigp_not_operational
= 3,
77 ec_call_function_single
,
88 struct _lowcore
*lowcore
; /* lowcore page(s) for the cpu */
89 unsigned long async_stack
; /* async stack for the cpu */
90 unsigned long panic_stack
; /* panic stack for the cpu */
91 unsigned long ec_mask
; /* bit mask for ec_xxx functions */
92 int state
; /* physical cpu state */
93 u32 status
; /* last status received via sigp */
94 u16 address
; /* physical cpu address */
97 static u8 boot_cpu_type
;
98 static u16 boot_cpu_address
;
99 static struct pcpu pcpu_devices
[NR_CPUS
];
101 DEFINE_MUTEX(smp_cpu_state_mutex
);
104 * Signal processor helper functions.
106 static inline int __pcpu_sigp(u16 addr
, u8 order
, u32 parm
, u32
*status
)
108 register unsigned int reg1
asm ("1") = parm
;
112 " sigp %1,%2,0(%3)\n"
115 : "=d" (cc
), "+d" (reg1
) : "d" (addr
), "a" (order
) : "cc");
116 if (status
&& cc
== 1)
121 static inline int __pcpu_sigp_relax(u16 addr
, u8 order
, u32 parm
, u32
*status
)
126 cc
= __pcpu_sigp(addr
, order
, parm
, status
);
133 static int pcpu_sigp_retry(struct pcpu
*pcpu
, u8 order
, u32 parm
)
137 for (retry
= 0; ; retry
++) {
138 cc
= __pcpu_sigp(pcpu
->address
, order
, parm
, &pcpu
->status
);
147 static inline int pcpu_stopped(struct pcpu
*pcpu
)
149 if (__pcpu_sigp(pcpu
->address
, sigp_sense
,
150 0, &pcpu
->status
) != sigp_status_stored
)
152 /* Check for stopped and check stop state */
153 return !!(pcpu
->status
& 0x50);
156 static inline int pcpu_running(struct pcpu
*pcpu
)
158 if (__pcpu_sigp(pcpu
->address
, sigp_sense_running
,
159 0, &pcpu
->status
) != sigp_status_stored
)
161 /* Check for running status */
162 return !(pcpu
->status
& 0x400);
166 * Find struct pcpu by cpu address.
168 static struct pcpu
*pcpu_find_address(const struct cpumask
*mask
, int address
)
172 for_each_cpu(cpu
, mask
)
173 if (pcpu_devices
[cpu
].address
== address
)
174 return pcpu_devices
+ cpu
;
178 static void pcpu_ec_call(struct pcpu
*pcpu
, int ec_bit
)
182 set_bit(ec_bit
, &pcpu
->ec_mask
);
183 order
= pcpu_running(pcpu
) ?
184 sigp_external_call
: sigp_emergency_signal
;
185 pcpu_sigp_retry(pcpu
, order
, 0);
188 static int __cpuinit
pcpu_alloc_lowcore(struct pcpu
*pcpu
, int cpu
)
192 if (pcpu
!= &pcpu_devices
[0]) {
193 pcpu
->lowcore
= (struct _lowcore
*)
194 __get_free_pages(GFP_KERNEL
| GFP_DMA
, LC_ORDER
);
195 pcpu
->async_stack
= __get_free_pages(GFP_KERNEL
, ASYNC_ORDER
);
196 pcpu
->panic_stack
= __get_free_page(GFP_KERNEL
);
197 if (!pcpu
->lowcore
|| !pcpu
->panic_stack
|| !pcpu
->async_stack
)
201 memcpy(lc
, &S390_lowcore
, 512);
202 memset((char *) lc
+ 512, 0, sizeof(*lc
) - 512);
203 lc
->async_stack
= pcpu
->async_stack
+ ASYNC_SIZE
;
204 lc
->panic_stack
= pcpu
->panic_stack
+ PAGE_SIZE
;
207 if (MACHINE_HAS_IEEE
) {
208 lc
->extended_save_area_addr
= get_zeroed_page(GFP_KERNEL
);
209 if (!lc
->extended_save_area_addr
)
213 if (vdso_alloc_per_cpu(lc
))
216 lowcore_ptr
[cpu
] = lc
;
217 pcpu_sigp_retry(pcpu
, sigp_set_prefix
, (u32
)(unsigned long) lc
);
220 if (pcpu
!= &pcpu_devices
[0]) {
221 free_page(pcpu
->panic_stack
);
222 free_pages(pcpu
->async_stack
, ASYNC_ORDER
);
223 free_pages((unsigned long) pcpu
->lowcore
, LC_ORDER
);
228 #ifdef CONFIG_HOTPLUG_CPU
230 static void pcpu_free_lowcore(struct pcpu
*pcpu
)
232 pcpu_sigp_retry(pcpu
, sigp_set_prefix
, 0);
233 lowcore_ptr
[pcpu
- pcpu_devices
] = NULL
;
235 if (MACHINE_HAS_IEEE
) {
236 struct _lowcore
*lc
= pcpu
->lowcore
;
238 free_page((unsigned long) lc
->extended_save_area_addr
);
239 lc
->extended_save_area_addr
= 0;
242 vdso_free_per_cpu(pcpu
->lowcore
);
244 if (pcpu
!= &pcpu_devices
[0]) {
245 free_page(pcpu
->panic_stack
);
246 free_pages(pcpu
->async_stack
, ASYNC_ORDER
);
247 free_pages((unsigned long) pcpu
->lowcore
, LC_ORDER
);
251 #endif /* CONFIG_HOTPLUG_CPU */
253 static void pcpu_prepare_secondary(struct pcpu
*pcpu
, int cpu
)
255 struct _lowcore
*lc
= pcpu
->lowcore
;
257 atomic_inc(&init_mm
.context
.attach_count
);
259 lc
->percpu_offset
= __per_cpu_offset
[cpu
];
260 lc
->kernel_asce
= S390_lowcore
.kernel_asce
;
261 lc
->machine_flags
= S390_lowcore
.machine_flags
;
262 lc
->ftrace_func
= S390_lowcore
.ftrace_func
;
263 lc
->user_timer
= lc
->system_timer
= lc
->steal_timer
= 0;
264 __ctl_store(lc
->cregs_save_area
, 0, 15);
265 save_access_regs((unsigned int *) lc
->access_regs_save_area
);
266 memcpy(lc
->stfle_fac_list
, S390_lowcore
.stfle_fac_list
,
270 static void pcpu_attach_task(struct pcpu
*pcpu
, struct task_struct
*tsk
)
272 struct _lowcore
*lc
= pcpu
->lowcore
;
273 struct thread_info
*ti
= task_thread_info(tsk
);
275 lc
->kernel_stack
= (unsigned long) task_stack_page(tsk
) + THREAD_SIZE
;
276 lc
->thread_info
= (unsigned long) task_thread_info(tsk
);
277 lc
->current_task
= (unsigned long) tsk
;
278 lc
->user_timer
= ti
->user_timer
;
279 lc
->system_timer
= ti
->system_timer
;
283 static void pcpu_start_fn(struct pcpu
*pcpu
, void (*func
)(void *), void *data
)
285 struct _lowcore
*lc
= pcpu
->lowcore
;
287 lc
->restart_stack
= lc
->kernel_stack
;
288 lc
->restart_fn
= (unsigned long) func
;
289 lc
->restart_data
= (unsigned long) data
;
290 lc
->restart_source
= -1UL;
291 pcpu_sigp_retry(pcpu
, sigp_restart
, 0);
295 * Call function via PSW restart on pcpu and stop the current cpu.
297 static void pcpu_delegate(struct pcpu
*pcpu
, void (*func
)(void *),
298 void *data
, unsigned long stack
)
300 struct _lowcore
*lc
= pcpu
->lowcore
;
301 unsigned short this_cpu
;
303 __load_psw_mask(psw_kernel_bits
);
305 if (pcpu
->address
== this_cpu
)
306 func(data
); /* should not return */
307 /* Stop target cpu (if func returns this stops the current cpu). */
308 pcpu_sigp_retry(pcpu
, sigp_stop
, 0);
309 /* Restart func on the target cpu and stop the current cpu. */
310 lc
->restart_stack
= stack
;
311 lc
->restart_fn
= (unsigned long) func
;
312 lc
->restart_data
= (unsigned long) data
;
313 lc
->restart_source
= (unsigned long) this_cpu
;
315 "0: sigp 0,%0,6 # sigp restart to target cpu\n"
316 " brc 2,0b # busy, try again\n"
317 "1: sigp 0,%1,5 # sigp stop to current cpu\n"
318 " brc 2,1b # busy, try again\n"
319 : : "d" (pcpu
->address
), "d" (this_cpu
) : "0", "1", "cc");
324 * Call function on an online CPU.
326 void smp_call_online_cpu(void (*func
)(void *), void *data
)
330 /* Use the current cpu if it is online. */
331 pcpu
= pcpu_find_address(cpu_online_mask
, stap());
333 /* Use the first online cpu. */
334 pcpu
= pcpu_devices
+ cpumask_first(cpu_online_mask
);
335 pcpu_delegate(pcpu
, func
, data
, (unsigned long) restart_stack
);
339 * Call function on the ipl CPU.
341 void smp_call_ipl_cpu(void (*func
)(void *), void *data
)
343 pcpu_delegate(&pcpu_devices
[0], func
, data
,
344 pcpu_devices
->panic_stack
+ PAGE_SIZE
);
347 int smp_find_processor_id(u16 address
)
351 for_each_present_cpu(cpu
)
352 if (pcpu_devices
[cpu
].address
== address
)
357 int smp_vcpu_scheduled(int cpu
)
359 return pcpu_running(pcpu_devices
+ cpu
);
364 if (MACHINE_HAS_DIAG44
)
365 asm volatile("diag 0,0,0x44");
368 void smp_yield_cpu(int cpu
)
370 if (MACHINE_HAS_DIAG9C
)
371 asm volatile("diag %0,0,0x9c"
372 : : "d" (pcpu_devices
[cpu
].address
));
373 else if (MACHINE_HAS_DIAG44
)
374 asm volatile("diag 0,0,0x44");
378 * Send cpus emergency shutdown signal. This gives the cpus the
379 * opportunity to complete outstanding interrupts.
381 void smp_emergency_stop(cpumask_t
*cpumask
)
386 end
= get_clock() + (1000000UL << 12);
387 for_each_cpu(cpu
, cpumask
) {
388 struct pcpu
*pcpu
= pcpu_devices
+ cpu
;
389 set_bit(ec_stop_cpu
, &pcpu
->ec_mask
);
390 while (__pcpu_sigp(pcpu
->address
, sigp_emergency_signal
,
391 0, NULL
) == sigp_busy
&&
395 while (get_clock() < end
) {
396 for_each_cpu(cpu
, cpumask
)
397 if (pcpu_stopped(pcpu_devices
+ cpu
))
398 cpumask_clear_cpu(cpu
, cpumask
);
399 if (cpumask_empty(cpumask
))
406 * Stop all cpus but the current one.
408 void smp_send_stop(void)
413 /* Disable all interrupts/machine checks */
414 __load_psw_mask(psw_kernel_bits
| PSW_MASK_DAT
);
415 trace_hardirqs_off();
417 debug_set_critical();
418 cpumask_copy(&cpumask
, cpu_online_mask
);
419 cpumask_clear_cpu(smp_processor_id(), &cpumask
);
421 if (oops_in_progress
)
422 smp_emergency_stop(&cpumask
);
424 /* stop all processors */
425 for_each_cpu(cpu
, &cpumask
) {
426 struct pcpu
*pcpu
= pcpu_devices
+ cpu
;
427 pcpu_sigp_retry(pcpu
, sigp_stop
, 0);
428 while (!pcpu_stopped(pcpu
))
434 * Stop the current cpu.
436 void smp_stop_cpu(void)
438 pcpu_sigp_retry(pcpu_devices
+ smp_processor_id(), sigp_stop
, 0);
443 * This is the main routine where commands issued by other
446 static void do_ext_call_interrupt(struct ext_code ext_code
,
447 unsigned int param32
, unsigned long param64
)
452 cpu
= smp_processor_id();
453 if (ext_code
.code
== 0x1202)
454 kstat_cpu(cpu
).irqs
[EXTINT_EXC
]++;
456 kstat_cpu(cpu
).irqs
[EXTINT_EMS
]++;
458 * handle bit signal external calls
460 bits
= xchg(&pcpu_devices
[cpu
].ec_mask
, 0);
462 if (test_bit(ec_stop_cpu
, &bits
))
465 if (test_bit(ec_schedule
, &bits
))
468 if (test_bit(ec_call_function
, &bits
))
469 generic_smp_call_function_interrupt();
471 if (test_bit(ec_call_function_single
, &bits
))
472 generic_smp_call_function_single_interrupt();
476 void arch_send_call_function_ipi_mask(const struct cpumask
*mask
)
480 for_each_cpu(cpu
, mask
)
481 pcpu_ec_call(pcpu_devices
+ cpu
, ec_call_function
);
484 void arch_send_call_function_single_ipi(int cpu
)
486 pcpu_ec_call(pcpu_devices
+ cpu
, ec_call_function_single
);
491 * this function sends a 'purge tlb' signal to another CPU.
493 static void smp_ptlb_callback(void *info
)
498 void smp_ptlb_all(void)
500 on_each_cpu(smp_ptlb_callback
, NULL
, 1);
502 EXPORT_SYMBOL(smp_ptlb_all
);
503 #endif /* ! CONFIG_64BIT */
506 * this function sends a 'reschedule' IPI to another CPU.
507 * it goes straight through and wastes no time serializing
508 * anything. Worst case is that we lose a reschedule ...
510 void smp_send_reschedule(int cpu
)
512 pcpu_ec_call(pcpu_devices
+ cpu
, ec_schedule
);
516 * parameter area for the set/clear control bit callbacks
518 struct ec_creg_mask_parms
{
520 unsigned long andval
;
525 * callback for setting/clearing control bits
527 static void smp_ctl_bit_callback(void *info
)
529 struct ec_creg_mask_parms
*pp
= info
;
530 unsigned long cregs
[16];
532 __ctl_store(cregs
, 0, 15);
533 cregs
[pp
->cr
] = (cregs
[pp
->cr
] & pp
->andval
) | pp
->orval
;
534 __ctl_load(cregs
, 0, 15);
538 * Set a bit in a control register of all cpus
540 void smp_ctl_set_bit(int cr
, int bit
)
542 struct ec_creg_mask_parms parms
= { 1UL << bit
, -1UL, cr
};
544 on_each_cpu(smp_ctl_bit_callback
, &parms
, 1);
546 EXPORT_SYMBOL(smp_ctl_set_bit
);
549 * Clear a bit in a control register of all cpus
551 void smp_ctl_clear_bit(int cr
, int bit
)
553 struct ec_creg_mask_parms parms
= { 0, ~(1UL << bit
), cr
};
555 on_each_cpu(smp_ctl_bit_callback
, &parms
, 1);
557 EXPORT_SYMBOL(smp_ctl_clear_bit
);
559 #if defined(CONFIG_ZFCPDUMP) || defined(CONFIG_CRASH_DUMP)
561 struct save_area
*zfcpdump_save_areas
[NR_CPUS
+ 1];
562 EXPORT_SYMBOL_GPL(zfcpdump_save_areas
);
564 static void __init
smp_get_save_area(int cpu
, u16 address
)
566 void *lc
= pcpu_devices
[0].lowcore
;
567 struct save_area
*save_area
;
569 if (is_kdump_kernel())
571 if (!OLDMEM_BASE
&& (address
== boot_cpu_address
||
572 ipl_info
.type
!= IPL_TYPE_FCP_DUMP
))
574 if (cpu
>= NR_CPUS
) {
575 pr_warning("CPU %i exceeds the maximum %i and is excluded "
576 "from the dump\n", cpu
, NR_CPUS
- 1);
579 save_area
= kmalloc(sizeof(struct save_area
), GFP_KERNEL
);
581 panic("could not allocate memory for save area\n");
582 zfcpdump_save_areas
[cpu
] = save_area
;
583 #ifdef CONFIG_CRASH_DUMP
584 if (address
== boot_cpu_address
) {
585 /* Copy the registers of the boot cpu. */
586 copy_oldmem_page(1, (void *) save_area
, sizeof(*save_area
),
587 SAVE_AREA_BASE
- PAGE_SIZE
, 0);
591 /* Get the registers of a non-boot cpu. */
592 __pcpu_sigp_relax(address
, sigp_stop_and_store_status
, 0, NULL
);
593 memcpy_real(save_area
, lc
+ SAVE_AREA_BASE
, sizeof(*save_area
));
596 int smp_store_status(int cpu
)
600 pcpu
= pcpu_devices
+ cpu
;
601 if (__pcpu_sigp_relax(pcpu
->address
, sigp_stop_and_store_status
,
602 0, NULL
) != sigp_order_code_accepted
)
607 #else /* CONFIG_ZFCPDUMP || CONFIG_CRASH_DUMP */
609 static inline void smp_get_save_area(int cpu
, u16 address
) { }
611 #endif /* CONFIG_ZFCPDUMP || CONFIG_CRASH_DUMP */
613 static struct sclp_cpu_info
*smp_get_cpu_info(void)
615 static int use_sigp_detection
;
616 struct sclp_cpu_info
*info
;
619 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
620 if (info
&& (use_sigp_detection
|| sclp_get_cpu_info(info
))) {
621 use_sigp_detection
= 1;
622 for (address
= 0; address
<= MAX_CPU_ADDRESS
; address
++) {
623 if (__pcpu_sigp_relax(address
, sigp_sense
, 0, NULL
) ==
624 sigp_not_operational
)
626 info
->cpu
[info
->configured
].address
= address
;
629 info
->combined
= info
->configured
;
634 static int __devinit
smp_add_present_cpu(int cpu
);
636 static int __devinit
__smp_rescan_cpus(struct sclp_cpu_info
*info
,
644 cpumask_xor(&avail
, cpu_possible_mask
, cpu_present_mask
);
645 cpu
= cpumask_first(&avail
);
646 for (i
= 0; (i
< info
->combined
) && (cpu
< nr_cpu_ids
); i
++) {
647 if (info
->has_cpu_type
&& info
->cpu
[i
].type
!= boot_cpu_type
)
649 if (pcpu_find_address(cpu_present_mask
, info
->cpu
[i
].address
))
651 pcpu
= pcpu_devices
+ cpu
;
652 pcpu
->address
= info
->cpu
[i
].address
;
653 pcpu
->state
= (cpu
>= info
->configured
) ?
654 CPU_STATE_STANDBY
: CPU_STATE_CONFIGURED
;
655 cpu_set_polarization(cpu
, POLARIZATION_UNKNOWN
);
656 set_cpu_present(cpu
, true);
657 if (sysfs_add
&& smp_add_present_cpu(cpu
) != 0)
658 set_cpu_present(cpu
, false);
661 cpu
= cpumask_next(cpu
, &avail
);
666 static void __init
smp_detect_cpus(void)
668 unsigned int cpu
, c_cpus
, s_cpus
;
669 struct sclp_cpu_info
*info
;
671 info
= smp_get_cpu_info();
673 panic("smp_detect_cpus failed to allocate memory\n");
674 if (info
->has_cpu_type
) {
675 for (cpu
= 0; cpu
< info
->combined
; cpu
++) {
676 if (info
->cpu
[cpu
].address
!= boot_cpu_address
)
678 /* The boot cpu dictates the cpu type. */
679 boot_cpu_type
= info
->cpu
[cpu
].type
;
684 for (cpu
= 0; cpu
< info
->combined
; cpu
++) {
685 if (info
->has_cpu_type
&& info
->cpu
[cpu
].type
!= boot_cpu_type
)
687 if (cpu
< info
->configured
) {
688 smp_get_save_area(c_cpus
, info
->cpu
[cpu
].address
);
693 pr_info("%d configured CPUs, %d standby CPUs\n", c_cpus
, s_cpus
);
695 __smp_rescan_cpus(info
, 0);
701 * Activate a secondary processor.
703 static void __cpuinit
smp_start_secondary(void *cpuvoid
)
705 S390_lowcore
.last_update_clock
= get_clock();
706 S390_lowcore
.restart_stack
= (unsigned long) restart_stack
;
707 S390_lowcore
.restart_fn
= (unsigned long) do_restart
;
708 S390_lowcore
.restart_data
= 0;
709 S390_lowcore
.restart_source
= -1UL;
710 restore_access_regs(S390_lowcore
.access_regs_save_area
);
711 __ctl_load(S390_lowcore
.cregs_save_area
, 0, 15);
712 __load_psw_mask(psw_kernel_bits
| PSW_MASK_DAT
);
718 notify_cpu_starting(smp_processor_id());
720 set_cpu_online(smp_processor_id(), true);
723 /* cpu_idle will call schedule for us */
727 /* Upping and downing of CPUs */
728 int __cpuinit
__cpu_up(unsigned int cpu
, struct task_struct
*tidle
)
733 pcpu
= pcpu_devices
+ cpu
;
734 if (pcpu
->state
!= CPU_STATE_CONFIGURED
)
736 if (pcpu_sigp_retry(pcpu
, sigp_initial_cpu_reset
, 0) !=
737 sigp_order_code_accepted
)
740 rc
= pcpu_alloc_lowcore(pcpu
, cpu
);
743 pcpu_prepare_secondary(pcpu
, cpu
);
744 pcpu_attach_task(pcpu
, tidle
);
745 pcpu_start_fn(pcpu
, smp_start_secondary
, NULL
);
746 while (!cpu_online(cpu
))
751 static int __init
setup_possible_cpus(char *s
)
755 if (kstrtoint(s
, 0, &max
) < 0)
757 init_cpu_possible(cpumask_of(0));
758 for (cpu
= 1; cpu
< max
&& cpu
< nr_cpu_ids
; cpu
++)
759 set_cpu_possible(cpu
, true);
762 early_param("possible_cpus", setup_possible_cpus
);
764 #ifdef CONFIG_HOTPLUG_CPU
766 int __cpu_disable(void)
768 unsigned long cregs
[16];
770 set_cpu_online(smp_processor_id(), false);
771 /* Disable pseudo page faults on this cpu. */
773 /* Disable interrupt sources via control register. */
774 __ctl_store(cregs
, 0, 15);
775 cregs
[0] &= ~0x0000ee70UL
; /* disable all external interrupts */
776 cregs
[6] &= ~0xff000000UL
; /* disable all I/O interrupts */
777 cregs
[14] &= ~0x1f000000UL
; /* disable most machine checks */
778 __ctl_load(cregs
, 0, 15);
782 void __cpu_die(unsigned int cpu
)
786 /* Wait until target cpu is down */
787 pcpu
= pcpu_devices
+ cpu
;
788 while (!pcpu_stopped(pcpu
))
790 pcpu_free_lowcore(pcpu
);
791 atomic_dec(&init_mm
.context
.attach_count
);
794 void __noreturn
cpu_die(void)
797 pcpu_sigp_retry(pcpu_devices
+ smp_processor_id(), sigp_stop
, 0);
801 #endif /* CONFIG_HOTPLUG_CPU */
803 static void smp_call_os_info_init_fn(void)
805 int (*init_fn
)(void);
808 init_fn
= os_info_old_entry(OS_INFO_INIT_FN
, &size
);
814 void __init
smp_prepare_cpus(unsigned int max_cpus
)
816 /* request the 0x1201 emergency signal external interrupt */
817 if (register_external_interrupt(0x1201, do_ext_call_interrupt
) != 0)
818 panic("Couldn't request external interrupt 0x1201");
819 /* request the 0x1202 external call external interrupt */
820 if (register_external_interrupt(0x1202, do_ext_call_interrupt
) != 0)
821 panic("Couldn't request external interrupt 0x1202");
822 smp_call_os_info_init_fn();
826 void __init
smp_prepare_boot_cpu(void)
828 struct pcpu
*pcpu
= pcpu_devices
;
830 boot_cpu_address
= stap();
831 pcpu
->state
= CPU_STATE_CONFIGURED
;
832 pcpu
->address
= boot_cpu_address
;
833 pcpu
->lowcore
= (struct _lowcore
*)(unsigned long) store_prefix();
834 pcpu
->async_stack
= S390_lowcore
.async_stack
- ASYNC_SIZE
;
835 pcpu
->panic_stack
= S390_lowcore
.panic_stack
- PAGE_SIZE
;
836 S390_lowcore
.percpu_offset
= __per_cpu_offset
[0];
837 cpu_set_polarization(0, POLARIZATION_UNKNOWN
);
838 set_cpu_present(0, true);
839 set_cpu_online(0, true);
842 void __init
smp_cpus_done(unsigned int max_cpus
)
846 void __init
smp_setup_processor_id(void)
848 S390_lowcore
.cpu_nr
= 0;
852 * the frequency of the profiling timer can be changed
853 * by writing a multiplier value into /proc/profile.
855 * usually you want to run this on all CPUs ;)
857 int setup_profiling_timer(unsigned int multiplier
)
862 #ifdef CONFIG_HOTPLUG_CPU
863 static ssize_t
cpu_configure_show(struct device
*dev
,
864 struct device_attribute
*attr
, char *buf
)
868 mutex_lock(&smp_cpu_state_mutex
);
869 count
= sprintf(buf
, "%d\n", pcpu_devices
[dev
->id
].state
);
870 mutex_unlock(&smp_cpu_state_mutex
);
874 static ssize_t
cpu_configure_store(struct device
*dev
,
875 struct device_attribute
*attr
,
876 const char *buf
, size_t count
)
882 if (sscanf(buf
, "%d %c", &val
, &delim
) != 1)
884 if (val
!= 0 && val
!= 1)
887 mutex_lock(&smp_cpu_state_mutex
);
889 /* disallow configuration changes of online cpus and cpu 0 */
891 if (cpu_online(cpu
) || cpu
== 0)
893 pcpu
= pcpu_devices
+ cpu
;
897 if (pcpu
->state
!= CPU_STATE_CONFIGURED
)
899 rc
= sclp_cpu_deconfigure(pcpu
->address
);
902 pcpu
->state
= CPU_STATE_STANDBY
;
903 cpu_set_polarization(cpu
, POLARIZATION_UNKNOWN
);
904 topology_expect_change();
907 if (pcpu
->state
!= CPU_STATE_STANDBY
)
909 rc
= sclp_cpu_configure(pcpu
->address
);
912 pcpu
->state
= CPU_STATE_CONFIGURED
;
913 cpu_set_polarization(cpu
, POLARIZATION_UNKNOWN
);
914 topology_expect_change();
920 mutex_unlock(&smp_cpu_state_mutex
);
922 return rc
? rc
: count
;
924 static DEVICE_ATTR(configure
, 0644, cpu_configure_show
, cpu_configure_store
);
925 #endif /* CONFIG_HOTPLUG_CPU */
927 static ssize_t
show_cpu_address(struct device
*dev
,
928 struct device_attribute
*attr
, char *buf
)
930 return sprintf(buf
, "%d\n", pcpu_devices
[dev
->id
].address
);
932 static DEVICE_ATTR(address
, 0444, show_cpu_address
, NULL
);
934 static struct attribute
*cpu_common_attrs
[] = {
935 #ifdef CONFIG_HOTPLUG_CPU
936 &dev_attr_configure
.attr
,
938 &dev_attr_address
.attr
,
942 static struct attribute_group cpu_common_attr_group
= {
943 .attrs
= cpu_common_attrs
,
946 static ssize_t
show_capability(struct device
*dev
,
947 struct device_attribute
*attr
, char *buf
)
949 unsigned int capability
;
952 rc
= get_cpu_capability(&capability
);
955 return sprintf(buf
, "%u\n", capability
);
957 static DEVICE_ATTR(capability
, 0444, show_capability
, NULL
);
959 static ssize_t
show_idle_count(struct device
*dev
,
960 struct device_attribute
*attr
, char *buf
)
962 struct s390_idle_data
*idle
= &per_cpu(s390_idle
, dev
->id
);
963 unsigned long long idle_count
;
964 unsigned int sequence
;
967 sequence
= ACCESS_ONCE(idle
->sequence
);
968 idle_count
= ACCESS_ONCE(idle
->idle_count
);
969 if (ACCESS_ONCE(idle
->idle_enter
))
971 } while ((sequence
& 1) || (idle
->sequence
!= sequence
));
972 return sprintf(buf
, "%llu\n", idle_count
);
974 static DEVICE_ATTR(idle_count
, 0444, show_idle_count
, NULL
);
976 static ssize_t
show_idle_time(struct device
*dev
,
977 struct device_attribute
*attr
, char *buf
)
979 struct s390_idle_data
*idle
= &per_cpu(s390_idle
, dev
->id
);
980 unsigned long long now
, idle_time
, idle_enter
, idle_exit
;
981 unsigned int sequence
;
985 sequence
= ACCESS_ONCE(idle
->sequence
);
986 idle_time
= ACCESS_ONCE(idle
->idle_time
);
987 idle_enter
= ACCESS_ONCE(idle
->idle_enter
);
988 idle_exit
= ACCESS_ONCE(idle
->idle_exit
);
989 } while ((sequence
& 1) || (idle
->sequence
!= sequence
));
990 idle_time
+= idle_enter
? ((idle_exit
? : now
) - idle_enter
) : 0;
991 return sprintf(buf
, "%llu\n", idle_time
>> 12);
993 static DEVICE_ATTR(idle_time_us
, 0444, show_idle_time
, NULL
);
995 static struct attribute
*cpu_online_attrs
[] = {
996 &dev_attr_capability
.attr
,
997 &dev_attr_idle_count
.attr
,
998 &dev_attr_idle_time_us
.attr
,
1002 static struct attribute_group cpu_online_attr_group
= {
1003 .attrs
= cpu_online_attrs
,
1006 static int __cpuinit
smp_cpu_notify(struct notifier_block
*self
,
1007 unsigned long action
, void *hcpu
)
1009 unsigned int cpu
= (unsigned int)(long)hcpu
;
1010 struct cpu
*c
= &pcpu_devices
[cpu
].cpu
;
1011 struct device
*s
= &c
->dev
;
1012 struct s390_idle_data
*idle
;
1017 case CPU_ONLINE_FROZEN
:
1018 idle
= &per_cpu(s390_idle
, cpu
);
1019 memset(idle
, 0, sizeof(struct s390_idle_data
));
1020 err
= sysfs_create_group(&s
->kobj
, &cpu_online_attr_group
);
1023 case CPU_DEAD_FROZEN
:
1024 sysfs_remove_group(&s
->kobj
, &cpu_online_attr_group
);
1027 return notifier_from_errno(err
);
1030 static struct notifier_block __cpuinitdata smp_cpu_nb
= {
1031 .notifier_call
= smp_cpu_notify
,
1034 static int __devinit
smp_add_present_cpu(int cpu
)
1036 struct cpu
*c
= &pcpu_devices
[cpu
].cpu
;
1037 struct device
*s
= &c
->dev
;
1040 c
->hotpluggable
= 1;
1041 rc
= register_cpu(c
, cpu
);
1044 rc
= sysfs_create_group(&s
->kobj
, &cpu_common_attr_group
);
1047 if (cpu_online(cpu
)) {
1048 rc
= sysfs_create_group(&s
->kobj
, &cpu_online_attr_group
);
1052 rc
= topology_cpu_init(c
);
1058 if (cpu_online(cpu
))
1059 sysfs_remove_group(&s
->kobj
, &cpu_online_attr_group
);
1061 sysfs_remove_group(&s
->kobj
, &cpu_common_attr_group
);
1063 #ifdef CONFIG_HOTPLUG_CPU
1070 #ifdef CONFIG_HOTPLUG_CPU
1072 int __ref
smp_rescan_cpus(void)
1074 struct sclp_cpu_info
*info
;
1077 info
= smp_get_cpu_info();
1081 mutex_lock(&smp_cpu_state_mutex
);
1082 nr
= __smp_rescan_cpus(info
, 1);
1083 mutex_unlock(&smp_cpu_state_mutex
);
1087 topology_schedule_update();
1091 static ssize_t __ref
rescan_store(struct device
*dev
,
1092 struct device_attribute
*attr
,
1098 rc
= smp_rescan_cpus();
1099 return rc
? rc
: count
;
1101 static DEVICE_ATTR(rescan
, 0200, NULL
, rescan_store
);
1102 #endif /* CONFIG_HOTPLUG_CPU */
1104 static int __init
s390_smp_init(void)
1108 register_cpu_notifier(&smp_cpu_nb
);
1109 #ifdef CONFIG_HOTPLUG_CPU
1110 rc
= device_create_file(cpu_subsys
.dev_root
, &dev_attr_rescan
);
1114 for_each_present_cpu(cpu
) {
1115 rc
= smp_add_present_cpu(cpu
);
1121 subsys_initcall(s390_smp_init
);