xref: /openbmc/linux/include/linux/nmi.h (revision 6aa7de05)
1 /*
2  *  linux/include/linux/nmi.h
3  */
4 #ifndef LINUX_NMI_H
5 #define LINUX_NMI_H
6 
7 #include <linux/sched.h>
8 #include <asm/irq.h>
9 #if defined(CONFIG_HAVE_NMI_WATCHDOG)
10 #include <asm/nmi.h>
11 #endif
12 
13 #ifdef CONFIG_LOCKUP_DETECTOR
14 void lockup_detector_init(void);
15 void lockup_detector_soft_poweroff(void);
16 void lockup_detector_cleanup(void);
17 bool is_hardlockup(void);
18 
19 extern int watchdog_user_enabled;
20 extern int nmi_watchdog_user_enabled;
21 extern int soft_watchdog_user_enabled;
22 extern int watchdog_thresh;
23 extern unsigned long watchdog_enabled;
24 
25 extern struct cpumask watchdog_cpumask;
26 extern unsigned long *watchdog_cpumask_bits;
27 #ifdef CONFIG_SMP
28 extern int sysctl_softlockup_all_cpu_backtrace;
29 extern int sysctl_hardlockup_all_cpu_backtrace;
30 #else
31 #define sysctl_softlockup_all_cpu_backtrace 0
32 #define sysctl_hardlockup_all_cpu_backtrace 0
33 #endif /* !CONFIG_SMP */
34 
35 #else /* CONFIG_LOCKUP_DETECTOR */
36 static inline void lockup_detector_init(void) { }
37 static inline void lockup_detector_soft_poweroff(void) { }
38 static inline void lockup_detector_cleanup(void) { }
39 #endif /* !CONFIG_LOCKUP_DETECTOR */
40 
41 #ifdef CONFIG_SOFTLOCKUP_DETECTOR
42 extern void touch_softlockup_watchdog_sched(void);
43 extern void touch_softlockup_watchdog(void);
44 extern void touch_softlockup_watchdog_sync(void);
45 extern void touch_all_softlockup_watchdogs(void);
46 extern unsigned int  softlockup_panic;
47 #else
48 static inline void touch_softlockup_watchdog_sched(void) { }
49 static inline void touch_softlockup_watchdog(void) { }
50 static inline void touch_softlockup_watchdog_sync(void) { }
51 static inline void touch_all_softlockup_watchdogs(void) { }
52 #endif
53 
54 #ifdef CONFIG_DETECT_HUNG_TASK
55 void reset_hung_task_detector(void);
56 #else
57 static inline void reset_hung_task_detector(void) { }
58 #endif
59 
60 /*
61  * The run state of the lockup detectors is controlled by the content of the
62  * 'watchdog_enabled' variable. Each lockup detector has its dedicated bit -
63  * bit 0 for the hard lockup detector and bit 1 for the soft lockup detector.
64  *
65  * 'watchdog_user_enabled', 'nmi_watchdog_user_enabled' and
66  * 'soft_watchdog_user_enabled' are variables that are only used as an
67  * 'interface' between the parameters in /proc/sys/kernel and the internal
68  * state bits in 'watchdog_enabled'. The 'watchdog_thresh' variable is
69  * handled differently because its value is not boolean, and the lockup
70  * detectors are 'suspended' while 'watchdog_thresh' is equal zero.
71  */
72 #define NMI_WATCHDOG_ENABLED_BIT   0
73 #define SOFT_WATCHDOG_ENABLED_BIT  1
74 #define NMI_WATCHDOG_ENABLED      (1 << NMI_WATCHDOG_ENABLED_BIT)
75 #define SOFT_WATCHDOG_ENABLED     (1 << SOFT_WATCHDOG_ENABLED_BIT)
76 
77 #if defined(CONFIG_HARDLOCKUP_DETECTOR)
78 extern void hardlockup_detector_disable(void);
79 extern unsigned int hardlockup_panic;
80 #else
81 static inline void hardlockup_detector_disable(void) {}
82 #endif
83 
84 #if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
85 # define NMI_WATCHDOG_SYSCTL_PERM	0644
86 #else
87 # define NMI_WATCHDOG_SYSCTL_PERM	0444
88 #endif
89 
90 #if defined(CONFIG_HARDLOCKUP_DETECTOR_PERF)
91 extern void arch_touch_nmi_watchdog(void);
92 extern void hardlockup_detector_perf_stop(void);
93 extern void hardlockup_detector_perf_restart(void);
94 extern void hardlockup_detector_perf_disable(void);
95 extern void hardlockup_detector_perf_enable(void);
96 extern void hardlockup_detector_perf_cleanup(void);
97 extern int hardlockup_detector_perf_init(void);
98 #else
99 static inline void hardlockup_detector_perf_stop(void) { }
100 static inline void hardlockup_detector_perf_restart(void) { }
101 static inline void hardlockup_detector_perf_disable(void) { }
102 static inline void hardlockup_detector_perf_enable(void) { }
103 static inline void hardlockup_detector_perf_cleanup(void) { }
104 # if !defined(CONFIG_HAVE_NMI_WATCHDOG)
105 static inline int hardlockup_detector_perf_init(void) { return -ENODEV; }
106 static inline void arch_touch_nmi_watchdog(void) {}
107 # else
108 static inline int hardlockup_detector_perf_init(void) { return 0; }
109 # endif
110 #endif
111 
112 void watchdog_nmi_stop(void);
113 void watchdog_nmi_start(void);
114 int watchdog_nmi_probe(void);
115 
116 /**
117  * touch_nmi_watchdog - restart NMI watchdog timeout.
118  *
119  * If the architecture supports the NMI watchdog, touch_nmi_watchdog()
120  * may be used to reset the timeout - for code which intentionally
121  * disables interrupts for a long time. This call is stateless.
122  */
123 static inline void touch_nmi_watchdog(void)
124 {
125 	arch_touch_nmi_watchdog();
126 	touch_softlockup_watchdog();
127 }
128 
129 /*
130  * Create trigger_all_cpu_backtrace() out of the arch-provided
131  * base function. Return whether such support was available,
132  * to allow calling code to fall back to some other mechanism:
133  */
134 #ifdef arch_trigger_cpumask_backtrace
135 static inline bool trigger_all_cpu_backtrace(void)
136 {
137 	arch_trigger_cpumask_backtrace(cpu_online_mask, false);
138 	return true;
139 }
140 
141 static inline bool trigger_allbutself_cpu_backtrace(void)
142 {
143 	arch_trigger_cpumask_backtrace(cpu_online_mask, true);
144 	return true;
145 }
146 
147 static inline bool trigger_cpumask_backtrace(struct cpumask *mask)
148 {
149 	arch_trigger_cpumask_backtrace(mask, false);
150 	return true;
151 }
152 
153 static inline bool trigger_single_cpu_backtrace(int cpu)
154 {
155 	arch_trigger_cpumask_backtrace(cpumask_of(cpu), false);
156 	return true;
157 }
158 
159 /* generic implementation */
160 void nmi_trigger_cpumask_backtrace(const cpumask_t *mask,
161 				   bool exclude_self,
162 				   void (*raise)(cpumask_t *mask));
163 bool nmi_cpu_backtrace(struct pt_regs *regs);
164 
165 #else
166 static inline bool trigger_all_cpu_backtrace(void)
167 {
168 	return false;
169 }
170 static inline bool trigger_allbutself_cpu_backtrace(void)
171 {
172 	return false;
173 }
174 static inline bool trigger_cpumask_backtrace(struct cpumask *mask)
175 {
176 	return false;
177 }
178 static inline bool trigger_single_cpu_backtrace(int cpu)
179 {
180 	return false;
181 }
182 #endif
183 
184 #ifdef CONFIG_HARDLOCKUP_DETECTOR_PERF
185 u64 hw_nmi_get_sample_period(int watchdog_thresh);
186 #endif
187 
188 #if defined(CONFIG_HARDLOCKUP_CHECK_TIMESTAMP) && \
189     defined(CONFIG_HARDLOCKUP_DETECTOR)
190 void watchdog_update_hrtimer_threshold(u64 period);
191 #else
192 static inline void watchdog_update_hrtimer_threshold(u64 period) { }
193 #endif
194 
195 struct ctl_table;
196 extern int proc_watchdog(struct ctl_table *, int ,
197 			 void __user *, size_t *, loff_t *);
198 extern int proc_nmi_watchdog(struct ctl_table *, int ,
199 			     void __user *, size_t *, loff_t *);
200 extern int proc_soft_watchdog(struct ctl_table *, int ,
201 			      void __user *, size_t *, loff_t *);
202 extern int proc_watchdog_thresh(struct ctl_table *, int ,
203 				void __user *, size_t *, loff_t *);
204 extern int proc_watchdog_cpumask(struct ctl_table *, int,
205 				 void __user *, size_t *, loff_t *);
206 
207 #ifdef CONFIG_HAVE_ACPI_APEI_NMI
208 #include <asm/nmi.h>
209 #endif
210 
211 #endif
212