Blame view
kernel/watchdog.c
21.8 KB
b24413180
|
1 |
// SPDX-License-Identifier: GPL-2.0 |
58687acba
|
2 3 4 5 6 |
/* * Detect hard and soft lockups on a system * * started by Don Zickus, Copyright (C) 2010 Red Hat, Inc. * |
86f5e6a7b
|
7 8 9 |
* Note: Most of this code is borrowed heavily from the original softlockup * detector, so thanks to Ingo for the initial implementation. * Some chunks also taken from the old x86-specific nmi watchdog code, thanks |
58687acba
|
10 11 |
* to those contributors as well. */ |
5f92a7b0f
|
12 |
#define pr_fmt(fmt) "watchdog: " fmt |
4501980aa
|
13 |
|
58687acba
|
14 15 16 17 |
#include <linux/mm.h> #include <linux/cpu.h> #include <linux/nmi.h> #include <linux/init.h> |
58687acba
|
18 19 |
#include <linux/module.h> #include <linux/sysctl.h> |
bcd951cf1
|
20 |
#include <linux/smpboot.h> |
8bd75c77b
|
21 |
#include <linux/sched/rt.h> |
ae7e81c07
|
22 |
#include <uapi/linux/sched/types.h> |
fe4ba3c34
|
23 |
#include <linux/tick.h> |
82607adcf
|
24 |
#include <linux/workqueue.h> |
e60175710
|
25 |
#include <linux/sched/clock.h> |
b17b01533
|
26 |
#include <linux/sched/debug.h> |
58687acba
|
27 28 |
#include <asm/irq_regs.h> |
5d1c0f4a8
|
29 |
#include <linux/kvm_para.h> |
81a4beef9
|
30 |
#include <linux/kthread.h> |
58687acba
|
31 |
|
946d19779
|
32 |
static DEFINE_MUTEX(watchdog_mutex); |
ab992dc38
|
33 |
|
05a4a9527
|
34 |
#if defined(CONFIG_HARDLOCKUP_DETECTOR) || defined(CONFIG_HAVE_NMI_WATCHDOG) |
091549858
|
35 36 |
# define WATCHDOG_DEFAULT (SOFT_WATCHDOG_ENABLED | NMI_WATCHDOG_ENABLED) # define NMI_WATCHDOG_DEFAULT 1 |
84d56e66b
|
37 |
#else |
091549858
|
38 39 |
# define WATCHDOG_DEFAULT (SOFT_WATCHDOG_ENABLED) # define NMI_WATCHDOG_DEFAULT 0 |
84d56e66b
|
40 |
#endif |
05a4a9527
|
41 |
|
091549858
|
42 43 44 45 |
unsigned long __read_mostly watchdog_enabled; int __read_mostly watchdog_user_enabled = 1; int __read_mostly nmi_watchdog_user_enabled = NMI_WATCHDOG_DEFAULT; int __read_mostly soft_watchdog_user_enabled = 1; |
7feeb9cd4
|
46 |
int __read_mostly watchdog_thresh = 10; |
a994a3147
|
47 |
int __read_mostly nmi_watchdog_available; |
7feeb9cd4
|
48 49 |
struct cpumask watchdog_allowed_mask __read_mostly; |
7feeb9cd4
|
50 51 52 |
struct cpumask watchdog_cpumask __read_mostly; unsigned long *watchdog_cpumask_bits = cpumask_bits(&watchdog_cpumask); |
05a4a9527
|
53 |
#ifdef CONFIG_HARDLOCKUP_DETECTOR |
05a4a9527
|
54 55 56 57 58 59 60 61 62 63 64 65 66 |
/* * Should we panic when a soft-lockup or hard-lockup occurs: */ unsigned int __read_mostly hardlockup_panic = CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE; /* * We may not want to enable hard lockup detection by default in all cases, * for example when running the kernel as a guest on a hypervisor. In these * cases this function can be called to disable hard lockup detection. This * function should only be executed once by the boot processor before the * kernel command line parameters are parsed, because otherwise it is not * possible to override this in hardlockup_panic_setup(). */ |
7a3558200
|
67 |
void __init hardlockup_detector_disable(void) |
05a4a9527
|
68 |
{ |
091549858
|
69 |
nmi_watchdog_user_enabled = 0; |
05a4a9527
|
70 71 72 73 74 75 76 77 78 |
} static int __init hardlockup_panic_setup(char *str) { if (!strncmp(str, "panic", 5)) hardlockup_panic = 1; else if (!strncmp(str, "nopanic", 7)) hardlockup_panic = 0; else if (!strncmp(str, "0", 1)) |
091549858
|
79 |
nmi_watchdog_user_enabled = 0; |
05a4a9527
|
80 |
else if (!strncmp(str, "1", 1)) |
091549858
|
81 |
nmi_watchdog_user_enabled = 1; |
05a4a9527
|
82 83 84 |
return 1; } __setup("nmi_watchdog=", hardlockup_panic_setup); |
368a7e2ce
|
85 86 |
# ifdef CONFIG_SMP int __read_mostly sysctl_hardlockup_all_cpu_backtrace; |
05a4a9527
|
87 |
|
368a7e2ce
|
88 89 90 91 92 93 94 95 |
static int __init hardlockup_all_cpu_backtrace_setup(char *str) { sysctl_hardlockup_all_cpu_backtrace = !!simple_strtol(str, NULL, 0); return 1; } __setup("hardlockup_all_cpu_backtrace=", hardlockup_all_cpu_backtrace_setup); # endif /* CONFIG_SMP */ #endif /* CONFIG_HARDLOCKUP_DETECTOR */ |
05a4a9527
|
96 |
|
ec6a90661
|
97 |
/* |
05a4a9527
|
98 99 |
* These functions can be overridden if an architecture implements its * own hardlockup detector. |
a10a842ff
|
100 101 102 103 |
* * watchdog_nmi_enable/disable can be implemented to start and stop when * softlockup watchdog threads start and stop. The arch must select the * SOFTLOCKUP_DETECTOR Kconfig. |
05a4a9527
|
104 105 106 |
*/ int __weak watchdog_nmi_enable(unsigned int cpu) { |
146c9d0e9
|
107 |
hardlockup_detector_perf_enable(); |
05a4a9527
|
108 109 |
return 0; } |
941154bd6
|
110 |
|
05a4a9527
|
111 112 |
void __weak watchdog_nmi_disable(unsigned int cpu) { |
941154bd6
|
113 |
hardlockup_detector_perf_disable(); |
05a4a9527
|
114 |
} |
a994a3147
|
115 116 117 118 119 |
/* Return 0, if a NMI watchdog is available. Error code otherwise */ int __weak __init watchdog_nmi_probe(void) { return hardlockup_detector_perf_init(); } |
6592ad2fc
|
120 |
/** |
6b9dc4806
|
121 |
* watchdog_nmi_stop - Stop the watchdog for reconfiguration |
6592ad2fc
|
122 |
* |
6b9dc4806
|
123 124 |
* The reconfiguration steps are: * watchdog_nmi_stop(); |
6592ad2fc
|
125 |
* update_variables(); |
6b9dc4806
|
126 127 128 129 130 131 |
* watchdog_nmi_start(); */ void __weak watchdog_nmi_stop(void) { } /** * watchdog_nmi_start - Start the watchdog after reconfiguration |
6592ad2fc
|
132 |
* |
6b9dc4806
|
133 134 135 136 |
* Counterpart to watchdog_nmi_stop(). * * The following variables have been updated in update_variables() and * contain the currently valid configuration: |
7feeb9cd4
|
137 |
* - watchdog_enabled |
a10a842ff
|
138 139 |
* - watchdog_thresh * - watchdog_cpumask |
a10a842ff
|
140 |
*/ |
6b9dc4806
|
141 |
void __weak watchdog_nmi_start(void) { } |
a10a842ff
|
142 |
|
091549858
|
143 144 145 146 147 148 149 150 151 152 153 |
/** * lockup_detector_update_enable - Update the sysctl enable bit * * Caller needs to make sure that the NMI/perf watchdogs are off, so this * can't race with watchdog_nmi_disable(). */ static void lockup_detector_update_enable(void) { watchdog_enabled = 0; if (!watchdog_user_enabled) return; |
a994a3147
|
154 |
if (nmi_watchdog_available && nmi_watchdog_user_enabled) |
091549858
|
155 156 157 158 |
watchdog_enabled |= NMI_WATCHDOG_ENABLED; if (soft_watchdog_user_enabled) watchdog_enabled |= SOFT_WATCHDOG_ENABLED; } |
05a4a9527
|
159 |
#ifdef CONFIG_SOFTLOCKUP_DETECTOR |
2b9d7f233
|
160 161 162 |
/* Global variables, exported for sysctl */ unsigned int __read_mostly softlockup_panic = CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE; |
2eb2527f8
|
163 |
|
0b62bf862
|
164 |
static bool softlockup_threads_initialized __read_mostly; |
0f34c4009
|
165 |
static u64 __read_mostly sample_period; |
58687acba
|
166 167 168 169 170 |
static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts); static DEFINE_PER_CPU(struct task_struct *, softlockup_watchdog); static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer); static DEFINE_PER_CPU(bool, softlockup_touch_sync); |
58687acba
|
171 |
static DEFINE_PER_CPU(bool, soft_watchdog_warn); |
bcd951cf1
|
172 173 |
static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts); static DEFINE_PER_CPU(unsigned long, soft_lockup_hrtimer_cnt); |
b1a8de1f5
|
174 |
static DEFINE_PER_CPU(struct task_struct *, softlockup_task_ptr_saved); |
58687acba
|
175 |
static DEFINE_PER_CPU(unsigned long, hrtimer_interrupts_saved); |
ed235875e
|
176 |
static unsigned long soft_lockup_nmi_warn; |
58687acba
|
177 |
|
58687acba
|
178 179 180 |
static int __init softlockup_panic_setup(char *str) { softlockup_panic = simple_strtoul(str, NULL, 0); |
58687acba
|
181 182 183 184 185 186 |
return 1; } __setup("softlockup_panic=", softlockup_panic_setup); static int __init nowatchdog_setup(char *str) { |
091549858
|
187 |
watchdog_user_enabled = 0; |
58687acba
|
188 189 190 |
return 1; } __setup("nowatchdog", nowatchdog_setup); |
58687acba
|
191 192 |
static int __init nosoftlockup_setup(char *str) { |
091549858
|
193 |
soft_watchdog_user_enabled = 0; |
58687acba
|
194 195 196 |
return 1; } __setup("nosoftlockup", nosoftlockup_setup); |
195daf665
|
197 |
|
ed235875e
|
198 |
#ifdef CONFIG_SMP |
368a7e2ce
|
199 |
int __read_mostly sysctl_softlockup_all_cpu_backtrace; |
ed235875e
|
200 201 |
static int __init softlockup_all_cpu_backtrace_setup(char *str) { |
368a7e2ce
|
202 |
sysctl_softlockup_all_cpu_backtrace = !!simple_strtol(str, NULL, 0); |
ed235875e
|
203 204 205 |
return 1; } __setup("softlockup_all_cpu_backtrace=", softlockup_all_cpu_backtrace_setup); |
05a4a9527
|
206 |
#endif |
58687acba
|
207 |
|
941154bd6
|
208 |
static void __lockup_detector_cleanup(void); |
4eec42f39
|
209 210 211 212 213 214 215 |
/* * Hard-lockup warnings should be triggered after just a few seconds. Soft- * lockups can have false positives under extreme conditions. So we generally * want a higher threshold for soft lockups than for hard lockups. So we couple * the thresholds with a factor: we make the soft threshold twice the amount of * time the hard threshold is. */ |
6e9101aee
|
216 |
static int get_softlockup_thresh(void) |
4eec42f39
|
217 218 219 |
{ return watchdog_thresh * 2; } |
58687acba
|
220 221 222 223 224 225 |
/* * Returns seconds, approximately. We don't need nanosecond * resolution, and we don't need to waste time with a big divide when * 2^30ns == 1.074s. */ |
c06b4f194
|
226 |
static unsigned long get_timestamp(void) |
58687acba
|
227 |
{ |
545a2bf74
|
228 |
return running_clock() >> 30LL; /* 2^30 ~= 10^9 */ |
58687acba
|
229 |
} |
0f34c4009
|
230 |
static void set_sample_period(void) |
58687acba
|
231 232 |
{ /* |
586692a5a
|
233 |
* convert watchdog_thresh from seconds to ns |
86f5e6a7b
|
234 235 236 237 |
* the divide by 5 is to give hrtimer several chances (two * or three with the current relation between the soft * and hard thresholds) to increment before the * hardlockup detector generates a warning |
58687acba
|
238 |
*/ |
0f34c4009
|
239 |
sample_period = get_softlockup_thresh() * ((u64)NSEC_PER_SEC / 5); |
7edaeb684
|
240 |
watchdog_update_hrtimer_threshold(sample_period); |
58687acba
|
241 242 243 244 245 |
} /* Commands for resetting the watchdog */ static void __touch_watchdog(void) { |
c06b4f194
|
246 |
__this_cpu_write(watchdog_touch_ts, get_timestamp()); |
58687acba
|
247 |
} |
03e0d4610
|
248 249 250 251 252 253 254 255 |
/** * touch_softlockup_watchdog_sched - touch watchdog on scheduler stalls * * Call when the scheduler may have stalled for legitimate reasons * preventing the watchdog task from executing - e.g. the scheduler * entering idle state. This should only be used for scheduler events. * Use touch_softlockup_watchdog() for everything else. */ |
63a0f9de0
|
256 |
notrace void touch_softlockup_watchdog_sched(void) |
58687acba
|
257 |
{ |
7861144b8
|
258 259 260 261 262 |
/* * Preemption can be enabled. It doesn't matter which CPU's timestamp * gets zeroed here, so use the raw_ operation. */ raw_cpu_write(watchdog_touch_ts, 0); |
58687acba
|
263 |
} |
03e0d4610
|
264 |
|
63a0f9de0
|
265 |
notrace void touch_softlockup_watchdog(void) |
03e0d4610
|
266 267 |
{ touch_softlockup_watchdog_sched(); |
82607adcf
|
268 |
wq_watchdog_touch(raw_smp_processor_id()); |
03e0d4610
|
269 |
} |
0167c7819
|
270 |
EXPORT_SYMBOL(touch_softlockup_watchdog); |
58687acba
|
271 |
|
332fbdbca
|
272 |
void touch_all_softlockup_watchdogs(void) |
58687acba
|
273 274 275 276 |
{ int cpu; /* |
d57108d4f
|
277 278 279 280 281 282 283 |
* watchdog_mutex cannpt be taken here, as this might be called * from (soft)interrupt context, so the access to * watchdog_allowed_cpumask might race with a concurrent update. * * The watchdog time stamp can race against a concurrent real * update as well, the only side effect might be a cycle delay for * the softlockup check. |
58687acba
|
284 |
*/ |
d57108d4f
|
285 |
for_each_cpu(cpu, &watchdog_allowed_mask) |
58687acba
|
286 |
per_cpu(watchdog_touch_ts, cpu) = 0; |
82607adcf
|
287 |
wq_watchdog_touch(-1); |
58687acba
|
288 |
} |
58687acba
|
289 290 |
void touch_softlockup_watchdog_sync(void) { |
f7f66b05a
|
291 292 |
__this_cpu_write(softlockup_touch_sync, true); __this_cpu_write(watchdog_touch_ts, 0); |
58687acba
|
293 |
} |
26e09c6ee
|
294 |
static int is_softlockup(unsigned long touch_ts) |
58687acba
|
295 |
{ |
c06b4f194
|
296 |
unsigned long now = get_timestamp(); |
58687acba
|
297 |
|
39d2da216
|
298 |
if ((watchdog_enabled & SOFT_WATCHDOG_ENABLED) && watchdog_thresh){ |
195daf665
|
299 300 301 302 |
/* Warn about unreasonable delays. */ if (time_after(now, touch_ts + get_softlockup_thresh())) return now - touch_ts; } |
58687acba
|
303 304 |
return 0; } |
05a4a9527
|
305 306 |
/* watchdog detector functions */ bool is_hardlockup(void) |
58687acba
|
307 |
{ |
05a4a9527
|
308 |
unsigned long hrint = __this_cpu_read(hrtimer_interrupts); |
bcd951cf1
|
309 |
|
05a4a9527
|
310 311 312 313 314 |
if (__this_cpu_read(hrtimer_interrupts_saved) == hrint) return true; __this_cpu_write(hrtimer_interrupts_saved, hrint); return false; |
73ce0511c
|
315 |
} |
05a4a9527
|
316 317 |
static void watchdog_interrupt_count(void) |
73ce0511c
|
318 |
{ |
05a4a9527
|
319 |
__this_cpu_inc(hrtimer_interrupts); |
73ce0511c
|
320 |
} |
58687acba
|
321 322 323 324 |
/* watchdog kicker functions */ static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer) { |
909ea9646
|
325 |
unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts); |
58687acba
|
326 327 |
struct pt_regs *regs = get_irq_regs(); int duration; |
ed235875e
|
328 |
int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace; |
58687acba
|
329 |
|
01f0a0270
|
330 |
if (!watchdog_enabled) |
b94f51183
|
331 |
return HRTIMER_NORESTART; |
58687acba
|
332 333 334 335 |
/* kick the hardlockup detector */ watchdog_interrupt_count(); /* kick the softlockup detector */ |
909ea9646
|
336 |
wake_up_process(__this_cpu_read(softlockup_watchdog)); |
58687acba
|
337 338 |
/* .. and repeat */ |
0f34c4009
|
339 |
hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period)); |
58687acba
|
340 341 |
if (touch_ts == 0) { |
909ea9646
|
342 |
if (unlikely(__this_cpu_read(softlockup_touch_sync))) { |
58687acba
|
343 344 345 346 |
/* * If the time stamp was touched atomically * make sure the scheduler tick is up to date. */ |
909ea9646
|
347 |
__this_cpu_write(softlockup_touch_sync, false); |
58687acba
|
348 349 |
sched_clock_tick(); } |
5d1c0f4a8
|
350 351 352 |
/* Clear the guest paused flag on watchdog reset */ kvm_check_and_clear_guest_paused(); |
58687acba
|
353 354 355 356 357 358 359 360 361 362 |
__touch_watchdog(); return HRTIMER_RESTART; } /* check for a softlockup * This is done by making sure a high priority task is * being scheduled. The task touches the watchdog to * indicate it is getting cpu time. If it hasn't then * this is a good indication some task is hogging the cpu */ |
26e09c6ee
|
363 |
duration = is_softlockup(touch_ts); |
58687acba
|
364 |
if (unlikely(duration)) { |
5d1c0f4a8
|
365 366 367 368 369 370 371 |
/* * If a virtual machine is stopped by the host it can look to * the watchdog like a soft lockup, check to see if the host * stopped the vm before we issue the warning */ if (kvm_check_and_clear_guest_paused()) return HRTIMER_RESTART; |
58687acba
|
372 |
/* only warn once */ |
b1a8de1f5
|
373 374 375 376 377 378 379 380 381 382 383 384 385 386 |
if (__this_cpu_read(soft_watchdog_warn) == true) { /* * When multiple processes are causing softlockups the * softlockup detector only warns on the first one * because the code relies on a full quiet cycle to * re-arm. The second process prevents the quiet cycle * and never gets reported. Use task pointers to detect * this. */ if (__this_cpu_read(softlockup_task_ptr_saved) != current) { __this_cpu_write(soft_watchdog_warn, false); __touch_watchdog(); } |
58687acba
|
387 |
return HRTIMER_RESTART; |
b1a8de1f5
|
388 |
} |
58687acba
|
389 |
|
ed235875e
|
390 391 392 393 394 395 396 397 398 399 |
if (softlockup_all_cpu_backtrace) { /* Prevent multiple soft-lockup reports if one cpu is already * engaged in dumping cpu back traces */ if (test_and_set_bit(0, &soft_lockup_nmi_warn)) { /* Someone else will report us. Let's give up */ __this_cpu_write(soft_watchdog_warn, true); return HRTIMER_RESTART; } } |
656c3b79f
|
400 401 |
pr_emerg("BUG: soft lockup - CPU#%d stuck for %us! [%s:%d] ", |
26e09c6ee
|
402 |
smp_processor_id(), duration, |
58687acba
|
403 |
current->comm, task_pid_nr(current)); |
b1a8de1f5
|
404 |
__this_cpu_write(softlockup_task_ptr_saved, current); |
58687acba
|
405 406 407 408 409 410 |
print_modules(); print_irqtrace_events(current); if (regs) show_regs(regs); else dump_stack(); |
ed235875e
|
411 412 413 414 415 416 417 418 419 420 |
if (softlockup_all_cpu_backtrace) { /* Avoid generating two back traces for current * given that one is already made above */ trigger_allbutself_cpu_backtrace(); clear_bit(0, &soft_lockup_nmi_warn); /* Barrier to sync with other cpus */ smp_mb__after_atomic(); } |
69361eef9
|
421 |
add_taint(TAINT_SOFTLOCKUP, LOCKDEP_STILL_OK); |
58687acba
|
422 423 |
if (softlockup_panic) panic("softlockup: hung tasks"); |
909ea9646
|
424 |
__this_cpu_write(soft_watchdog_warn, true); |
58687acba
|
425 |
} else |
909ea9646
|
426 |
__this_cpu_write(soft_watchdog_warn, false); |
58687acba
|
427 428 429 |
return HRTIMER_RESTART; } |
bcd951cf1
|
430 431 432 |
static void watchdog_set_prio(unsigned int policy, unsigned int prio) { struct sched_param param = { .sched_priority = prio }; |
58687acba
|
433 |
|
bcd951cf1
|
434 435 436 437 |
sched_setscheduler(current, policy, ¶m); } static void watchdog_enable(unsigned int cpu) |
58687acba
|
438 |
{ |
01f0a0270
|
439 |
struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer); |
58687acba
|
440 |
|
01f0a0270
|
441 442 443 444 |
/* * Start the timer first to prevent the NMI watchdog triggering * before the timer has a chance to fire. */ |
3935e8950
|
445 446 |
hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); hrtimer->function = watchdog_timer_fn; |
01f0a0270
|
447 448 |
hrtimer_start(hrtimer, ns_to_ktime(sample_period), HRTIMER_MODE_REL_PINNED); |
3935e8950
|
449 |
|
01f0a0270
|
450 451 |
/* Initialize timestamp */ __touch_watchdog(); |
bcd951cf1
|
452 |
/* Enable the perf event */ |
146c9d0e9
|
453 454 |
if (watchdog_enabled & NMI_WATCHDOG_ENABLED) watchdog_nmi_enable(cpu); |
58687acba
|
455 |
|
bcd951cf1
|
456 |
watchdog_set_prio(SCHED_FIFO, MAX_RT_PRIO - 1); |
bcd951cf1
|
457 |
} |
58687acba
|
458 |
|
bcd951cf1
|
459 460 |
static void watchdog_disable(unsigned int cpu) { |
01f0a0270
|
461 |
struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer); |
58687acba
|
462 |
|
bcd951cf1
|
463 |
watchdog_set_prio(SCHED_NORMAL, 0); |
01f0a0270
|
464 465 466 467 468 |
/* * Disable the perf event first. That prevents that a large delay * between disabling the timer and disabling the perf event causes * the perf NMI to detect a false positive. */ |
bcd951cf1
|
469 |
watchdog_nmi_disable(cpu); |
01f0a0270
|
470 |
hrtimer_cancel(hrtimer); |
58687acba
|
471 |
} |
b8900bc02
|
472 473 474 475 |
static void watchdog_cleanup(unsigned int cpu, bool online) { watchdog_disable(cpu); } |
bcd951cf1
|
476 477 478 479 480 481 482 483 484 |
static int watchdog_should_run(unsigned int cpu) { return __this_cpu_read(hrtimer_interrupts) != __this_cpu_read(soft_lockup_hrtimer_cnt); } /* * The watchdog thread function - touches the timestamp. * |
0f34c4009
|
485 |
* It only runs once every sample_period seconds (4 seconds by |
bcd951cf1
|
486 487 488 489 490 491 492 493 494 495 |
* default) to reset the softlockup timestamp. If this gets delayed * for more than 2*watchdog_thresh seconds then the debug-printout * triggers in watchdog_timer_fn(). */ static void watchdog(unsigned int cpu) { __this_cpu_write(soft_lockup_hrtimer_cnt, __this_cpu_read(hrtimer_interrupts)); __touch_watchdog(); } |
58687acba
|
496 |
|
b8900bc02
|
497 498 499 500 501 502 503 504 505 506 |
static struct smp_hotplug_thread watchdog_threads = { .store = &softlockup_watchdog, .thread_should_run = watchdog_should_run, .thread_fn = watchdog, .thread_comm = "watchdog/%u", .setup = watchdog_enable, .cleanup = watchdog_cleanup, .park = watchdog_disable, .unpark = watchdog_enable, }; |
2eb2527f8
|
507 508 509 510 511 512 513 514 515 |
static void softlockup_update_smpboot_threads(void) { lockdep_assert_held(&watchdog_mutex); if (!softlockup_threads_initialized) return; smpboot_update_cpumask_percpu_thread(&watchdog_threads, &watchdog_allowed_mask); |
2eb2527f8
|
516 517 518 519 520 521 522 523 |
} /* Temporarily park all watchdog threads */ static void softlockup_park_all_threads(void) { cpumask_clear(&watchdog_allowed_mask); softlockup_update_smpboot_threads(); } |
e8b62b2dd
|
524 525 |
/* Unpark enabled threads */ static void softlockup_unpark_threads(void) |
2eb2527f8
|
526 527 528 529 |
{ cpumask_copy(&watchdog_allowed_mask, &watchdog_cpumask); softlockup_update_smpboot_threads(); } |
5587185dd
|
530 |
static void lockup_detector_reconfigure(void) |
2eb2527f8
|
531 |
{ |
e31d6883f
|
532 |
cpus_read_lock(); |
6b9dc4806
|
533 |
watchdog_nmi_stop(); |
2eb2527f8
|
534 535 |
softlockup_park_all_threads(); set_sample_period(); |
091549858
|
536 537 |
lockup_detector_update_enable(); if (watchdog_enabled && watchdog_thresh) |
e8b62b2dd
|
538 |
softlockup_unpark_threads(); |
6b9dc4806
|
539 |
watchdog_nmi_start(); |
e31d6883f
|
540 541 542 543 544 545 |
cpus_read_unlock(); /* * Must be called outside the cpus locked section to prevent * recursive locking in the perf code. */ __lockup_detector_cleanup(); |
2eb2527f8
|
546 547 548 |
} /* |
5587185dd
|
549 |
* Create the watchdog thread infrastructure and configure the detector(s). |
2eb2527f8
|
550 551 552 553 554 |
* * The threads are not unparked as watchdog_allowed_mask is empty. When * the threads are sucessfully initialized, take the proper locks and * unpark the threads in the watchdog_cpumask if the watchdog is enabled. */ |
5587185dd
|
555 |
static __init void lockup_detector_setup(void) |
2eb2527f8
|
556 557 558 559 560 561 562 |
{ int ret; /* * If sysctl is off and watchdog got disabled on the command line, * nothing to do here. */ |
091549858
|
563 |
lockup_detector_update_enable(); |
2eb2527f8
|
564 565 566 567 568 569 570 571 572 573 574 575 576 577 |
if (!IS_ENABLED(CONFIG_SYSCTL) && !(watchdog_enabled && watchdog_thresh)) return; ret = smpboot_register_percpu_thread_cpumask(&watchdog_threads, &watchdog_allowed_mask); if (ret) { pr_err("Failed to initialize soft lockup detector threads "); return; } mutex_lock(&watchdog_mutex); softlockup_threads_initialized = true; |
5587185dd
|
578 |
lockup_detector_reconfigure(); |
2eb2527f8
|
579 580 |
mutex_unlock(&watchdog_mutex); } |
2b9d7f233
|
581 582 583 584 585 |
#else /* CONFIG_SOFTLOCKUP_DETECTOR */ static inline int watchdog_park_threads(void) { return 0; } static inline void watchdog_unpark_threads(void) { } static inline int watchdog_enable_all_cpus(void) { return 0; } static inline void watchdog_disable_all_cpus(void) { } |
5587185dd
|
586 |
static void lockup_detector_reconfigure(void) |
6592ad2fc
|
587 |
{ |
e31d6883f
|
588 |
cpus_read_lock(); |
6b9dc4806
|
589 |
watchdog_nmi_stop(); |
091549858
|
590 |
lockup_detector_update_enable(); |
6b9dc4806
|
591 |
watchdog_nmi_start(); |
e31d6883f
|
592 |
cpus_read_unlock(); |
6592ad2fc
|
593 |
} |
5587185dd
|
594 |
static inline void lockup_detector_setup(void) |
34ddaa3e5
|
595 |
{ |
5587185dd
|
596 |
lockup_detector_reconfigure(); |
34ddaa3e5
|
597 |
} |
2b9d7f233
|
598 |
#endif /* !CONFIG_SOFTLOCKUP_DETECTOR */ |
05a4a9527
|
599 |
|
941154bd6
|
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 |
static void __lockup_detector_cleanup(void) { lockdep_assert_held(&watchdog_mutex); hardlockup_detector_perf_cleanup(); } /** * lockup_detector_cleanup - Cleanup after cpu hotplug or sysctl changes * * Caller must not hold the cpu hotplug rwsem. */ void lockup_detector_cleanup(void) { mutex_lock(&watchdog_mutex); __lockup_detector_cleanup(); mutex_unlock(&watchdog_mutex); } |
6554fd8cf
|
617 618 619 620 621 622 623 624 625 626 |
/** * lockup_detector_soft_poweroff - Interface to stop lockup detector(s) * * Special interface for parisc. It prevents lockup detector warnings from * the default pm_poweroff() function which busy loops forever. */ void lockup_detector_soft_poweroff(void) { watchdog_enabled = 0; } |
58cf690a0
|
627 |
#ifdef CONFIG_SYSCTL |
e8b62b2dd
|
628 |
/* Propagate any changes to the watchdog threads */ |
d57108d4f
|
629 |
static void proc_watchdog_update(void) |
a0c9cbb93
|
630 |
{ |
e8b62b2dd
|
631 632 |
/* Remove impossible cpus to keep sysctl output clean. */ cpumask_and(&watchdog_cpumask, &watchdog_cpumask, cpu_possible_mask); |
5587185dd
|
633 |
lockup_detector_reconfigure(); |
a0c9cbb93
|
634 635 636 |
} /* |
ef246a216
|
637 638 |
* common function for watchdog, nmi_watchdog and soft_watchdog parameter * |
7feeb9cd4
|
639 640 641 642 643 644 645 646 |
* caller | table->data points to | 'which' * -------------------|----------------------------|-------------------------- * proc_watchdog | watchdog_user_enabled | NMI_WATCHDOG_ENABLED | * | | SOFT_WATCHDOG_ENABLED * -------------------|----------------------------|-------------------------- * proc_nmi_watchdog | nmi_watchdog_user_enabled | NMI_WATCHDOG_ENABLED * -------------------|----------------------------|-------------------------- * proc_soft_watchdog | soft_watchdog_user_enabled | SOFT_WATCHDOG_ENABLED |
ef246a216
|
647 648 649 650 |
*/ static int proc_watchdog_common(int which, struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { |
091549858
|
651 |
int err, old, *param = table->data; |
ef246a216
|
652 |
|
946d19779
|
653 |
mutex_lock(&watchdog_mutex); |
ef246a216
|
654 |
|
ef246a216
|
655 |
if (!write) { |
091549858
|
656 657 658 659 660 |
/* * On read synchronize the userspace interface. This is a * racy snapshot. */ *param = (watchdog_enabled & which) != 0; |
ef246a216
|
661 662 |
err = proc_dointvec_minmax(table, write, buffer, lenp, ppos); } else { |
091549858
|
663 |
old = READ_ONCE(*param); |
ef246a216
|
664 |
err = proc_dointvec_minmax(table, write, buffer, lenp, ppos); |
091549858
|
665 |
if (!err && old != READ_ONCE(*param)) |
d57108d4f
|
666 |
proc_watchdog_update(); |
ef246a216
|
667 |
} |
946d19779
|
668 |
mutex_unlock(&watchdog_mutex); |
ef246a216
|
669 670 671 672 |
return err; } /* |
83a80a390
|
673 674 675 676 677 678 679 680 681 682 683 |
* /proc/sys/kernel/watchdog */ int proc_watchdog(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { return proc_watchdog_common(NMI_WATCHDOG_ENABLED|SOFT_WATCHDOG_ENABLED, table, write, buffer, lenp, ppos); } /* * /proc/sys/kernel/nmi_watchdog |
58687acba
|
684 |
*/ |
83a80a390
|
685 686 687 |
int proc_nmi_watchdog(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { |
a994a3147
|
688 689 |
if (!nmi_watchdog_available && write) return -ENOTSUPP; |
83a80a390
|
690 691 692 693 694 695 696 697 698 699 700 701 702 |
return proc_watchdog_common(NMI_WATCHDOG_ENABLED, table, write, buffer, lenp, ppos); } /* * /proc/sys/kernel/soft_watchdog */ int proc_soft_watchdog(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { return proc_watchdog_common(SOFT_WATCHDOG_ENABLED, table, write, buffer, lenp, ppos); } |
58687acba
|
703 |
|
83a80a390
|
704 705 706 707 708 |
/* * /proc/sys/kernel/watchdog_thresh */ int proc_watchdog_thresh(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) |
58687acba
|
709 |
{ |
d57108d4f
|
710 |
int err, old; |
58687acba
|
711 |
|
946d19779
|
712 |
mutex_lock(&watchdog_mutex); |
bcd951cf1
|
713 |
|
d57108d4f
|
714 |
old = READ_ONCE(watchdog_thresh); |
b8900bc02
|
715 |
err = proc_dointvec_minmax(table, write, buffer, lenp, ppos); |
83a80a390
|
716 |
|
d57108d4f
|
717 718 |
if (!err && write && old != READ_ONCE(watchdog_thresh)) proc_watchdog_update(); |
e04ab2bc4
|
719 |
|
946d19779
|
720 |
mutex_unlock(&watchdog_mutex); |
b8900bc02
|
721 |
return err; |
58687acba
|
722 |
} |
fe4ba3c34
|
723 724 725 726 727 728 729 730 731 732 733 |
/* * The cpumask is the mask of possible cpus that the watchdog can run * on, not the mask of cpus it is actually running on. This allows the * user to specify a mask that will include cpus that have not yet * been brought online, if desired. */ int proc_watchdog_cpumask(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos) { int err; |
946d19779
|
734 |
mutex_lock(&watchdog_mutex); |
8c073d27d
|
735 |
|
fe4ba3c34
|
736 |
err = proc_do_large_bitmap(table, write, buffer, lenp, ppos); |
05ba3de74
|
737 |
if (!err && write) |
e8b62b2dd
|
738 |
proc_watchdog_update(); |
5490125d7
|
739 |
|
946d19779
|
740 |
mutex_unlock(&watchdog_mutex); |
fe4ba3c34
|
741 742 |
return err; } |
58687acba
|
743 |
#endif /* CONFIG_SYSCTL */ |
004417a6d
|
744 |
void __init lockup_detector_init(void) |
58687acba
|
745 |
{ |
fe4ba3c34
|
746 747 |
#ifdef CONFIG_NO_HZ_FULL if (tick_nohz_full_enabled()) { |
314b08ff5
|
748 749 750 |
pr_info("Disabling watchdog on nohz_full cores by default "); cpumask_copy(&watchdog_cpumask, housekeeping_mask); |
fe4ba3c34
|
751 752 753 754 755 |
} else cpumask_copy(&watchdog_cpumask, cpu_possible_mask); #else cpumask_copy(&watchdog_cpumask, cpu_possible_mask); #endif |
a994a3147
|
756 757 |
if (!watchdog_nmi_probe()) nmi_watchdog_available = true; |
5587185dd
|
758 |
lockup_detector_setup(); |
58687acba
|
759 |
} |