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 static void pcpu_free_lowcore(struct pcpu
*pcpu
)
230 pcpu_sigp_retry(pcpu
, sigp_set_prefix
, 0);
231 lowcore_ptr
[pcpu
- pcpu_devices
] = NULL
;
233 if (MACHINE_HAS_IEEE
) {
234 struct _lowcore
*lc
= pcpu
->lowcore
;
236 free_page((unsigned long) lc
->extended_save_area_addr
);
237 lc
->extended_save_area_addr
= 0;
240 vdso_free_per_cpu(pcpu
->lowcore
);
242 if (pcpu
!= &pcpu_devices
[0]) {
243 free_page(pcpu
->panic_stack
);
244 free_pages(pcpu
->async_stack
, ASYNC_ORDER
);
245 free_pages((unsigned long) pcpu
->lowcore
, LC_ORDER
);
249 static void pcpu_prepare_secondary(struct pcpu
*pcpu
, int cpu
)
251 struct _lowcore
*lc
= pcpu
->lowcore
;
253 atomic_inc(&init_mm
.context
.attach_count
);
255 lc
->percpu_offset
= __per_cpu_offset
[cpu
];
256 lc
->kernel_asce
= S390_lowcore
.kernel_asce
;
257 lc
->machine_flags
= S390_lowcore
.machine_flags
;
258 lc
->ftrace_func
= S390_lowcore
.ftrace_func
;
259 lc
->user_timer
= lc
->system_timer
= lc
->steal_timer
= 0;
260 __ctl_store(lc
->cregs_save_area
, 0, 15);
261 save_access_regs((unsigned int *) lc
->access_regs_save_area
);
262 memcpy(lc
->stfle_fac_list
, S390_lowcore
.stfle_fac_list
,
266 static void pcpu_attach_task(struct pcpu
*pcpu
, struct task_struct
*tsk
)
268 struct _lowcore
*lc
= pcpu
->lowcore
;
269 struct thread_info
*ti
= task_thread_info(tsk
);
271 lc
->kernel_stack
= (unsigned long) task_stack_page(tsk
) + THREAD_SIZE
;
272 lc
->thread_info
= (unsigned long) task_thread_info(tsk
);
273 lc
->current_task
= (unsigned long) tsk
;
274 lc
->user_timer
= ti
->user_timer
;
275 lc
->system_timer
= ti
->system_timer
;
279 static void pcpu_start_fn(struct pcpu
*pcpu
, void (*func
)(void *), void *data
)
281 struct _lowcore
*lc
= pcpu
->lowcore
;
283 lc
->restart_stack
= lc
->kernel_stack
;
284 lc
->restart_fn
= (unsigned long) func
;
285 lc
->restart_data
= (unsigned long) data
;
286 lc
->restart_source
= -1UL;
287 pcpu_sigp_retry(pcpu
, sigp_restart
, 0);
291 * Call function via PSW restart on pcpu and stop the current cpu.
293 static void pcpu_delegate(struct pcpu
*pcpu
, void (*func
)(void *),
294 void *data
, unsigned long stack
)
296 struct _lowcore
*lc
= pcpu
->lowcore
;
297 unsigned short this_cpu
;
299 __load_psw_mask(psw_kernel_bits
);
301 if (pcpu
->address
== this_cpu
)
302 func(data
); /* should not return */
303 /* Stop target cpu (if func returns this stops the current cpu). */
304 pcpu_sigp_retry(pcpu
, sigp_stop
, 0);
305 /* Restart func on the target cpu and stop the current cpu. */
306 lc
->restart_stack
= stack
;
307 lc
->restart_fn
= (unsigned long) func
;
308 lc
->restart_data
= (unsigned long) data
;
309 lc
->restart_source
= (unsigned long) this_cpu
;
311 "0: sigp 0,%0,6 # sigp restart to target cpu\n"
312 " brc 2,0b # busy, try again\n"
313 "1: sigp 0,%1,5 # sigp stop to current cpu\n"
314 " brc 2,1b # busy, try again\n"
315 : : "d" (pcpu
->address
), "d" (this_cpu
) : "0", "1", "cc");
320 * Call function on an online CPU.
322 void smp_call_online_cpu(void (*func
)(void *), void *data
)
326 /* Use the current cpu if it is online. */
327 pcpu
= pcpu_find_address(cpu_online_mask
, stap());
329 /* Use the first online cpu. */
330 pcpu
= pcpu_devices
+ cpumask_first(cpu_online_mask
);
331 pcpu_delegate(pcpu
, func
, data
, (unsigned long) restart_stack
);
335 * Call function on the ipl CPU.
337 void smp_call_ipl_cpu(void (*func
)(void *), void *data
)
339 pcpu_delegate(&pcpu_devices
[0], func
, data
,
340 pcpu_devices
->panic_stack
+ PAGE_SIZE
);
343 int smp_find_processor_id(u16 address
)
347 for_each_present_cpu(cpu
)
348 if (pcpu_devices
[cpu
].address
== address
)
353 int smp_vcpu_scheduled(int cpu
)
355 return pcpu_running(pcpu_devices
+ cpu
);
360 if (MACHINE_HAS_DIAG44
)
361 asm volatile("diag 0,0,0x44");
364 void smp_yield_cpu(int cpu
)
366 if (MACHINE_HAS_DIAG9C
)
367 asm volatile("diag %0,0,0x9c"
368 : : "d" (pcpu_devices
[cpu
].address
));
369 else if (MACHINE_HAS_DIAG44
)
370 asm volatile("diag 0,0,0x44");
374 * Send cpus emergency shutdown signal. This gives the cpus the
375 * opportunity to complete outstanding interrupts.
377 void smp_emergency_stop(cpumask_t
*cpumask
)
382 end
= get_clock() + (1000000UL << 12);
383 for_each_cpu(cpu
, cpumask
) {
384 struct pcpu
*pcpu
= pcpu_devices
+ cpu
;
385 set_bit(ec_stop_cpu
, &pcpu
->ec_mask
);
386 while (__pcpu_sigp(pcpu
->address
, sigp_emergency_signal
,
387 0, NULL
) == sigp_busy
&&
391 while (get_clock() < end
) {
392 for_each_cpu(cpu
, cpumask
)
393 if (pcpu_stopped(pcpu_devices
+ cpu
))
394 cpumask_clear_cpu(cpu
, cpumask
);
395 if (cpumask_empty(cpumask
))
402 * Stop all cpus but the current one.
404 void smp_send_stop(void)
409 /* Disable all interrupts/machine checks */
410 __load_psw_mask(psw_kernel_bits
| PSW_MASK_DAT
);
411 trace_hardirqs_off();
413 debug_set_critical();
414 cpumask_copy(&cpumask
, cpu_online_mask
);
415 cpumask_clear_cpu(smp_processor_id(), &cpumask
);
417 if (oops_in_progress
)
418 smp_emergency_stop(&cpumask
);
420 /* stop all processors */
421 for_each_cpu(cpu
, &cpumask
) {
422 struct pcpu
*pcpu
= pcpu_devices
+ cpu
;
423 pcpu_sigp_retry(pcpu
, sigp_stop
, 0);
424 while (!pcpu_stopped(pcpu
))
430 * Stop the current cpu.
432 void smp_stop_cpu(void)
434 pcpu_sigp_retry(pcpu_devices
+ smp_processor_id(), sigp_stop
, 0);
439 * This is the main routine where commands issued by other
442 static void do_ext_call_interrupt(struct ext_code ext_code
,
443 unsigned int param32
, unsigned long param64
)
448 cpu
= smp_processor_id();
449 if (ext_code
.code
== 0x1202)
450 kstat_cpu(cpu
).irqs
[EXTINT_EXC
]++;
452 kstat_cpu(cpu
).irqs
[EXTINT_EMS
]++;
454 * handle bit signal external calls
456 bits
= xchg(&pcpu_devices
[cpu
].ec_mask
, 0);
458 if (test_bit(ec_stop_cpu
, &bits
))
461 if (test_bit(ec_schedule
, &bits
))
464 if (test_bit(ec_call_function
, &bits
))
465 generic_smp_call_function_interrupt();
467 if (test_bit(ec_call_function_single
, &bits
))
468 generic_smp_call_function_single_interrupt();
472 void arch_send_call_function_ipi_mask(const struct cpumask
*mask
)
476 for_each_cpu(cpu
, mask
)
477 pcpu_ec_call(pcpu_devices
+ cpu
, ec_call_function
);
480 void arch_send_call_function_single_ipi(int cpu
)
482 pcpu_ec_call(pcpu_devices
+ cpu
, ec_call_function_single
);
487 * this function sends a 'purge tlb' signal to another CPU.
489 static void smp_ptlb_callback(void *info
)
494 void smp_ptlb_all(void)
496 on_each_cpu(smp_ptlb_callback
, NULL
, 1);
498 EXPORT_SYMBOL(smp_ptlb_all
);
499 #endif /* ! CONFIG_64BIT */
502 * this function sends a 'reschedule' IPI to another CPU.
503 * it goes straight through and wastes no time serializing
504 * anything. Worst case is that we lose a reschedule ...
506 void smp_send_reschedule(int cpu
)
508 pcpu_ec_call(pcpu_devices
+ cpu
, ec_schedule
);
512 * parameter area for the set/clear control bit callbacks
514 struct ec_creg_mask_parms
{
516 unsigned long andval
;
521 * callback for setting/clearing control bits
523 static void smp_ctl_bit_callback(void *info
)
525 struct ec_creg_mask_parms
*pp
= info
;
526 unsigned long cregs
[16];
528 __ctl_store(cregs
, 0, 15);
529 cregs
[pp
->cr
] = (cregs
[pp
->cr
] & pp
->andval
) | pp
->orval
;
530 __ctl_load(cregs
, 0, 15);
534 * Set a bit in a control register of all cpus
536 void smp_ctl_set_bit(int cr
, int bit
)
538 struct ec_creg_mask_parms parms
= { 1UL << bit
, -1UL, cr
};
540 on_each_cpu(smp_ctl_bit_callback
, &parms
, 1);
542 EXPORT_SYMBOL(smp_ctl_set_bit
);
545 * Clear a bit in a control register of all cpus
547 void smp_ctl_clear_bit(int cr
, int bit
)
549 struct ec_creg_mask_parms parms
= { 0, ~(1UL << bit
), cr
};
551 on_each_cpu(smp_ctl_bit_callback
, &parms
, 1);
553 EXPORT_SYMBOL(smp_ctl_clear_bit
);
555 #if defined(CONFIG_ZFCPDUMP) || defined(CONFIG_CRASH_DUMP)
557 struct save_area
*zfcpdump_save_areas
[NR_CPUS
+ 1];
558 EXPORT_SYMBOL_GPL(zfcpdump_save_areas
);
560 static void __init
smp_get_save_area(int cpu
, u16 address
)
562 void *lc
= pcpu_devices
[0].lowcore
;
563 struct save_area
*save_area
;
565 if (is_kdump_kernel())
567 if (!OLDMEM_BASE
&& (address
== boot_cpu_address
||
568 ipl_info
.type
!= IPL_TYPE_FCP_DUMP
))
570 if (cpu
>= NR_CPUS
) {
571 pr_warning("CPU %i exceeds the maximum %i and is excluded "
572 "from the dump\n", cpu
, NR_CPUS
- 1);
575 save_area
= kmalloc(sizeof(struct save_area
), GFP_KERNEL
);
577 panic("could not allocate memory for save area\n");
578 zfcpdump_save_areas
[cpu
] = save_area
;
579 #ifdef CONFIG_CRASH_DUMP
580 if (address
== boot_cpu_address
) {
581 /* Copy the registers of the boot cpu. */
582 copy_oldmem_page(1, (void *) save_area
, sizeof(*save_area
),
583 SAVE_AREA_BASE
- PAGE_SIZE
, 0);
587 /* Get the registers of a non-boot cpu. */
588 __pcpu_sigp_relax(address
, sigp_stop_and_store_status
, 0, NULL
);
589 memcpy_real(save_area
, lc
+ SAVE_AREA_BASE
, sizeof(*save_area
));
592 int smp_store_status(int cpu
)
596 pcpu
= pcpu_devices
+ cpu
;
597 if (__pcpu_sigp_relax(pcpu
->address
, sigp_stop_and_store_status
,
598 0, NULL
) != sigp_order_code_accepted
)
603 #else /* CONFIG_ZFCPDUMP || CONFIG_CRASH_DUMP */
605 static inline void smp_get_save_area(int cpu
, u16 address
) { }
607 #endif /* CONFIG_ZFCPDUMP || CONFIG_CRASH_DUMP */
609 static struct sclp_cpu_info
*smp_get_cpu_info(void)
611 static int use_sigp_detection
;
612 struct sclp_cpu_info
*info
;
615 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
616 if (info
&& (use_sigp_detection
|| sclp_get_cpu_info(info
))) {
617 use_sigp_detection
= 1;
618 for (address
= 0; address
<= MAX_CPU_ADDRESS
; address
++) {
619 if (__pcpu_sigp_relax(address
, sigp_sense
, 0, NULL
) ==
620 sigp_not_operational
)
622 info
->cpu
[info
->configured
].address
= address
;
625 info
->combined
= info
->configured
;
630 static int __devinit
smp_add_present_cpu(int cpu
);
632 static int __devinit
__smp_rescan_cpus(struct sclp_cpu_info
*info
,
640 cpumask_xor(&avail
, cpu_possible_mask
, cpu_present_mask
);
641 cpu
= cpumask_first(&avail
);
642 for (i
= 0; (i
< info
->combined
) && (cpu
< nr_cpu_ids
); i
++) {
643 if (info
->has_cpu_type
&& info
->cpu
[i
].type
!= boot_cpu_type
)
645 if (pcpu_find_address(cpu_present_mask
, info
->cpu
[i
].address
))
647 pcpu
= pcpu_devices
+ cpu
;
648 pcpu
->address
= info
->cpu
[i
].address
;
649 pcpu
->state
= (cpu
>= info
->configured
) ?
650 CPU_STATE_STANDBY
: CPU_STATE_CONFIGURED
;
651 cpu_set_polarization(cpu
, POLARIZATION_UNKNOWN
);
652 set_cpu_present(cpu
, true);
653 if (sysfs_add
&& smp_add_present_cpu(cpu
) != 0)
654 set_cpu_present(cpu
, false);
657 cpu
= cpumask_next(cpu
, &avail
);
662 static void __init
smp_detect_cpus(void)
664 unsigned int cpu
, c_cpus
, s_cpus
;
665 struct sclp_cpu_info
*info
;
667 info
= smp_get_cpu_info();
669 panic("smp_detect_cpus failed to allocate memory\n");
670 if (info
->has_cpu_type
) {
671 for (cpu
= 0; cpu
< info
->combined
; cpu
++) {
672 if (info
->cpu
[cpu
].address
!= boot_cpu_address
)
674 /* The boot cpu dictates the cpu type. */
675 boot_cpu_type
= info
->cpu
[cpu
].type
;
680 for (cpu
= 0; cpu
< info
->combined
; cpu
++) {
681 if (info
->has_cpu_type
&& info
->cpu
[cpu
].type
!= boot_cpu_type
)
683 if (cpu
< info
->configured
) {
684 smp_get_save_area(c_cpus
, info
->cpu
[cpu
].address
);
689 pr_info("%d configured CPUs, %d standby CPUs\n", c_cpus
, s_cpus
);
691 __smp_rescan_cpus(info
, 0);
697 * Activate a secondary processor.
699 static void __cpuinit
smp_start_secondary(void *cpuvoid
)
701 S390_lowcore
.last_update_clock
= get_clock();
702 S390_lowcore
.restart_stack
= (unsigned long) restart_stack
;
703 S390_lowcore
.restart_fn
= (unsigned long) do_restart
;
704 S390_lowcore
.restart_data
= 0;
705 S390_lowcore
.restart_source
= -1UL;
706 restore_access_regs(S390_lowcore
.access_regs_save_area
);
707 __ctl_load(S390_lowcore
.cregs_save_area
, 0, 15);
708 __load_psw_mask(psw_kernel_bits
| PSW_MASK_DAT
);
714 notify_cpu_starting(smp_processor_id());
716 set_cpu_online(smp_processor_id(), true);
719 /* cpu_idle will call schedule for us */
723 /* Upping and downing of CPUs */
724 int __cpuinit
__cpu_up(unsigned int cpu
, struct task_struct
*tidle
)
729 pcpu
= pcpu_devices
+ cpu
;
730 if (pcpu
->state
!= CPU_STATE_CONFIGURED
)
732 if (pcpu_sigp_retry(pcpu
, sigp_initial_cpu_reset
, 0) !=
733 sigp_order_code_accepted
)
736 rc
= pcpu_alloc_lowcore(pcpu
, cpu
);
739 pcpu_prepare_secondary(pcpu
, cpu
);
740 pcpu_attach_task(pcpu
, tidle
);
741 pcpu_start_fn(pcpu
, smp_start_secondary
, NULL
);
742 while (!cpu_online(cpu
))
747 static int __init
setup_possible_cpus(char *s
)
751 if (kstrtoint(s
, 0, &max
) < 0)
753 init_cpu_possible(cpumask_of(0));
754 for (cpu
= 1; cpu
< max
&& cpu
< nr_cpu_ids
; cpu
++)
755 set_cpu_possible(cpu
, true);
758 early_param("possible_cpus", setup_possible_cpus
);
760 #ifdef CONFIG_HOTPLUG_CPU
762 int __cpu_disable(void)
764 unsigned long cregs
[16];
766 set_cpu_online(smp_processor_id(), false);
767 /* Disable pseudo page faults on this cpu. */
769 /* Disable interrupt sources via control register. */
770 __ctl_store(cregs
, 0, 15);
771 cregs
[0] &= ~0x0000ee70UL
; /* disable all external interrupts */
772 cregs
[6] &= ~0xff000000UL
; /* disable all I/O interrupts */
773 cregs
[14] &= ~0x1f000000UL
; /* disable most machine checks */
774 __ctl_load(cregs
, 0, 15);
778 void __cpu_die(unsigned int cpu
)
782 /* Wait until target cpu is down */
783 pcpu
= pcpu_devices
+ cpu
;
784 while (!pcpu_stopped(pcpu
))
786 pcpu_free_lowcore(pcpu
);
787 atomic_dec(&init_mm
.context
.attach_count
);
790 void __noreturn
cpu_die(void)
793 pcpu_sigp_retry(pcpu_devices
+ smp_processor_id(), sigp_stop
, 0);
797 #endif /* CONFIG_HOTPLUG_CPU */
799 static void smp_call_os_info_init_fn(void)
801 int (*init_fn
)(void);
804 init_fn
= os_info_old_entry(OS_INFO_INIT_FN
, &size
);
810 void __init
smp_prepare_cpus(unsigned int max_cpus
)
812 /* request the 0x1201 emergency signal external interrupt */
813 if (register_external_interrupt(0x1201, do_ext_call_interrupt
) != 0)
814 panic("Couldn't request external interrupt 0x1201");
815 /* request the 0x1202 external call external interrupt */
816 if (register_external_interrupt(0x1202, do_ext_call_interrupt
) != 0)
817 panic("Couldn't request external interrupt 0x1202");
818 smp_call_os_info_init_fn();
822 void __init
smp_prepare_boot_cpu(void)
824 struct pcpu
*pcpu
= pcpu_devices
;
826 boot_cpu_address
= stap();
827 pcpu
->state
= CPU_STATE_CONFIGURED
;
828 pcpu
->address
= boot_cpu_address
;
829 pcpu
->lowcore
= (struct _lowcore
*)(unsigned long) store_prefix();
830 pcpu
->async_stack
= S390_lowcore
.async_stack
- ASYNC_SIZE
;
831 pcpu
->panic_stack
= S390_lowcore
.panic_stack
- PAGE_SIZE
;
832 S390_lowcore
.percpu_offset
= __per_cpu_offset
[0];
833 cpu_set_polarization(0, POLARIZATION_UNKNOWN
);
834 set_cpu_present(0, true);
835 set_cpu_online(0, true);
838 void __init
smp_cpus_done(unsigned int max_cpus
)
842 void __init
smp_setup_processor_id(void)
844 S390_lowcore
.cpu_nr
= 0;
848 * the frequency of the profiling timer can be changed
849 * by writing a multiplier value into /proc/profile.
851 * usually you want to run this on all CPUs ;)
853 int setup_profiling_timer(unsigned int multiplier
)
858 #ifdef CONFIG_HOTPLUG_CPU
859 static ssize_t
cpu_configure_show(struct device
*dev
,
860 struct device_attribute
*attr
, char *buf
)
864 mutex_lock(&smp_cpu_state_mutex
);
865 count
= sprintf(buf
, "%d\n", pcpu_devices
[dev
->id
].state
);
866 mutex_unlock(&smp_cpu_state_mutex
);
870 static ssize_t
cpu_configure_store(struct device
*dev
,
871 struct device_attribute
*attr
,
872 const char *buf
, size_t count
)
878 if (sscanf(buf
, "%d %c", &val
, &delim
) != 1)
880 if (val
!= 0 && val
!= 1)
883 mutex_lock(&smp_cpu_state_mutex
);
885 /* disallow configuration changes of online cpus and cpu 0 */
887 if (cpu_online(cpu
) || cpu
== 0)
889 pcpu
= pcpu_devices
+ cpu
;
893 if (pcpu
->state
!= CPU_STATE_CONFIGURED
)
895 rc
= sclp_cpu_deconfigure(pcpu
->address
);
898 pcpu
->state
= CPU_STATE_STANDBY
;
899 cpu_set_polarization(cpu
, POLARIZATION_UNKNOWN
);
900 topology_expect_change();
903 if (pcpu
->state
!= CPU_STATE_STANDBY
)
905 rc
= sclp_cpu_configure(pcpu
->address
);
908 pcpu
->state
= CPU_STATE_CONFIGURED
;
909 cpu_set_polarization(cpu
, POLARIZATION_UNKNOWN
);
910 topology_expect_change();
916 mutex_unlock(&smp_cpu_state_mutex
);
918 return rc
? rc
: count
;
920 static DEVICE_ATTR(configure
, 0644, cpu_configure_show
, cpu_configure_store
);
921 #endif /* CONFIG_HOTPLUG_CPU */
923 static ssize_t
show_cpu_address(struct device
*dev
,
924 struct device_attribute
*attr
, char *buf
)
926 return sprintf(buf
, "%d\n", pcpu_devices
[dev
->id
].address
);
928 static DEVICE_ATTR(address
, 0444, show_cpu_address
, NULL
);
930 static struct attribute
*cpu_common_attrs
[] = {
931 #ifdef CONFIG_HOTPLUG_CPU
932 &dev_attr_configure
.attr
,
934 &dev_attr_address
.attr
,
938 static struct attribute_group cpu_common_attr_group
= {
939 .attrs
= cpu_common_attrs
,
942 static ssize_t
show_capability(struct device
*dev
,
943 struct device_attribute
*attr
, char *buf
)
945 unsigned int capability
;
948 rc
= get_cpu_capability(&capability
);
951 return sprintf(buf
, "%u\n", capability
);
953 static DEVICE_ATTR(capability
, 0444, show_capability
, NULL
);
955 static ssize_t
show_idle_count(struct device
*dev
,
956 struct device_attribute
*attr
, char *buf
)
958 struct s390_idle_data
*idle
= &per_cpu(s390_idle
, dev
->id
);
959 unsigned long long idle_count
;
960 unsigned int sequence
;
963 sequence
= ACCESS_ONCE(idle
->sequence
);
964 idle_count
= ACCESS_ONCE(idle
->idle_count
);
965 if (ACCESS_ONCE(idle
->idle_enter
))
967 } while ((sequence
& 1) || (idle
->sequence
!= sequence
));
968 return sprintf(buf
, "%llu\n", idle_count
);
970 static DEVICE_ATTR(idle_count
, 0444, show_idle_count
, NULL
);
972 static ssize_t
show_idle_time(struct device
*dev
,
973 struct device_attribute
*attr
, char *buf
)
975 struct s390_idle_data
*idle
= &per_cpu(s390_idle
, dev
->id
);
976 unsigned long long now
, idle_time
, idle_enter
, idle_exit
;
977 unsigned int sequence
;
981 sequence
= ACCESS_ONCE(idle
->sequence
);
982 idle_time
= ACCESS_ONCE(idle
->idle_time
);
983 idle_enter
= ACCESS_ONCE(idle
->idle_enter
);
984 idle_exit
= ACCESS_ONCE(idle
->idle_exit
);
985 } while ((sequence
& 1) || (idle
->sequence
!= sequence
));
986 idle_time
+= idle_enter
? ((idle_exit
? : now
) - idle_enter
) : 0;
987 return sprintf(buf
, "%llu\n", idle_time
>> 12);
989 static DEVICE_ATTR(idle_time_us
, 0444, show_idle_time
, NULL
);
991 static struct attribute
*cpu_online_attrs
[] = {
992 &dev_attr_capability
.attr
,
993 &dev_attr_idle_count
.attr
,
994 &dev_attr_idle_time_us
.attr
,
998 static struct attribute_group cpu_online_attr_group
= {
999 .attrs
= cpu_online_attrs
,
1002 static int __cpuinit
smp_cpu_notify(struct notifier_block
*self
,
1003 unsigned long action
, void *hcpu
)
1005 unsigned int cpu
= (unsigned int)(long)hcpu
;
1006 struct cpu
*c
= &pcpu_devices
[cpu
].cpu
;
1007 struct device
*s
= &c
->dev
;
1008 struct s390_idle_data
*idle
;
1013 case CPU_ONLINE_FROZEN
:
1014 idle
= &per_cpu(s390_idle
, cpu
);
1015 memset(idle
, 0, sizeof(struct s390_idle_data
));
1016 err
= sysfs_create_group(&s
->kobj
, &cpu_online_attr_group
);
1019 case CPU_DEAD_FROZEN
:
1020 sysfs_remove_group(&s
->kobj
, &cpu_online_attr_group
);
1023 return notifier_from_errno(err
);
1026 static struct notifier_block __cpuinitdata smp_cpu_nb
= {
1027 .notifier_call
= smp_cpu_notify
,
1030 static int __devinit
smp_add_present_cpu(int cpu
)
1032 struct cpu
*c
= &pcpu_devices
[cpu
].cpu
;
1033 struct device
*s
= &c
->dev
;
1036 c
->hotpluggable
= 1;
1037 rc
= register_cpu(c
, cpu
);
1040 rc
= sysfs_create_group(&s
->kobj
, &cpu_common_attr_group
);
1043 if (cpu_online(cpu
)) {
1044 rc
= sysfs_create_group(&s
->kobj
, &cpu_online_attr_group
);
1048 rc
= topology_cpu_init(c
);
1054 if (cpu_online(cpu
))
1055 sysfs_remove_group(&s
->kobj
, &cpu_online_attr_group
);
1057 sysfs_remove_group(&s
->kobj
, &cpu_common_attr_group
);
1059 #ifdef CONFIG_HOTPLUG_CPU
1066 #ifdef CONFIG_HOTPLUG_CPU
1068 int __ref
smp_rescan_cpus(void)
1070 struct sclp_cpu_info
*info
;
1073 info
= smp_get_cpu_info();
1077 mutex_lock(&smp_cpu_state_mutex
);
1078 nr
= __smp_rescan_cpus(info
, 1);
1079 mutex_unlock(&smp_cpu_state_mutex
);
1083 topology_schedule_update();
1087 static ssize_t __ref
rescan_store(struct device
*dev
,
1088 struct device_attribute
*attr
,
1094 rc
= smp_rescan_cpus();
1095 return rc
? rc
: count
;
1097 static DEVICE_ATTR(rescan
, 0200, NULL
, rescan_store
);
1098 #endif /* CONFIG_HOTPLUG_CPU */
1100 static int __init
s390_smp_init(void)
1104 register_cpu_notifier(&smp_cpu_nb
);
1105 #ifdef CONFIG_HOTPLUG_CPU
1106 rc
= device_create_file(cpu_subsys
.dev_root
, &dev_attr_rescan
);
1110 for_each_present_cpu(cpu
) {
1111 rc
= smp_add_present_cpu(cpu
);
1117 subsys_initcall(s390_smp_init
);