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