Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * arch/x86/kernel/nmi-selftest.c
4 *
5 * Testsuite for NMI: IPIs
6 *
7 * Started by Don Zickus:
8 * (using lib/locking-selftest.c as a guide)
9 *
10 * Copyright (C) 2011 Red Hat, Inc., Don Zickus <dzickus@redhat.com>
11 */
12
13#include <linux/smp.h>
14#include <linux/cpumask.h>
15#include <linux/delay.h>
16#include <linux/init.h>
17#include <linux/percpu.h>
18
19#include <asm/apic.h>
20#include <asm/nmi.h>
21
22#define SUCCESS 0
23#define FAILURE 1
24#define TIMEOUT 2
25
26static int __initdata nmi_fail;
27
28/* check to see if NMI IPIs work on this machine */
29static DECLARE_BITMAP(nmi_ipi_mask, NR_CPUS) __initdata;
30
31static int __initdata testcase_total;
32static int __initdata testcase_successes;
33static int __initdata expected_testcase_failures;
34static int __initdata unexpected_testcase_failures;
35static int __initdata unexpected_testcase_unknowns;
36
37static int __init nmi_unk_cb(unsigned int val, struct pt_regs *regs)
38{
39 unexpected_testcase_unknowns++;
40 return NMI_HANDLED;
41}
42
43static void __init init_nmi_testsuite(void)
44{
45 /* trap all the unknown NMIs we may generate */
46 register_nmi_handler(NMI_UNKNOWN, nmi_unk_cb, 0, "nmi_selftest_unk",
47 __initdata);
48}
49
50static void __init cleanup_nmi_testsuite(void)
51{
52 unregister_nmi_handler(NMI_UNKNOWN, "nmi_selftest_unk");
53}
54
55static int __init test_nmi_ipi_callback(unsigned int val, struct pt_regs *regs)
56{
57 int cpu = raw_smp_processor_id();
58
59 if (cpumask_test_and_clear_cpu(cpu, to_cpumask(nmi_ipi_mask)))
60 return NMI_HANDLED;
61
62 return NMI_DONE;
63}
64
65static void __init test_nmi_ipi(struct cpumask *mask)
66{
67 unsigned long timeout;
68
69 if (register_nmi_handler(NMI_LOCAL, test_nmi_ipi_callback,
70 NMI_FLAG_FIRST, "nmi_selftest", __initdata)) {
71 nmi_fail = FAILURE;
72 return;
73 }
74
75 /* sync above data before sending NMI */
76 wmb();
77
78 apic->send_IPI_mask(mask, NMI_VECTOR);
79
80 /* Don't wait longer than a second */
81 timeout = USEC_PER_SEC;
82 while (!cpumask_empty(mask) && --timeout)
83 udelay(1);
84
85 /* What happens if we timeout, do we still unregister?? */
86 unregister_nmi_handler(NMI_LOCAL, "nmi_selftest");
87
88 if (!timeout)
89 nmi_fail = TIMEOUT;
90 return;
91}
92
93static void __init remote_ipi(void)
94{
95 cpumask_copy(to_cpumask(nmi_ipi_mask), cpu_online_mask);
96 cpumask_clear_cpu(smp_processor_id(), to_cpumask(nmi_ipi_mask));
97 if (!cpumask_empty(to_cpumask(nmi_ipi_mask)))
98 test_nmi_ipi(to_cpumask(nmi_ipi_mask));
99}
100
101static void __init local_ipi(void)
102{
103 cpumask_clear(to_cpumask(nmi_ipi_mask));
104 cpumask_set_cpu(smp_processor_id(), to_cpumask(nmi_ipi_mask));
105 test_nmi_ipi(to_cpumask(nmi_ipi_mask));
106}
107
108static void __init reset_nmi(void)
109{
110 nmi_fail = 0;
111}
112
113static void __init dotest(void (*testcase_fn)(void), int expected)
114{
115 testcase_fn();
116 /*
117 * Filter out expected failures:
118 */
119 if (nmi_fail != expected) {
120 unexpected_testcase_failures++;
121
122 if (nmi_fail == FAILURE)
123 printk(KERN_CONT "FAILED |");
124 else if (nmi_fail == TIMEOUT)
125 printk(KERN_CONT "TIMEOUT|");
126 else
127 printk(KERN_CONT "ERROR |");
128 dump_stack();
129 } else {
130 testcase_successes++;
131 printk(KERN_CONT " ok |");
132 }
133 testcase_total++;
134
135 reset_nmi();
136}
137
138static inline void __init print_testname(const char *testname)
139{
140 printk("%12s:", testname);
141}
142
143void __init nmi_selftest(void)
144{
145 init_nmi_testsuite();
146
147 /*
148 * Run the testsuite:
149 */
150 printk("----------------\n");
151 printk("| NMI testsuite:\n");
152 printk("--------------------\n");
153
154 print_testname("remote IPI");
155 dotest(remote_ipi, SUCCESS);
156 printk(KERN_CONT "\n");
157 print_testname("local IPI");
158 dotest(local_ipi, SUCCESS);
159 printk(KERN_CONT "\n");
160
161 cleanup_nmi_testsuite();
162
163 if (unexpected_testcase_failures) {
164 printk("--------------------\n");
165 printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
166 unexpected_testcase_failures, testcase_total);
167 printk("-----------------------------------------------------------------\n");
168 } else if (expected_testcase_failures && testcase_successes) {
169 printk("--------------------\n");
170 printk("%3d out of %3d testcases failed, as expected. |\n",
171 expected_testcase_failures, testcase_total);
172 printk("----------------------------------------------------\n");
173 } else if (expected_testcase_failures && !testcase_successes) {
174 printk("--------------------\n");
175 printk("All %3d testcases failed, as expected. |\n",
176 expected_testcase_failures);
177 printk("----------------------------------------\n");
178 } else {
179 printk("--------------------\n");
180 printk("Good, all %3d testcases passed! |\n",
181 testcase_successes);
182 printk("---------------------------------\n");
183 }
184}
1/*
2 * arch/x86/kernel/nmi-selftest.c
3 *
4 * Testsuite for NMI: IPIs
5 *
6 * Started by Don Zickus:
7 * (using lib/locking-selftest.c as a guide)
8 *
9 * Copyright (C) 2011 Red Hat, Inc., Don Zickus <dzickus@redhat.com>
10 */
11
12#include <linux/smp.h>
13#include <linux/cpumask.h>
14#include <linux/delay.h>
15#include <linux/init.h>
16#include <linux/percpu.h>
17
18#include <asm/apic.h>
19#include <asm/nmi.h>
20
21#define SUCCESS 0
22#define FAILURE 1
23#define TIMEOUT 2
24
25static int __initdata nmi_fail;
26
27/* check to see if NMI IPIs work on this machine */
28static DECLARE_BITMAP(nmi_ipi_mask, NR_CPUS) __initdata;
29
30static int __initdata testcase_total;
31static int __initdata testcase_successes;
32static int __initdata expected_testcase_failures;
33static int __initdata unexpected_testcase_failures;
34static int __initdata unexpected_testcase_unknowns;
35
36static int __init nmi_unk_cb(unsigned int val, struct pt_regs *regs)
37{
38 unexpected_testcase_unknowns++;
39 return NMI_HANDLED;
40}
41
42static void __init init_nmi_testsuite(void)
43{
44 /* trap all the unknown NMIs we may generate */
45 register_nmi_handler(NMI_UNKNOWN, nmi_unk_cb, 0, "nmi_selftest_unk",
46 __initdata);
47}
48
49static void __init cleanup_nmi_testsuite(void)
50{
51 unregister_nmi_handler(NMI_UNKNOWN, "nmi_selftest_unk");
52}
53
54static int __init test_nmi_ipi_callback(unsigned int val, struct pt_regs *regs)
55{
56 int cpu = raw_smp_processor_id();
57
58 if (cpumask_test_and_clear_cpu(cpu, to_cpumask(nmi_ipi_mask)))
59 return NMI_HANDLED;
60
61 return NMI_DONE;
62}
63
64static void __init test_nmi_ipi(struct cpumask *mask)
65{
66 unsigned long timeout;
67
68 if (register_nmi_handler(NMI_LOCAL, test_nmi_ipi_callback,
69 NMI_FLAG_FIRST, "nmi_selftest", __initdata)) {
70 nmi_fail = FAILURE;
71 return;
72 }
73
74 /* sync above data before sending NMI */
75 wmb();
76
77 apic->send_IPI_mask(mask, NMI_VECTOR);
78
79 /* Don't wait longer than a second */
80 timeout = USEC_PER_SEC;
81 while (!cpumask_empty(mask) && timeout--)
82 udelay(1);
83
84 /* What happens if we timeout, do we still unregister?? */
85 unregister_nmi_handler(NMI_LOCAL, "nmi_selftest");
86
87 if (!timeout)
88 nmi_fail = TIMEOUT;
89 return;
90}
91
92static void __init remote_ipi(void)
93{
94 cpumask_copy(to_cpumask(nmi_ipi_mask), cpu_online_mask);
95 cpumask_clear_cpu(smp_processor_id(), to_cpumask(nmi_ipi_mask));
96 if (!cpumask_empty(to_cpumask(nmi_ipi_mask)))
97 test_nmi_ipi(to_cpumask(nmi_ipi_mask));
98}
99
100static void __init local_ipi(void)
101{
102 cpumask_clear(to_cpumask(nmi_ipi_mask));
103 cpumask_set_cpu(smp_processor_id(), to_cpumask(nmi_ipi_mask));
104 test_nmi_ipi(to_cpumask(nmi_ipi_mask));
105}
106
107static void __init reset_nmi(void)
108{
109 nmi_fail = 0;
110}
111
112static void __init dotest(void (*testcase_fn)(void), int expected)
113{
114 testcase_fn();
115 /*
116 * Filter out expected failures:
117 */
118 if (nmi_fail != expected) {
119 unexpected_testcase_failures++;
120
121 if (nmi_fail == FAILURE)
122 printk(KERN_CONT "FAILED |");
123 else if (nmi_fail == TIMEOUT)
124 printk(KERN_CONT "TIMEOUT|");
125 else
126 printk(KERN_CONT "ERROR |");
127 dump_stack();
128 } else {
129 testcase_successes++;
130 printk(KERN_CONT " ok |");
131 }
132 testcase_total++;
133
134 reset_nmi();
135}
136
137static inline void __init print_testname(const char *testname)
138{
139 printk("%12s:", testname);
140}
141
142void __init nmi_selftest(void)
143{
144 init_nmi_testsuite();
145
146 /*
147 * Run the testsuite:
148 */
149 printk("----------------\n");
150 printk("| NMI testsuite:\n");
151 printk("--------------------\n");
152
153 print_testname("remote IPI");
154 dotest(remote_ipi, SUCCESS);
155 printk(KERN_CONT "\n");
156 print_testname("local IPI");
157 dotest(local_ipi, SUCCESS);
158 printk(KERN_CONT "\n");
159
160 cleanup_nmi_testsuite();
161
162 if (unexpected_testcase_failures) {
163 printk("--------------------\n");
164 printk("BUG: %3d unexpected failures (out of %3d) - debugging disabled! |\n",
165 unexpected_testcase_failures, testcase_total);
166 printk("-----------------------------------------------------------------\n");
167 } else if (expected_testcase_failures && testcase_successes) {
168 printk("--------------------\n");
169 printk("%3d out of %3d testcases failed, as expected. |\n",
170 expected_testcase_failures, testcase_total);
171 printk("----------------------------------------------------\n");
172 } else if (expected_testcase_failures && !testcase_successes) {
173 printk("--------------------\n");
174 printk("All %3d testcases failed, as expected. |\n",
175 expected_testcase_failures);
176 printk("----------------------------------------\n");
177 } else {
178 printk("--------------------\n");
179 printk("Good, all %3d testcases passed! |\n",
180 testcase_successes);
181 printk("---------------------------------\n");
182 }
183}