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/cpu.h> 16 #include <linux/init.h> 17 #include <linux/irq.h> 18 #include <linux/irqdesc.h> 19 #include <linux/kernel_stat.h> 20 #include <linux/kvm_para.h> 21 #include <linux/math64.h> 22 #include <linux/mm.h> 23 #include <linux/module.h> 24 #include <linux/nmi.h> 25 #include <linux/stop_machine.h> 26 #include <linux/sysctl.h> 27 #include <linux/tick.h> 28 29 #include <linux/sched/clock.h> 30 #include <linux/sched/debug.h> 31 #include <linux/sched/isolation.h> 32 33 #include <asm/irq_regs.h> 34 35 static DEFINE_MUTEX(watchdog_mutex); 36 37 #if defined(CONFIG_HARDLOCKUP_DETECTOR) || defined(CONFIG_HARDLOCKUP_DETECTOR_SPARC64) 38 # define WATCHDOG_HARDLOCKUP_DEFAULT 1 39 #else 40 # define WATCHDOG_HARDLOCKUP_DEFAULT 0 41 #endif 42 43 #define NUM_SAMPLE_PERIODS 5 44 45 unsigned long __read_mostly watchdog_enabled; 46 int __read_mostly watchdog_user_enabled = 1; 47 static int __read_mostly watchdog_hardlockup_user_enabled = WATCHDOG_HARDLOCKUP_DEFAULT; 48 static int __read_mostly watchdog_softlockup_user_enabled = 1; 49 int __read_mostly watchdog_thresh = 10; 50 static int __read_mostly watchdog_hardlockup_available; 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 # ifdef CONFIG_SMP 58 int __read_mostly sysctl_hardlockup_all_cpu_backtrace; 59 # endif /* CONFIG_SMP */ 60 61 /* 62 * Should we panic when a soft-lockup or hard-lockup occurs: 63 */ 64 unsigned int __read_mostly hardlockup_panic = 65 IS_ENABLED(CONFIG_BOOTPARAM_HARDLOCKUP_PANIC); 66 /* 67 * We may not want to enable hard lockup detection by default in all cases, 68 * for example when running the kernel as a guest on a hypervisor. In these 69 * cases this function can be called to disable hard lockup detection. This 70 * function should only be executed once by the boot processor before the 71 * kernel command line parameters are parsed, because otherwise it is not 72 * possible to override this in hardlockup_panic_setup(). 73 */ 74 void __init hardlockup_detector_disable(void) 75 { 76 watchdog_hardlockup_user_enabled = 0; 77 } 78 79 static int __init hardlockup_panic_setup(char *str) 80 { 81 next: 82 if (!strncmp(str, "panic", 5)) 83 hardlockup_panic = 1; 84 else if (!strncmp(str, "nopanic", 7)) 85 hardlockup_panic = 0; 86 else if (!strncmp(str, "0", 1)) 87 watchdog_hardlockup_user_enabled = 0; 88 else if (!strncmp(str, "1", 1)) 89 watchdog_hardlockup_user_enabled = 1; 90 else if (!strncmp(str, "r", 1)) 91 hardlockup_config_perf_event(str + 1); 92 while (*(str++)) { 93 if (*str == ',') { 94 str++; 95 goto next; 96 } 97 } 98 return 1; 99 } 100 __setup("nmi_watchdog=", hardlockup_panic_setup); 101 102 #endif /* CONFIG_HARDLOCKUP_DETECTOR */ 103 104 #if defined(CONFIG_HARDLOCKUP_DETECTOR_COUNTS_HRTIMER) 105 106 static DEFINE_PER_CPU(atomic_t, hrtimer_interrupts); 107 static DEFINE_PER_CPU(int, hrtimer_interrupts_saved); 108 static DEFINE_PER_CPU(bool, watchdog_hardlockup_warned); 109 static DEFINE_PER_CPU(bool, watchdog_hardlockup_touched); 110 static unsigned long hard_lockup_nmi_warn; 111 112 notrace void arch_touch_nmi_watchdog(void) 113 { 114 /* 115 * Using __raw here because some code paths have 116 * preemption enabled. If preemption is enabled 117 * then interrupts should be enabled too, in which 118 * case we shouldn't have to worry about the watchdog 119 * going off. 120 */ 121 raw_cpu_write(watchdog_hardlockup_touched, true); 122 } 123 EXPORT_SYMBOL(arch_touch_nmi_watchdog); 124 125 void watchdog_hardlockup_touch_cpu(unsigned int cpu) 126 { 127 per_cpu(watchdog_hardlockup_touched, cpu) = true; 128 } 129 130 static bool is_hardlockup(unsigned int cpu) 131 { 132 int hrint = atomic_read(&per_cpu(hrtimer_interrupts, cpu)); 133 134 if (per_cpu(hrtimer_interrupts_saved, cpu) == hrint) 135 return true; 136 137 /* 138 * NOTE: we don't need any fancy atomic_t or READ_ONCE/WRITE_ONCE 139 * for hrtimer_interrupts_saved. hrtimer_interrupts_saved is 140 * written/read by a single CPU. 141 */ 142 per_cpu(hrtimer_interrupts_saved, cpu) = hrint; 143 144 return false; 145 } 146 147 static void watchdog_hardlockup_kick(void) 148 { 149 int new_interrupts; 150 151 new_interrupts = atomic_inc_return(this_cpu_ptr(&hrtimer_interrupts)); 152 watchdog_buddy_check_hardlockup(new_interrupts); 153 } 154 155 void watchdog_hardlockup_check(unsigned int cpu, struct pt_regs *regs) 156 { 157 if (per_cpu(watchdog_hardlockup_touched, cpu)) { 158 per_cpu(watchdog_hardlockup_touched, cpu) = false; 159 return; 160 } 161 162 /* 163 * Check for a hardlockup by making sure the CPU's timer 164 * interrupt is incrementing. The timer interrupt should have 165 * fired multiple times before we overflow'd. If it hasn't 166 * then this is a good indication the cpu is stuck 167 */ 168 if (is_hardlockup(cpu)) { 169 unsigned int this_cpu = smp_processor_id(); 170 unsigned long flags; 171 172 /* Only print hardlockups once. */ 173 if (per_cpu(watchdog_hardlockup_warned, cpu)) 174 return; 175 176 /* 177 * Prevent multiple hard-lockup reports if one cpu is already 178 * engaged in dumping all cpu back traces. 179 */ 180 if (sysctl_hardlockup_all_cpu_backtrace) { 181 if (test_and_set_bit_lock(0, &hard_lockup_nmi_warn)) 182 return; 183 } 184 185 /* 186 * NOTE: we call printk_cpu_sync_get_irqsave() after printing 187 * the lockup message. While it would be nice to serialize 188 * that printout, we really want to make sure that if some 189 * other CPU somehow locked up while holding the lock associated 190 * with printk_cpu_sync_get_irqsave() that we can still at least 191 * get the message about the lockup out. 192 */ 193 pr_emerg("Watchdog detected hard LOCKUP on cpu %d\n", cpu); 194 printk_cpu_sync_get_irqsave(flags); 195 196 print_modules(); 197 print_irqtrace_events(current); 198 if (cpu == this_cpu) { 199 if (regs) 200 show_regs(regs); 201 else 202 dump_stack(); 203 printk_cpu_sync_put_irqrestore(flags); 204 } else { 205 printk_cpu_sync_put_irqrestore(flags); 206 trigger_single_cpu_backtrace(cpu); 207 } 208 209 if (sysctl_hardlockup_all_cpu_backtrace) { 210 trigger_allbutcpu_cpu_backtrace(cpu); 211 if (!hardlockup_panic) 212 clear_bit_unlock(0, &hard_lockup_nmi_warn); 213 } 214 215 if (hardlockup_panic) 216 nmi_panic(regs, "Hard LOCKUP"); 217 218 per_cpu(watchdog_hardlockup_warned, cpu) = true; 219 } else { 220 per_cpu(watchdog_hardlockup_warned, cpu) = false; 221 } 222 } 223 224 #else /* CONFIG_HARDLOCKUP_DETECTOR_COUNTS_HRTIMER */ 225 226 static inline void watchdog_hardlockup_kick(void) { } 227 228 #endif /* !CONFIG_HARDLOCKUP_DETECTOR_COUNTS_HRTIMER */ 229 230 /* 231 * These functions can be overridden based on the configured hardlockdup detector. 232 * 233 * watchdog_hardlockup_enable/disable can be implemented to start and stop when 234 * softlockup watchdog start and stop. The detector must select the 235 * SOFTLOCKUP_DETECTOR Kconfig. 236 */ 237 void __weak watchdog_hardlockup_enable(unsigned int cpu) { } 238 239 void __weak watchdog_hardlockup_disable(unsigned int cpu) { } 240 241 /* 242 * Watchdog-detector specific API. 243 * 244 * Return 0 when hardlockup watchdog is available, negative value otherwise. 245 * Note that the negative value means that a delayed probe might 246 * succeed later. 247 */ 248 int __weak __init watchdog_hardlockup_probe(void) 249 { 250 return -ENODEV; 251 } 252 253 /** 254 * watchdog_hardlockup_stop - Stop the watchdog for reconfiguration 255 * 256 * The reconfiguration steps are: 257 * watchdog_hardlockup_stop(); 258 * update_variables(); 259 * watchdog_hardlockup_start(); 260 */ 261 void __weak watchdog_hardlockup_stop(void) { } 262 263 /** 264 * watchdog_hardlockup_start - Start the watchdog after reconfiguration 265 * 266 * Counterpart to watchdog_hardlockup_stop(). 267 * 268 * The following variables have been updated in update_variables() and 269 * contain the currently valid configuration: 270 * - watchdog_enabled 271 * - watchdog_thresh 272 * - watchdog_cpumask 273 */ 274 void __weak watchdog_hardlockup_start(void) { } 275 276 /** 277 * lockup_detector_update_enable - Update the sysctl enable bit 278 * 279 * Caller needs to make sure that the hard watchdogs are off, so this 280 * can't race with watchdog_hardlockup_disable(). 281 */ 282 static void lockup_detector_update_enable(void) 283 { 284 watchdog_enabled = 0; 285 if (!watchdog_user_enabled) 286 return; 287 if (watchdog_hardlockup_available && watchdog_hardlockup_user_enabled) 288 watchdog_enabled |= WATCHDOG_HARDLOCKUP_ENABLED; 289 if (watchdog_softlockup_user_enabled) 290 watchdog_enabled |= WATCHDOG_SOFTOCKUP_ENABLED; 291 } 292 293 #ifdef CONFIG_SOFTLOCKUP_DETECTOR 294 295 /* 296 * Delay the soflockup report when running a known slow code. 297 * It does _not_ affect the timestamp of the last successdul reschedule. 298 */ 299 #define SOFTLOCKUP_DELAY_REPORT ULONG_MAX 300 301 #ifdef CONFIG_SMP 302 int __read_mostly sysctl_softlockup_all_cpu_backtrace; 303 #endif 304 305 static struct cpumask watchdog_allowed_mask __read_mostly; 306 307 /* Global variables, exported for sysctl */ 308 unsigned int __read_mostly softlockup_panic = 309 IS_ENABLED(CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC); 310 311 static bool softlockup_initialized __read_mostly; 312 static u64 __read_mostly sample_period; 313 314 /* Timestamp taken after the last successful reschedule. */ 315 static DEFINE_PER_CPU(unsigned long, watchdog_touch_ts); 316 /* Timestamp of the last softlockup report. */ 317 static DEFINE_PER_CPU(unsigned long, watchdog_report_ts); 318 static DEFINE_PER_CPU(struct hrtimer, watchdog_hrtimer); 319 static DEFINE_PER_CPU(bool, softlockup_touch_sync); 320 static unsigned long soft_lockup_nmi_warn; 321 322 static int __init softlockup_panic_setup(char *str) 323 { 324 softlockup_panic = simple_strtoul(str, NULL, 0); 325 return 1; 326 } 327 __setup("softlockup_panic=", softlockup_panic_setup); 328 329 static int __init nowatchdog_setup(char *str) 330 { 331 watchdog_user_enabled = 0; 332 return 1; 333 } 334 __setup("nowatchdog", nowatchdog_setup); 335 336 static int __init nosoftlockup_setup(char *str) 337 { 338 watchdog_softlockup_user_enabled = 0; 339 return 1; 340 } 341 __setup("nosoftlockup", nosoftlockup_setup); 342 343 static int __init watchdog_thresh_setup(char *str) 344 { 345 get_option(&str, &watchdog_thresh); 346 return 1; 347 } 348 __setup("watchdog_thresh=", watchdog_thresh_setup); 349 350 static void __lockup_detector_cleanup(void); 351 352 #ifdef CONFIG_SOFTLOCKUP_DETECTOR_INTR_STORM 353 enum stats_per_group { 354 STATS_SYSTEM, 355 STATS_SOFTIRQ, 356 STATS_HARDIRQ, 357 STATS_IDLE, 358 NUM_STATS_PER_GROUP, 359 }; 360 361 static const enum cpu_usage_stat tracked_stats[NUM_STATS_PER_GROUP] = { 362 CPUTIME_SYSTEM, 363 CPUTIME_SOFTIRQ, 364 CPUTIME_IRQ, 365 CPUTIME_IDLE, 366 }; 367 368 static DEFINE_PER_CPU(u16, cpustat_old[NUM_STATS_PER_GROUP]); 369 static DEFINE_PER_CPU(u8, cpustat_util[NUM_SAMPLE_PERIODS][NUM_STATS_PER_GROUP]); 370 static DEFINE_PER_CPU(u8, cpustat_tail); 371 372 /* 373 * We don't need nanosecond resolution. A granularity of 16ms is 374 * sufficient for our precision, allowing us to use u16 to store 375 * cpustats, which will roll over roughly every ~1000 seconds. 376 * 2^24 ~= 16 * 10^6 377 */ 378 static u16 get_16bit_precision(u64 data_ns) 379 { 380 return data_ns >> 24LL; /* 2^24ns ~= 16.8ms */ 381 } 382 383 static void update_cpustat(void) 384 { 385 int i; 386 u8 util; 387 u16 old_stat, new_stat; 388 struct kernel_cpustat kcpustat; 389 u64 *cpustat = kcpustat.cpustat; 390 u8 tail = __this_cpu_read(cpustat_tail); 391 u16 sample_period_16 = get_16bit_precision(sample_period); 392 393 kcpustat_cpu_fetch(&kcpustat, smp_processor_id()); 394 395 for (i = 0; i < NUM_STATS_PER_GROUP; i++) { 396 old_stat = __this_cpu_read(cpustat_old[i]); 397 new_stat = get_16bit_precision(cpustat[tracked_stats[i]]); 398 util = DIV_ROUND_UP(100 * (new_stat - old_stat), sample_period_16); 399 __this_cpu_write(cpustat_util[tail][i], util); 400 __this_cpu_write(cpustat_old[i], new_stat); 401 } 402 403 __this_cpu_write(cpustat_tail, (tail + 1) % NUM_SAMPLE_PERIODS); 404 } 405 406 static void print_cpustat(void) 407 { 408 int i, group; 409 u8 tail = __this_cpu_read(cpustat_tail); 410 u64 sample_period_second = sample_period; 411 412 do_div(sample_period_second, NSEC_PER_SEC); 413 414 /* 415 * Outputting the "watchdog" prefix on every line is redundant and not 416 * concise, and the original alarm information is sufficient for 417 * positioning in logs, hence here printk() is used instead of pr_crit(). 418 */ 419 printk(KERN_CRIT "CPU#%d Utilization every %llus during lockup:\n", 420 smp_processor_id(), sample_period_second); 421 422 for (i = 0; i < NUM_SAMPLE_PERIODS; i++) { 423 group = (tail + i) % NUM_SAMPLE_PERIODS; 424 printk(KERN_CRIT "\t#%d: %3u%% system,\t%3u%% softirq,\t" 425 "%3u%% hardirq,\t%3u%% idle\n", i + 1, 426 __this_cpu_read(cpustat_util[group][STATS_SYSTEM]), 427 __this_cpu_read(cpustat_util[group][STATS_SOFTIRQ]), 428 __this_cpu_read(cpustat_util[group][STATS_HARDIRQ]), 429 __this_cpu_read(cpustat_util[group][STATS_IDLE])); 430 } 431 } 432 433 #define HARDIRQ_PERCENT_THRESH 50 434 #define NUM_HARDIRQ_REPORT 5 435 struct irq_counts { 436 int irq; 437 u32 counts; 438 }; 439 440 static DEFINE_PER_CPU(bool, snapshot_taken); 441 442 /* Tabulate the most frequent interrupts. */ 443 static void tabulate_irq_count(struct irq_counts *irq_counts, int irq, u32 counts, int rank) 444 { 445 int i; 446 struct irq_counts new_count = {irq, counts}; 447 448 for (i = 0; i < rank; i++) { 449 if (counts > irq_counts[i].counts) 450 swap(new_count, irq_counts[i]); 451 } 452 } 453 454 /* 455 * If the hardirq time exceeds HARDIRQ_PERCENT_THRESH% of the sample_period, 456 * then the cause of softlockup might be interrupt storm. In this case, it 457 * would be useful to start interrupt counting. 458 */ 459 static bool need_counting_irqs(void) 460 { 461 u8 util; 462 int tail = __this_cpu_read(cpustat_tail); 463 464 tail = (tail + NUM_HARDIRQ_REPORT - 1) % NUM_HARDIRQ_REPORT; 465 util = __this_cpu_read(cpustat_util[tail][STATS_HARDIRQ]); 466 return util > HARDIRQ_PERCENT_THRESH; 467 } 468 469 static void start_counting_irqs(void) 470 { 471 if (!__this_cpu_read(snapshot_taken)) { 472 kstat_snapshot_irqs(); 473 __this_cpu_write(snapshot_taken, true); 474 } 475 } 476 477 static void stop_counting_irqs(void) 478 { 479 __this_cpu_write(snapshot_taken, false); 480 } 481 482 static void print_irq_counts(void) 483 { 484 unsigned int i, count; 485 struct irq_counts irq_counts_sorted[NUM_HARDIRQ_REPORT] = { 486 {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0} 487 }; 488 489 if (__this_cpu_read(snapshot_taken)) { 490 for_each_active_irq(i) { 491 count = kstat_get_irq_since_snapshot(i); 492 tabulate_irq_count(irq_counts_sorted, i, count, NUM_HARDIRQ_REPORT); 493 } 494 495 /* 496 * Outputting the "watchdog" prefix on every line is redundant and not 497 * concise, and the original alarm information is sufficient for 498 * positioning in logs, hence here printk() is used instead of pr_crit(). 499 */ 500 printk(KERN_CRIT "CPU#%d Detect HardIRQ Time exceeds %d%%. Most frequent HardIRQs:\n", 501 smp_processor_id(), HARDIRQ_PERCENT_THRESH); 502 503 for (i = 0; i < NUM_HARDIRQ_REPORT; i++) { 504 if (irq_counts_sorted[i].irq == -1) 505 break; 506 507 printk(KERN_CRIT "\t#%u: %-10u\tirq#%d\n", 508 i + 1, irq_counts_sorted[i].counts, 509 irq_counts_sorted[i].irq); 510 } 511 512 /* 513 * If the hardirq time is less than HARDIRQ_PERCENT_THRESH% in the last 514 * sample_period, then we suspect the interrupt storm might be subsiding. 515 */ 516 if (!need_counting_irqs()) 517 stop_counting_irqs(); 518 } 519 } 520 521 static void report_cpu_status(void) 522 { 523 print_cpustat(); 524 print_irq_counts(); 525 } 526 #else 527 static inline void update_cpustat(void) { } 528 static inline void report_cpu_status(void) { } 529 static inline bool need_counting_irqs(void) { return false; } 530 static inline void start_counting_irqs(void) { } 531 static inline void stop_counting_irqs(void) { } 532 #endif 533 534 /* 535 * Hard-lockup warnings should be triggered after just a few seconds. Soft- 536 * lockups can have false positives under extreme conditions. So we generally 537 * want a higher threshold for soft lockups than for hard lockups. So we couple 538 * the thresholds with a factor: we make the soft threshold twice the amount of 539 * time the hard threshold is. 540 */ 541 static int get_softlockup_thresh(void) 542 { 543 return watchdog_thresh * 2; 544 } 545 546 /* 547 * Returns seconds, approximately. We don't need nanosecond 548 * resolution, and we don't need to waste time with a big divide when 549 * 2^30ns == 1.074s. 550 */ 551 static unsigned long get_timestamp(void) 552 { 553 return running_clock() >> 30LL; /* 2^30 ~= 10^9 */ 554 } 555 556 static void set_sample_period(void) 557 { 558 /* 559 * convert watchdog_thresh from seconds to ns 560 * the divide by 5 is to give hrtimer several chances (two 561 * or three with the current relation between the soft 562 * and hard thresholds) to increment before the 563 * hardlockup detector generates a warning 564 */ 565 sample_period = get_softlockup_thresh() * ((u64)NSEC_PER_SEC / NUM_SAMPLE_PERIODS); 566 watchdog_update_hrtimer_threshold(sample_period); 567 } 568 569 static void update_report_ts(void) 570 { 571 __this_cpu_write(watchdog_report_ts, get_timestamp()); 572 } 573 574 /* Commands for resetting the watchdog */ 575 static void update_touch_ts(void) 576 { 577 __this_cpu_write(watchdog_touch_ts, get_timestamp()); 578 update_report_ts(); 579 } 580 581 /** 582 * touch_softlockup_watchdog_sched - touch watchdog on scheduler stalls 583 * 584 * Call when the scheduler may have stalled for legitimate reasons 585 * preventing the watchdog task from executing - e.g. the scheduler 586 * entering idle state. This should only be used for scheduler events. 587 * Use touch_softlockup_watchdog() for everything else. 588 */ 589 notrace void touch_softlockup_watchdog_sched(void) 590 { 591 /* 592 * Preemption can be enabled. It doesn't matter which CPU's watchdog 593 * report period gets restarted here, so use the raw_ operation. 594 */ 595 raw_cpu_write(watchdog_report_ts, SOFTLOCKUP_DELAY_REPORT); 596 } 597 598 notrace void touch_softlockup_watchdog(void) 599 { 600 touch_softlockup_watchdog_sched(); 601 wq_watchdog_touch(raw_smp_processor_id()); 602 } 603 EXPORT_SYMBOL(touch_softlockup_watchdog); 604 605 void touch_all_softlockup_watchdogs(void) 606 { 607 int cpu; 608 609 /* 610 * watchdog_mutex cannpt be taken here, as this might be called 611 * from (soft)interrupt context, so the access to 612 * watchdog_allowed_cpumask might race with a concurrent update. 613 * 614 * The watchdog time stamp can race against a concurrent real 615 * update as well, the only side effect might be a cycle delay for 616 * the softlockup check. 617 */ 618 for_each_cpu(cpu, &watchdog_allowed_mask) { 619 per_cpu(watchdog_report_ts, cpu) = SOFTLOCKUP_DELAY_REPORT; 620 wq_watchdog_touch(cpu); 621 } 622 } 623 624 void touch_softlockup_watchdog_sync(void) 625 { 626 __this_cpu_write(softlockup_touch_sync, true); 627 __this_cpu_write(watchdog_report_ts, SOFTLOCKUP_DELAY_REPORT); 628 } 629 630 static int is_softlockup(unsigned long touch_ts, 631 unsigned long period_ts, 632 unsigned long now) 633 { 634 if ((watchdog_enabled & WATCHDOG_SOFTOCKUP_ENABLED) && watchdog_thresh) { 635 /* 636 * If period_ts has not been updated during a sample_period, then 637 * in the subsequent few sample_periods, period_ts might also not 638 * be updated, which could indicate a potential softlockup. In 639 * this case, if we suspect the cause of the potential softlockup 640 * might be interrupt storm, then we need to count the interrupts 641 * to find which interrupt is storming. 642 */ 643 if (time_after_eq(now, period_ts + get_softlockup_thresh() / NUM_SAMPLE_PERIODS) && 644 need_counting_irqs()) 645 start_counting_irqs(); 646 647 /* Warn about unreasonable delays. */ 648 if (time_after(now, period_ts + get_softlockup_thresh())) 649 return now - touch_ts; 650 } 651 return 0; 652 } 653 654 /* watchdog detector functions */ 655 static DEFINE_PER_CPU(struct completion, softlockup_completion); 656 static DEFINE_PER_CPU(struct cpu_stop_work, softlockup_stop_work); 657 658 /* 659 * The watchdog feed function - touches the timestamp. 660 * 661 * It only runs once every sample_period seconds (4 seconds by 662 * default) to reset the softlockup timestamp. If this gets delayed 663 * for more than 2*watchdog_thresh seconds then the debug-printout 664 * triggers in watchdog_timer_fn(). 665 */ 666 static int softlockup_fn(void *data) 667 { 668 update_touch_ts(); 669 stop_counting_irqs(); 670 complete(this_cpu_ptr(&softlockup_completion)); 671 672 return 0; 673 } 674 675 /* watchdog kicker functions */ 676 static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer) 677 { 678 unsigned long touch_ts, period_ts, now; 679 struct pt_regs *regs = get_irq_regs(); 680 int duration; 681 int softlockup_all_cpu_backtrace = sysctl_softlockup_all_cpu_backtrace; 682 unsigned long flags; 683 684 if (!watchdog_enabled) 685 return HRTIMER_NORESTART; 686 687 watchdog_hardlockup_kick(); 688 689 /* kick the softlockup detector */ 690 if (completion_done(this_cpu_ptr(&softlockup_completion))) { 691 reinit_completion(this_cpu_ptr(&softlockup_completion)); 692 stop_one_cpu_nowait(smp_processor_id(), 693 softlockup_fn, NULL, 694 this_cpu_ptr(&softlockup_stop_work)); 695 } 696 697 /* .. and repeat */ 698 hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period)); 699 700 /* 701 * Read the current timestamp first. It might become invalid anytime 702 * when a virtual machine is stopped by the host or when the watchog 703 * is touched from NMI. 704 */ 705 now = get_timestamp(); 706 /* 707 * If a virtual machine is stopped by the host it can look to 708 * the watchdog like a soft lockup. This function touches the watchdog. 709 */ 710 kvm_check_and_clear_guest_paused(); 711 /* 712 * The stored timestamp is comparable with @now only when not touched. 713 * It might get touched anytime from NMI. Make sure that is_softlockup() 714 * uses the same (valid) value. 715 */ 716 period_ts = READ_ONCE(*this_cpu_ptr(&watchdog_report_ts)); 717 718 update_cpustat(); 719 720 /* Reset the interval when touched by known problematic code. */ 721 if (period_ts == SOFTLOCKUP_DELAY_REPORT) { 722 if (unlikely(__this_cpu_read(softlockup_touch_sync))) { 723 /* 724 * If the time stamp was touched atomically 725 * make sure the scheduler tick is up to date. 726 */ 727 __this_cpu_write(softlockup_touch_sync, false); 728 sched_clock_tick(); 729 } 730 731 update_report_ts(); 732 return HRTIMER_RESTART; 733 } 734 735 /* Check for a softlockup. */ 736 touch_ts = __this_cpu_read(watchdog_touch_ts); 737 duration = is_softlockup(touch_ts, period_ts, now); 738 if (unlikely(duration)) { 739 /* 740 * Prevent multiple soft-lockup reports if one cpu is already 741 * engaged in dumping all cpu back traces. 742 */ 743 if (softlockup_all_cpu_backtrace) { 744 if (test_and_set_bit_lock(0, &soft_lockup_nmi_warn)) 745 return HRTIMER_RESTART; 746 } 747 748 /* Start period for the next softlockup warning. */ 749 update_report_ts(); 750 751 printk_cpu_sync_get_irqsave(flags); 752 pr_emerg("BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n", 753 smp_processor_id(), duration, 754 current->comm, task_pid_nr(current)); 755 report_cpu_status(); 756 print_modules(); 757 print_irqtrace_events(current); 758 if (regs) 759 show_regs(regs); 760 else 761 dump_stack(); 762 printk_cpu_sync_put_irqrestore(flags); 763 764 if (softlockup_all_cpu_backtrace) { 765 trigger_allbutcpu_cpu_backtrace(smp_processor_id()); 766 if (!softlockup_panic) 767 clear_bit_unlock(0, &soft_lockup_nmi_warn); 768 } 769 770 add_taint(TAINT_SOFTLOCKUP, LOCKDEP_STILL_OK); 771 if (softlockup_panic) 772 panic("softlockup: hung tasks"); 773 } 774 775 return HRTIMER_RESTART; 776 } 777 778 static void watchdog_enable(unsigned int cpu) 779 { 780 struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer); 781 struct completion *done = this_cpu_ptr(&softlockup_completion); 782 783 WARN_ON_ONCE(cpu != smp_processor_id()); 784 785 init_completion(done); 786 complete(done); 787 788 /* 789 * Start the timer first to prevent the hardlockup watchdog triggering 790 * before the timer has a chance to fire. 791 */ 792 hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_HARD); 793 hrtimer->function = watchdog_timer_fn; 794 hrtimer_start(hrtimer, ns_to_ktime(sample_period), 795 HRTIMER_MODE_REL_PINNED_HARD); 796 797 /* Initialize timestamp */ 798 update_touch_ts(); 799 /* Enable the hardlockup detector */ 800 if (watchdog_enabled & WATCHDOG_HARDLOCKUP_ENABLED) 801 watchdog_hardlockup_enable(cpu); 802 } 803 804 static void watchdog_disable(unsigned int cpu) 805 { 806 struct hrtimer *hrtimer = this_cpu_ptr(&watchdog_hrtimer); 807 808 WARN_ON_ONCE(cpu != smp_processor_id()); 809 810 /* 811 * Disable the hardlockup detector first. That prevents that a large 812 * delay between disabling the timer and disabling the hardlockup 813 * detector causes a false positive. 814 */ 815 watchdog_hardlockup_disable(cpu); 816 hrtimer_cancel(hrtimer); 817 wait_for_completion(this_cpu_ptr(&softlockup_completion)); 818 } 819 820 static int softlockup_stop_fn(void *data) 821 { 822 watchdog_disable(smp_processor_id()); 823 return 0; 824 } 825 826 static void softlockup_stop_all(void) 827 { 828 int cpu; 829 830 if (!softlockup_initialized) 831 return; 832 833 for_each_cpu(cpu, &watchdog_allowed_mask) 834 smp_call_on_cpu(cpu, softlockup_stop_fn, NULL, false); 835 836 cpumask_clear(&watchdog_allowed_mask); 837 } 838 839 static int softlockup_start_fn(void *data) 840 { 841 watchdog_enable(smp_processor_id()); 842 return 0; 843 } 844 845 static void softlockup_start_all(void) 846 { 847 int cpu; 848 849 cpumask_copy(&watchdog_allowed_mask, &watchdog_cpumask); 850 for_each_cpu(cpu, &watchdog_allowed_mask) 851 smp_call_on_cpu(cpu, softlockup_start_fn, NULL, false); 852 } 853 854 int lockup_detector_online_cpu(unsigned int cpu) 855 { 856 if (cpumask_test_cpu(cpu, &watchdog_allowed_mask)) 857 watchdog_enable(cpu); 858 return 0; 859 } 860 861 int lockup_detector_offline_cpu(unsigned int cpu) 862 { 863 if (cpumask_test_cpu(cpu, &watchdog_allowed_mask)) 864 watchdog_disable(cpu); 865 return 0; 866 } 867 868 static void __lockup_detector_reconfigure(void) 869 { 870 cpus_read_lock(); 871 watchdog_hardlockup_stop(); 872 873 softlockup_stop_all(); 874 set_sample_period(); 875 lockup_detector_update_enable(); 876 if (watchdog_enabled && watchdog_thresh) 877 softlockup_start_all(); 878 879 watchdog_hardlockup_start(); 880 cpus_read_unlock(); 881 /* 882 * Must be called outside the cpus locked section to prevent 883 * recursive locking in the perf code. 884 */ 885 __lockup_detector_cleanup(); 886 } 887 888 void lockup_detector_reconfigure(void) 889 { 890 mutex_lock(&watchdog_mutex); 891 __lockup_detector_reconfigure(); 892 mutex_unlock(&watchdog_mutex); 893 } 894 895 /* 896 * Create the watchdog infrastructure and configure the detector(s). 897 */ 898 static __init void lockup_detector_setup(void) 899 { 900 /* 901 * If sysctl is off and watchdog got disabled on the command line, 902 * nothing to do here. 903 */ 904 lockup_detector_update_enable(); 905 906 if (!IS_ENABLED(CONFIG_SYSCTL) && 907 !(watchdog_enabled && watchdog_thresh)) 908 return; 909 910 mutex_lock(&watchdog_mutex); 911 __lockup_detector_reconfigure(); 912 softlockup_initialized = true; 913 mutex_unlock(&watchdog_mutex); 914 } 915 916 #else /* CONFIG_SOFTLOCKUP_DETECTOR */ 917 static void __lockup_detector_reconfigure(void) 918 { 919 cpus_read_lock(); 920 watchdog_hardlockup_stop(); 921 lockup_detector_update_enable(); 922 watchdog_hardlockup_start(); 923 cpus_read_unlock(); 924 } 925 void lockup_detector_reconfigure(void) 926 { 927 __lockup_detector_reconfigure(); 928 } 929 static inline void lockup_detector_setup(void) 930 { 931 __lockup_detector_reconfigure(); 932 } 933 #endif /* !CONFIG_SOFTLOCKUP_DETECTOR */ 934 935 static void __lockup_detector_cleanup(void) 936 { 937 lockdep_assert_held(&watchdog_mutex); 938 hardlockup_detector_perf_cleanup(); 939 } 940 941 /** 942 * lockup_detector_cleanup - Cleanup after cpu hotplug or sysctl changes 943 * 944 * Caller must not hold the cpu hotplug rwsem. 945 */ 946 void lockup_detector_cleanup(void) 947 { 948 mutex_lock(&watchdog_mutex); 949 __lockup_detector_cleanup(); 950 mutex_unlock(&watchdog_mutex); 951 } 952 953 /** 954 * lockup_detector_soft_poweroff - Interface to stop lockup detector(s) 955 * 956 * Special interface for parisc. It prevents lockup detector warnings from 957 * the default pm_poweroff() function which busy loops forever. 958 */ 959 void lockup_detector_soft_poweroff(void) 960 { 961 watchdog_enabled = 0; 962 } 963 964 #ifdef CONFIG_SYSCTL 965 966 /* Propagate any changes to the watchdog infrastructure */ 967 static void proc_watchdog_update(void) 968 { 969 /* Remove impossible cpus to keep sysctl output clean. */ 970 cpumask_and(&watchdog_cpumask, &watchdog_cpumask, cpu_possible_mask); 971 __lockup_detector_reconfigure(); 972 } 973 974 /* 975 * common function for watchdog, nmi_watchdog and soft_watchdog parameter 976 * 977 * caller | table->data points to | 'which' 978 * -------------------|----------------------------------|------------------------------- 979 * proc_watchdog | watchdog_user_enabled | WATCHDOG_HARDLOCKUP_ENABLED | 980 * | | WATCHDOG_SOFTOCKUP_ENABLED 981 * -------------------|----------------------------------|------------------------------- 982 * proc_nmi_watchdog | watchdog_hardlockup_user_enabled | WATCHDOG_HARDLOCKUP_ENABLED 983 * -------------------|----------------------------------|------------------------------- 984 * proc_soft_watchdog | watchdog_softlockup_user_enabled | WATCHDOG_SOFTOCKUP_ENABLED 985 */ 986 static int proc_watchdog_common(int which, struct ctl_table *table, int write, 987 void *buffer, size_t *lenp, loff_t *ppos) 988 { 989 int err, old, *param = table->data; 990 991 mutex_lock(&watchdog_mutex); 992 993 if (!write) { 994 /* 995 * On read synchronize the userspace interface. This is a 996 * racy snapshot. 997 */ 998 *param = (watchdog_enabled & which) != 0; 999 err = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 1000 } else { 1001 old = READ_ONCE(*param); 1002 err = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 1003 if (!err && old != READ_ONCE(*param)) 1004 proc_watchdog_update(); 1005 } 1006 mutex_unlock(&watchdog_mutex); 1007 return err; 1008 } 1009 1010 /* 1011 * /proc/sys/kernel/watchdog 1012 */ 1013 static int proc_watchdog(struct ctl_table *table, int write, 1014 void *buffer, size_t *lenp, loff_t *ppos) 1015 { 1016 return proc_watchdog_common(WATCHDOG_HARDLOCKUP_ENABLED | 1017 WATCHDOG_SOFTOCKUP_ENABLED, 1018 table, write, buffer, lenp, ppos); 1019 } 1020 1021 /* 1022 * /proc/sys/kernel/nmi_watchdog 1023 */ 1024 static int proc_nmi_watchdog(struct ctl_table *table, int write, 1025 void *buffer, size_t *lenp, loff_t *ppos) 1026 { 1027 if (!watchdog_hardlockup_available && write) 1028 return -ENOTSUPP; 1029 return proc_watchdog_common(WATCHDOG_HARDLOCKUP_ENABLED, 1030 table, write, buffer, lenp, ppos); 1031 } 1032 1033 #ifdef CONFIG_SOFTLOCKUP_DETECTOR 1034 /* 1035 * /proc/sys/kernel/soft_watchdog 1036 */ 1037 static int proc_soft_watchdog(struct ctl_table *table, int write, 1038 void *buffer, size_t *lenp, loff_t *ppos) 1039 { 1040 return proc_watchdog_common(WATCHDOG_SOFTOCKUP_ENABLED, 1041 table, write, buffer, lenp, ppos); 1042 } 1043 #endif 1044 1045 /* 1046 * /proc/sys/kernel/watchdog_thresh 1047 */ 1048 static int proc_watchdog_thresh(struct ctl_table *table, int write, 1049 void *buffer, size_t *lenp, loff_t *ppos) 1050 { 1051 int err, old; 1052 1053 mutex_lock(&watchdog_mutex); 1054 1055 old = READ_ONCE(watchdog_thresh); 1056 err = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 1057 1058 if (!err && write && old != READ_ONCE(watchdog_thresh)) 1059 proc_watchdog_update(); 1060 1061 mutex_unlock(&watchdog_mutex); 1062 return err; 1063 } 1064 1065 /* 1066 * The cpumask is the mask of possible cpus that the watchdog can run 1067 * on, not the mask of cpus it is actually running on. This allows the 1068 * user to specify a mask that will include cpus that have not yet 1069 * been brought online, if desired. 1070 */ 1071 static int proc_watchdog_cpumask(struct ctl_table *table, int write, 1072 void *buffer, size_t *lenp, loff_t *ppos) 1073 { 1074 int err; 1075 1076 mutex_lock(&watchdog_mutex); 1077 1078 err = proc_do_large_bitmap(table, write, buffer, lenp, ppos); 1079 if (!err && write) 1080 proc_watchdog_update(); 1081 1082 mutex_unlock(&watchdog_mutex); 1083 return err; 1084 } 1085 1086 static const int sixty = 60; 1087 1088 static struct ctl_table watchdog_sysctls[] = { 1089 { 1090 .procname = "watchdog", 1091 .data = &watchdog_user_enabled, 1092 .maxlen = sizeof(int), 1093 .mode = 0644, 1094 .proc_handler = proc_watchdog, 1095 .extra1 = SYSCTL_ZERO, 1096 .extra2 = SYSCTL_ONE, 1097 }, 1098 { 1099 .procname = "watchdog_thresh", 1100 .data = &watchdog_thresh, 1101 .maxlen = sizeof(int), 1102 .mode = 0644, 1103 .proc_handler = proc_watchdog_thresh, 1104 .extra1 = SYSCTL_ZERO, 1105 .extra2 = (void *)&sixty, 1106 }, 1107 { 1108 .procname = "watchdog_cpumask", 1109 .data = &watchdog_cpumask_bits, 1110 .maxlen = NR_CPUS, 1111 .mode = 0644, 1112 .proc_handler = proc_watchdog_cpumask, 1113 }, 1114 #ifdef CONFIG_SOFTLOCKUP_DETECTOR 1115 { 1116 .procname = "soft_watchdog", 1117 .data = &watchdog_softlockup_user_enabled, 1118 .maxlen = sizeof(int), 1119 .mode = 0644, 1120 .proc_handler = proc_soft_watchdog, 1121 .extra1 = SYSCTL_ZERO, 1122 .extra2 = SYSCTL_ONE, 1123 }, 1124 { 1125 .procname = "softlockup_panic", 1126 .data = &softlockup_panic, 1127 .maxlen = sizeof(int), 1128 .mode = 0644, 1129 .proc_handler = proc_dointvec_minmax, 1130 .extra1 = SYSCTL_ZERO, 1131 .extra2 = SYSCTL_ONE, 1132 }, 1133 #ifdef CONFIG_SMP 1134 { 1135 .procname = "softlockup_all_cpu_backtrace", 1136 .data = &sysctl_softlockup_all_cpu_backtrace, 1137 .maxlen = sizeof(int), 1138 .mode = 0644, 1139 .proc_handler = proc_dointvec_minmax, 1140 .extra1 = SYSCTL_ZERO, 1141 .extra2 = SYSCTL_ONE, 1142 }, 1143 #endif /* CONFIG_SMP */ 1144 #endif 1145 #ifdef CONFIG_HARDLOCKUP_DETECTOR 1146 { 1147 .procname = "hardlockup_panic", 1148 .data = &hardlockup_panic, 1149 .maxlen = sizeof(int), 1150 .mode = 0644, 1151 .proc_handler = proc_dointvec_minmax, 1152 .extra1 = SYSCTL_ZERO, 1153 .extra2 = SYSCTL_ONE, 1154 }, 1155 #ifdef CONFIG_SMP 1156 { 1157 .procname = "hardlockup_all_cpu_backtrace", 1158 .data = &sysctl_hardlockup_all_cpu_backtrace, 1159 .maxlen = sizeof(int), 1160 .mode = 0644, 1161 .proc_handler = proc_dointvec_minmax, 1162 .extra1 = SYSCTL_ZERO, 1163 .extra2 = SYSCTL_ONE, 1164 }, 1165 #endif /* CONFIG_SMP */ 1166 #endif 1167 }; 1168 1169 static struct ctl_table watchdog_hardlockup_sysctl[] = { 1170 { 1171 .procname = "nmi_watchdog", 1172 .data = &watchdog_hardlockup_user_enabled, 1173 .maxlen = sizeof(int), 1174 .mode = 0444, 1175 .proc_handler = proc_nmi_watchdog, 1176 .extra1 = SYSCTL_ZERO, 1177 .extra2 = SYSCTL_ONE, 1178 }, 1179 }; 1180 1181 static void __init watchdog_sysctl_init(void) 1182 { 1183 register_sysctl_init("kernel", watchdog_sysctls); 1184 1185 if (watchdog_hardlockup_available) 1186 watchdog_hardlockup_sysctl[0].mode = 0644; 1187 register_sysctl_init("kernel", watchdog_hardlockup_sysctl); 1188 } 1189 1190 #else 1191 #define watchdog_sysctl_init() do { } while (0) 1192 #endif /* CONFIG_SYSCTL */ 1193 1194 static void __init lockup_detector_delay_init(struct work_struct *work); 1195 static bool allow_lockup_detector_init_retry __initdata; 1196 1197 static struct work_struct detector_work __initdata = 1198 __WORK_INITIALIZER(detector_work, lockup_detector_delay_init); 1199 1200 static void __init lockup_detector_delay_init(struct work_struct *work) 1201 { 1202 int ret; 1203 1204 ret = watchdog_hardlockup_probe(); 1205 if (ret) { 1206 pr_info("Delayed init of the lockup detector failed: %d\n", ret); 1207 pr_info("Hard watchdog permanently disabled\n"); 1208 return; 1209 } 1210 1211 allow_lockup_detector_init_retry = false; 1212 1213 watchdog_hardlockup_available = true; 1214 lockup_detector_setup(); 1215 } 1216 1217 /* 1218 * lockup_detector_retry_init - retry init lockup detector if possible. 1219 * 1220 * Retry hardlockup detector init. It is useful when it requires some 1221 * functionality that has to be initialized later on a particular 1222 * platform. 1223 */ 1224 void __init lockup_detector_retry_init(void) 1225 { 1226 /* Must be called before late init calls */ 1227 if (!allow_lockup_detector_init_retry) 1228 return; 1229 1230 schedule_work(&detector_work); 1231 } 1232 1233 /* 1234 * Ensure that optional delayed hardlockup init is proceed before 1235 * the init code and memory is freed. 1236 */ 1237 static int __init lockup_detector_check(void) 1238 { 1239 /* Prevent any later retry. */ 1240 allow_lockup_detector_init_retry = false; 1241 1242 /* Make sure no work is pending. */ 1243 flush_work(&detector_work); 1244 1245 watchdog_sysctl_init(); 1246 1247 return 0; 1248 1249 } 1250 late_initcall_sync(lockup_detector_check); 1251 1252 void __init lockup_detector_init(void) 1253 { 1254 if (tick_nohz_full_enabled()) 1255 pr_info("Disabling watchdog on nohz_full cores by default\n"); 1256 1257 cpumask_copy(&watchdog_cpumask, 1258 housekeeping_cpumask(HK_TYPE_TIMER)); 1259 1260 if (!watchdog_hardlockup_probe()) 1261 watchdog_hardlockup_available = true; 1262 else 1263 allow_lockup_detector_init_retry = true; 1264 1265 lockup_detector_setup(); 1266 } 1267