1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/acpi.h>
21#include <linux/arm_sdei.h>
22#include <linux/delay.h>
23#include <linux/init.h>
24#include <linux/spinlock.h>
25#include <linux/sched/mm.h>
26#include <linux/sched/hotplug.h>
27#include <linux/sched/task_stack.h>
28#include <linux/interrupt.h>
29#include <linux/cache.h>
30#include <linux/profile.h>
31#include <linux/errno.h>
32#include <linux/mm.h>
33#include <linux/err.h>
34#include <linux/cpu.h>
35#include <linux/smp.h>
36#include <linux/seq_file.h>
37#include <linux/irq.h>
38#include <linux/percpu.h>
39#include <linux/clockchips.h>
40#include <linux/completion.h>
41#include <linux/of.h>
42#include <linux/irq_work.h>
43#include <linux/kexec.h>
44
45#include <asm/alternative.h>
46#include <asm/atomic.h>
47#include <asm/cacheflush.h>
48#include <asm/cpu.h>
49#include <asm/cputype.h>
50#include <asm/cpu_ops.h>
51#include <asm/daifflags.h>
52#include <asm/mmu_context.h>
53#include <asm/numa.h>
54#include <asm/pgtable.h>
55#include <asm/pgalloc.h>
56#include <asm/processor.h>
57#include <asm/smp_plat.h>
58#include <asm/sections.h>
59#include <asm/tlbflush.h>
60#include <asm/ptrace.h>
61#include <asm/virt.h>
62
63#define CREATE_TRACE_POINTS
64#include <trace/events/ipi.h>
65
66DEFINE_PER_CPU_READ_MOSTLY(int, cpu_number);
67EXPORT_PER_CPU_SYMBOL(cpu_number);
68
69
70
71
72
73
74struct secondary_data secondary_data;
75
76int cpus_stuck_in_kernel;
77
78enum ipi_msg_type {
79 IPI_RESCHEDULE,
80 IPI_CALL_FUNC,
81 IPI_CPU_STOP,
82 IPI_CPU_CRASH_STOP,
83 IPI_TIMER,
84 IPI_IRQ_WORK,
85 IPI_WAKEUP
86};
87
88#ifdef CONFIG_ARM64_VHE
89
90
91static bool boot_cpu_hyp_mode;
92
93static inline void save_boot_cpu_run_el(void)
94{
95 boot_cpu_hyp_mode = is_kernel_in_hyp_mode();
96}
97
98static inline bool is_boot_cpu_in_hyp_mode(void)
99{
100 return boot_cpu_hyp_mode;
101}
102
103
104
105
106
107void verify_cpu_run_el(void)
108{
109 bool in_el2 = is_kernel_in_hyp_mode();
110 bool boot_cpu_el2 = is_boot_cpu_in_hyp_mode();
111
112 if (in_el2 ^ boot_cpu_el2) {
113 pr_crit("CPU%d: mismatched Exception Level(EL%d) with boot CPU(EL%d)\n",
114 smp_processor_id(),
115 in_el2 ? 2 : 1,
116 boot_cpu_el2 ? 2 : 1);
117 cpu_panic_kernel();
118 }
119}
120
121#else
122static inline void save_boot_cpu_run_el(void) {}
123#endif
124
125#ifdef CONFIG_HOTPLUG_CPU
126static int op_cpu_kill(unsigned int cpu);
127#else
128static inline int op_cpu_kill(unsigned int cpu)
129{
130 return -ENOSYS;
131}
132#endif
133
134
135
136
137
138
139static int boot_secondary(unsigned int cpu, struct task_struct *idle)
140{
141 if (cpu_ops[cpu]->cpu_boot)
142 return cpu_ops[cpu]->cpu_boot(cpu);
143
144 return -EOPNOTSUPP;
145}
146
147static DECLARE_COMPLETION(cpu_running);
148
149int __cpu_up(unsigned int cpu, struct task_struct *idle)
150{
151 int ret;
152 long status;
153
154
155
156
157
158 secondary_data.task = idle;
159 secondary_data.stack = task_stack_page(idle) + THREAD_SIZE;
160 update_cpu_boot_status(CPU_MMU_OFF);
161 __flush_dcache_area(&secondary_data, sizeof(secondary_data));
162
163
164
165
166 ret = boot_secondary(cpu, idle);
167 if (ret == 0) {
168
169
170
171
172 wait_for_completion_timeout(&cpu_running,
173 msecs_to_jiffies(1000));
174
175 if (!cpu_online(cpu)) {
176 pr_crit("CPU%u: failed to come online\n", cpu);
177 ret = -EIO;
178 }
179 } else {
180 pr_err("CPU%u: failed to boot: %d\n", cpu, ret);
181 }
182
183 secondary_data.task = NULL;
184 secondary_data.stack = NULL;
185 status = READ_ONCE(secondary_data.status);
186 if (ret && status) {
187
188 if (status == CPU_MMU_OFF)
189 status = READ_ONCE(__early_cpu_boot_status);
190
191 switch (status) {
192 default:
193 pr_err("CPU%u: failed in unknown state : 0x%lx\n",
194 cpu, status);
195 break;
196 case CPU_KILL_ME:
197 if (!op_cpu_kill(cpu)) {
198 pr_crit("CPU%u: died during early boot\n", cpu);
199 break;
200 }
201
202 pr_crit("CPU%u: may not have shut down cleanly\n", cpu);
203 case CPU_STUCK_IN_KERNEL:
204 pr_crit("CPU%u: is stuck in kernel\n", cpu);
205 cpus_stuck_in_kernel++;
206 break;
207 case CPU_PANIC_KERNEL:
208 panic("CPU%u detected unsupported configuration\n", cpu);
209 }
210 }
211
212 return ret;
213}
214
215
216
217
218
219asmlinkage void secondary_start_kernel(void)
220{
221 u64 mpidr = read_cpuid_mpidr() & MPIDR_HWID_BITMASK;
222 struct mm_struct *mm = &init_mm;
223 unsigned int cpu;
224
225 cpu = task_cpu(current);
226 set_my_cpu_offset(per_cpu_offset(cpu));
227
228
229
230
231
232 mmgrab(mm);
233 current->active_mm = mm;
234
235
236
237
238
239 cpu_uninstall_idmap();
240
241 preempt_disable();
242 trace_hardirqs_off();
243
244
245
246
247
248
249 check_local_cpu_capabilities();
250
251 if (cpu_ops[cpu]->cpu_postboot)
252 cpu_ops[cpu]->cpu_postboot();
253
254
255
256
257 cpuinfo_store_cpu();
258
259
260
261
262 notify_cpu_starting(cpu);
263
264 store_cpu_topology(cpu);
265
266
267
268
269
270
271 pr_info("CPU%u: Booted secondary processor 0x%010lx [0x%08x]\n",
272 cpu, (unsigned long)mpidr,
273 read_cpuid_id());
274 update_cpu_boot_status(CPU_BOOT_SUCCESS);
275 set_cpu_online(cpu, true);
276 complete(&cpu_running);
277
278 local_daif_restore(DAIF_PROCCTX);
279
280
281
282
283 cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
284}
285
286#ifdef CONFIG_HOTPLUG_CPU
287static int op_cpu_disable(unsigned int cpu)
288{
289
290
291
292
293 if (!cpu_ops[cpu] || !cpu_ops[cpu]->cpu_die)
294 return -EOPNOTSUPP;
295
296
297
298
299
300 if (cpu_ops[cpu]->cpu_disable)
301 return cpu_ops[cpu]->cpu_disable(cpu);
302
303 return 0;
304}
305
306
307
308
309int __cpu_disable(void)
310{
311 unsigned int cpu = smp_processor_id();
312 int ret;
313
314 ret = op_cpu_disable(cpu);
315 if (ret)
316 return ret;
317
318
319
320
321
322 set_cpu_online(cpu, false);
323
324
325
326
327 irq_migrate_all_off_this_cpu();
328
329 return 0;
330}
331
332static int op_cpu_kill(unsigned int cpu)
333{
334
335
336
337
338
339 if (!cpu_ops[cpu]->cpu_kill)
340 return 0;
341
342 return cpu_ops[cpu]->cpu_kill(cpu);
343}
344
345
346
347
348
349void __cpu_die(unsigned int cpu)
350{
351 int err;
352
353 if (!cpu_wait_death(cpu, 5)) {
354 pr_crit("CPU%u: cpu didn't die\n", cpu);
355 return;
356 }
357 pr_notice("CPU%u: shutdown\n", cpu);
358
359
360
361
362
363
364
365 err = op_cpu_kill(cpu);
366 if (err)
367 pr_warn("CPU%d may not have shut down cleanly: %d\n",
368 cpu, err);
369}
370
371
372
373
374
375void cpu_die(void)
376{
377 unsigned int cpu = smp_processor_id();
378
379 idle_task_exit();
380
381 local_daif_mask();
382
383
384 (void)cpu_report_death();
385
386
387
388
389
390
391 cpu_ops[cpu]->cpu_die(cpu);
392
393 BUG();
394}
395#endif
396
397
398
399
400
401void cpu_die_early(void)
402{
403 int cpu = smp_processor_id();
404
405 pr_crit("CPU%d: will not boot\n", cpu);
406
407
408 set_cpu_present(cpu, 0);
409
410#ifdef CONFIG_HOTPLUG_CPU
411 update_cpu_boot_status(CPU_KILL_ME);
412
413 if (cpu_ops[cpu] && cpu_ops[cpu]->cpu_die)
414 cpu_ops[cpu]->cpu_die(cpu);
415#endif
416 update_cpu_boot_status(CPU_STUCK_IN_KERNEL);
417
418 cpu_park_loop();
419}
420
421static void __init hyp_mode_check(void)
422{
423 if (is_hyp_mode_available())
424 pr_info("CPU: All CPU(s) started at EL2\n");
425 else if (is_hyp_mode_mismatched())
426 WARN_TAINT(1, TAINT_CPU_OUT_OF_SPEC,
427 "CPU: CPUs started in inconsistent modes");
428 else
429 pr_info("CPU: All CPU(s) started at EL1\n");
430}
431
432void __init smp_cpus_done(unsigned int max_cpus)
433{
434 pr_info("SMP: Total of %d processors activated.\n", num_online_cpus());
435 setup_cpu_features();
436 hyp_mode_check();
437 apply_alternatives_all();
438 mark_linear_text_alias_ro();
439}
440
441void __init smp_prepare_boot_cpu(void)
442{
443 set_my_cpu_offset(per_cpu_offset(smp_processor_id()));
444
445
446
447
448 jump_label_init();
449 cpuinfo_store_boot_cpu();
450 save_boot_cpu_run_el();
451
452
453
454
455
456 update_cpu_errata_workarounds();
457}
458
459static u64 __init of_get_cpu_mpidr(struct device_node *dn)
460{
461 const __be32 *cell;
462 u64 hwid;
463
464
465
466
467
468
469 cell = of_get_property(dn, "reg", NULL);
470 if (!cell) {
471 pr_err("%pOF: missing reg property\n", dn);
472 return INVALID_HWID;
473 }
474
475 hwid = of_read_number(cell, of_n_addr_cells(dn));
476
477
478
479 if (hwid & ~MPIDR_HWID_BITMASK) {
480 pr_err("%pOF: invalid reg property\n", dn);
481 return INVALID_HWID;
482 }
483 return hwid;
484}
485
486
487
488
489
490
491
492static bool __init is_mpidr_duplicate(unsigned int cpu, u64 hwid)
493{
494 unsigned int i;
495
496 for (i = 1; (i < cpu) && (i < NR_CPUS); i++)
497 if (cpu_logical_map(i) == hwid)
498 return true;
499 return false;
500}
501
502
503
504
505
506static int __init smp_cpu_setup(int cpu)
507{
508 if (cpu_read_ops(cpu))
509 return -ENODEV;
510
511 if (cpu_ops[cpu]->cpu_init(cpu))
512 return -ENODEV;
513
514 set_cpu_possible(cpu, true);
515
516 return 0;
517}
518
519static bool bootcpu_valid __initdata;
520static unsigned int cpu_count = 1;
521
522#ifdef CONFIG_ACPI
523static struct acpi_madt_generic_interrupt cpu_madt_gicc[NR_CPUS];
524
525struct acpi_madt_generic_interrupt *acpi_cpu_get_madt_gicc(int cpu)
526{
527 return &cpu_madt_gicc[cpu];
528}
529
530
531
532
533
534
535
536static void __init
537acpi_map_gic_cpu_interface(struct acpi_madt_generic_interrupt *processor)
538{
539 u64 hwid = processor->arm_mpidr;
540
541 if (!(processor->flags & ACPI_MADT_ENABLED)) {
542 pr_debug("skipping disabled CPU entry with 0x%llx MPIDR\n", hwid);
543 return;
544 }
545
546 if (hwid & ~MPIDR_HWID_BITMASK || hwid == INVALID_HWID) {
547 pr_err("skipping CPU entry with invalid MPIDR 0x%llx\n", hwid);
548 return;
549 }
550
551 if (is_mpidr_duplicate(cpu_count, hwid)) {
552 pr_err("duplicate CPU MPIDR 0x%llx in MADT\n", hwid);
553 return;
554 }
555
556
557 if (cpu_logical_map(0) == hwid) {
558 if (bootcpu_valid) {
559 pr_err("duplicate boot CPU MPIDR: 0x%llx in MADT\n",
560 hwid);
561 return;
562 }
563 bootcpu_valid = true;
564 cpu_madt_gicc[0] = *processor;
565 early_map_cpu_to_node(0, acpi_numa_get_nid(0, hwid));
566 return;
567 }
568
569 if (cpu_count >= NR_CPUS)
570 return;
571
572
573 cpu_logical_map(cpu_count) = hwid;
574
575 cpu_madt_gicc[cpu_count] = *processor;
576
577
578
579
580
581
582
583
584
585
586 acpi_set_mailbox_entry(cpu_count, processor);
587
588 early_map_cpu_to_node(cpu_count, acpi_numa_get_nid(cpu_count, hwid));
589
590 cpu_count++;
591}
592
593static int __init
594acpi_parse_gic_cpu_interface(struct acpi_subtable_header *header,
595 const unsigned long end)
596{
597 struct acpi_madt_generic_interrupt *processor;
598
599 processor = (struct acpi_madt_generic_interrupt *)header;
600 if (BAD_MADT_GICC_ENTRY(processor, end))
601 return -EINVAL;
602
603 acpi_table_print_madt_entry(header);
604
605 acpi_map_gic_cpu_interface(processor);
606
607 return 0;
608}
609#else
610#define acpi_table_parse_madt(...) do { } while (0)
611#endif
612
613
614
615
616
617
618static void __init of_parse_and_init_cpus(void)
619{
620 struct device_node *dn;
621
622 for_each_node_by_type(dn, "cpu") {
623 u64 hwid = of_get_cpu_mpidr(dn);
624
625 if (hwid == INVALID_HWID)
626 goto next;
627
628 if (is_mpidr_duplicate(cpu_count, hwid)) {
629 pr_err("%pOF: duplicate cpu reg properties in the DT\n",
630 dn);
631 goto next;
632 }
633
634
635
636
637
638
639
640 if (hwid == cpu_logical_map(0)) {
641 if (bootcpu_valid) {
642 pr_err("%pOF: duplicate boot cpu reg property in DT\n",
643 dn);
644 goto next;
645 }
646
647 bootcpu_valid = true;
648 early_map_cpu_to_node(0, of_node_to_nid(dn));
649
650
651
652
653
654
655
656 continue;
657 }
658
659 if (cpu_count >= NR_CPUS)
660 goto next;
661
662 pr_debug("cpu logical map 0x%llx\n", hwid);
663 cpu_logical_map(cpu_count) = hwid;
664
665 early_map_cpu_to_node(cpu_count, of_node_to_nid(dn));
666next:
667 cpu_count++;
668 }
669}
670
671
672
673
674
675
676void __init smp_init_cpus(void)
677{
678 int i;
679
680 if (acpi_disabled)
681 of_parse_and_init_cpus();
682 else
683
684
685
686
687
688 acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_INTERRUPT,
689 acpi_parse_gic_cpu_interface, 0);
690
691 if (cpu_count > nr_cpu_ids)
692 pr_warn("Number of cores (%d) exceeds configured maximum of %u - clipping\n",
693 cpu_count, nr_cpu_ids);
694
695 if (!bootcpu_valid) {
696 pr_err("missing boot CPU MPIDR, not enabling secondaries\n");
697 return;
698 }
699
700
701
702
703
704
705
706
707 for (i = 1; i < nr_cpu_ids; i++) {
708 if (cpu_logical_map(i) != INVALID_HWID) {
709 if (smp_cpu_setup(i))
710 cpu_logical_map(i) = INVALID_HWID;
711 }
712 }
713}
714
715void __init smp_prepare_cpus(unsigned int max_cpus)
716{
717 int err;
718 unsigned int cpu;
719 unsigned int this_cpu;
720
721 init_cpu_topology();
722
723 this_cpu = smp_processor_id();
724 store_cpu_topology(this_cpu);
725 numa_store_cpu_info(this_cpu);
726
727
728
729
730
731 if (max_cpus == 0)
732 return;
733
734
735
736
737
738
739 for_each_possible_cpu(cpu) {
740
741 per_cpu(cpu_number, cpu) = cpu;
742
743 if (cpu == smp_processor_id())
744 continue;
745
746 if (!cpu_ops[cpu])
747 continue;
748
749 err = cpu_ops[cpu]->cpu_prepare(cpu);
750 if (err)
751 continue;
752
753 set_cpu_present(cpu, true);
754 numa_store_cpu_info(cpu);
755 }
756}
757
758void (*__smp_cross_call)(const struct cpumask *, unsigned int);
759
760void __init set_smp_cross_call(void (*fn)(const struct cpumask *, unsigned int))
761{
762 __smp_cross_call = fn;
763}
764
765static const char *ipi_types[NR_IPI] __tracepoint_string = {
766#define S(x,s) [x] = s
767 S(IPI_RESCHEDULE, "Rescheduling interrupts"),
768 S(IPI_CALL_FUNC, "Function call interrupts"),
769 S(IPI_CPU_STOP, "CPU stop interrupts"),
770 S(IPI_CPU_CRASH_STOP, "CPU stop (for crash dump) interrupts"),
771 S(IPI_TIMER, "Timer broadcast interrupts"),
772 S(IPI_IRQ_WORK, "IRQ work interrupts"),
773 S(IPI_WAKEUP, "CPU wake-up interrupts"),
774};
775
776static void smp_cross_call(const struct cpumask *target, unsigned int ipinr)
777{
778 trace_ipi_raise(target, ipi_types[ipinr]);
779 __smp_cross_call(target, ipinr);
780}
781
782void show_ipi_list(struct seq_file *p, int prec)
783{
784 unsigned int cpu, i;
785
786 for (i = 0; i < NR_IPI; i++) {
787 seq_printf(p, "%*s%u:%s", prec - 1, "IPI", i,
788 prec >= 4 ? " " : "");
789 for_each_online_cpu(cpu)
790 seq_printf(p, "%10u ",
791 __get_irq_stat(cpu, ipi_irqs[i]));
792 seq_printf(p, " %s\n", ipi_types[i]);
793 }
794}
795
796u64 smp_irq_stat_cpu(unsigned int cpu)
797{
798 u64 sum = 0;
799 int i;
800
801 for (i = 0; i < NR_IPI; i++)
802 sum += __get_irq_stat(cpu, ipi_irqs[i]);
803
804 return sum;
805}
806
807void arch_send_call_function_ipi_mask(const struct cpumask *mask)
808{
809 smp_cross_call(mask, IPI_CALL_FUNC);
810}
811
812void arch_send_call_function_single_ipi(int cpu)
813{
814 smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC);
815}
816
817#ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
818void arch_send_wakeup_ipi_mask(const struct cpumask *mask)
819{
820 smp_cross_call(mask, IPI_WAKEUP);
821}
822#endif
823
824#ifdef CONFIG_IRQ_WORK
825void arch_irq_work_raise(void)
826{
827 if (__smp_cross_call)
828 smp_cross_call(cpumask_of(smp_processor_id()), IPI_IRQ_WORK);
829}
830#endif
831
832
833
834
835static void ipi_cpu_stop(unsigned int cpu)
836{
837 set_cpu_online(cpu, false);
838
839 local_daif_mask();
840 sdei_mask_local_cpu();
841
842 while (1)
843 cpu_relax();
844}
845
846#ifdef CONFIG_KEXEC_CORE
847static atomic_t waiting_for_crash_ipi = ATOMIC_INIT(0);
848#endif
849
850static void ipi_cpu_crash_stop(unsigned int cpu, struct pt_regs *regs)
851{
852#ifdef CONFIG_KEXEC_CORE
853 crash_save_cpu(regs, cpu);
854
855 atomic_dec(&waiting_for_crash_ipi);
856
857 local_irq_disable();
858 sdei_mask_local_cpu();
859
860#ifdef CONFIG_HOTPLUG_CPU
861 if (cpu_ops[cpu]->cpu_die)
862 cpu_ops[cpu]->cpu_die(cpu);
863#endif
864
865
866 cpu_park_loop();
867#endif
868}
869
870
871
872
873void handle_IPI(int ipinr, struct pt_regs *regs)
874{
875 unsigned int cpu = smp_processor_id();
876 struct pt_regs *old_regs = set_irq_regs(regs);
877
878 if ((unsigned)ipinr < NR_IPI) {
879 trace_ipi_entry_rcuidle(ipi_types[ipinr]);
880 __inc_irq_stat(cpu, ipi_irqs[ipinr]);
881 }
882
883 switch (ipinr) {
884 case IPI_RESCHEDULE:
885 scheduler_ipi();
886 break;
887
888 case IPI_CALL_FUNC:
889 irq_enter();
890 generic_smp_call_function_interrupt();
891 irq_exit();
892 break;
893
894 case IPI_CPU_STOP:
895 irq_enter();
896 ipi_cpu_stop(cpu);
897 irq_exit();
898 break;
899
900 case IPI_CPU_CRASH_STOP:
901 if (IS_ENABLED(CONFIG_KEXEC_CORE)) {
902 irq_enter();
903 ipi_cpu_crash_stop(cpu, regs);
904
905 unreachable();
906 }
907 break;
908
909#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
910 case IPI_TIMER:
911 irq_enter();
912 tick_receive_broadcast();
913 irq_exit();
914 break;
915#endif
916
917#ifdef CONFIG_IRQ_WORK
918 case IPI_IRQ_WORK:
919 irq_enter();
920 irq_work_run();
921 irq_exit();
922 break;
923#endif
924
925#ifdef CONFIG_ARM64_ACPI_PARKING_PROTOCOL
926 case IPI_WAKEUP:
927 WARN_ONCE(!acpi_parking_protocol_valid(cpu),
928 "CPU%u: Wake-up IPI outside the ACPI parking protocol\n",
929 cpu);
930 break;
931#endif
932
933 default:
934 pr_crit("CPU%u: Unknown IPI message 0x%x\n", cpu, ipinr);
935 break;
936 }
937
938 if ((unsigned)ipinr < NR_IPI)
939 trace_ipi_exit_rcuidle(ipi_types[ipinr]);
940 set_irq_regs(old_regs);
941}
942
943void smp_send_reschedule(int cpu)
944{
945 smp_cross_call(cpumask_of(cpu), IPI_RESCHEDULE);
946}
947
948#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
949void tick_broadcast(const struct cpumask *mask)
950{
951 smp_cross_call(mask, IPI_TIMER);
952}
953#endif
954
955void smp_send_stop(void)
956{
957 unsigned long timeout;
958
959 if (num_online_cpus() > 1) {
960 cpumask_t mask;
961
962 cpumask_copy(&mask, cpu_online_mask);
963 cpumask_clear_cpu(smp_processor_id(), &mask);
964
965 if (system_state <= SYSTEM_RUNNING)
966 pr_crit("SMP: stopping secondary CPUs\n");
967 smp_cross_call(&mask, IPI_CPU_STOP);
968 }
969
970
971 timeout = USEC_PER_SEC;
972 while (num_online_cpus() > 1 && timeout--)
973 udelay(1);
974
975 if (num_online_cpus() > 1)
976 pr_warning("SMP: failed to stop secondary CPUs %*pbl\n",
977 cpumask_pr_args(cpu_online_mask));
978
979 sdei_mask_local_cpu();
980}
981
982#ifdef CONFIG_KEXEC_CORE
983void crash_smp_send_stop(void)
984{
985 static int cpus_stopped;
986 cpumask_t mask;
987 unsigned long timeout;
988
989
990
991
992
993 if (cpus_stopped)
994 return;
995
996 cpus_stopped = 1;
997
998 if (num_online_cpus() == 1) {
999 sdei_mask_local_cpu();
1000 return;
1001 }
1002
1003 cpumask_copy(&mask, cpu_online_mask);
1004 cpumask_clear_cpu(smp_processor_id(), &mask);
1005
1006 atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
1007
1008 pr_crit("SMP: stopping secondary CPUs\n");
1009 smp_cross_call(&mask, IPI_CPU_CRASH_STOP);
1010
1011
1012 timeout = USEC_PER_SEC;
1013 while ((atomic_read(&waiting_for_crash_ipi) > 0) && timeout--)
1014 udelay(1);
1015
1016 if (atomic_read(&waiting_for_crash_ipi) > 0)
1017 pr_warning("SMP: failed to stop secondary CPUs %*pbl\n",
1018 cpumask_pr_args(&mask));
1019
1020 sdei_mask_local_cpu();
1021}
1022
1023bool smp_crash_stop_failed(void)
1024{
1025 return (atomic_read(&waiting_for_crash_ipi) > 0);
1026}
1027#endif
1028
1029
1030
1031
1032int setup_profiling_timer(unsigned int multiplier)
1033{
1034 return -EINVAL;
1035}
1036
1037static bool have_cpu_die(void)
1038{
1039#ifdef CONFIG_HOTPLUG_CPU
1040 int any_cpu = raw_smp_processor_id();
1041
1042 if (cpu_ops[any_cpu] && cpu_ops[any_cpu]->cpu_die)
1043 return true;
1044#endif
1045 return false;
1046}
1047
1048bool cpus_are_stuck_in_kernel(void)
1049{
1050 bool smp_spin_tables = (num_possible_cpus() > 1 && !have_cpu_die());
1051
1052 return !!cpus_stuck_in_kernel || smp_spin_tables;
1053}
1054