kernel/hung_task.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Detect Hung Task
   4  *
   5  * kernel/hung_task.c - kernel thread for detecting tasks stuck in D state
   6  *
   7  */
   8
   9 #include <linux/mm.h>
  10 #include <linux/cpu.h>
  11 #include <linux/nmi.h>
  12 #include <linux/init.h>
  13 #include <linux/delay.h>
  14 #include <linux/freezer.h>
  15 #include <linux/kthread.h>
  16 #include <linux/lockdep.h>
  17 #include <linux/export.h>
  18 #include <linux/panic_notifier.h>
  19 #include <linux/sysctl.h>
  20 #include <linux/suspend.h>
  21 #include <linux/utsname.h>
  22 #include <linux/sched/signal.h>
  23 #include <linux/sched/debug.h>
  24 #include <linux/sched/sysctl.h>
  25
  26 #include <trace/events/sched.h>
  27
  28 /*
  29  * The number of tasks checked:
  30  */
  31 static int __read_mostly sysctl_hung_task_check_count = PID_MAX_LIMIT;
  32
  33 /*
  34  * Total number of tasks detected as hung since boot:
  35  */
  36 static unsigned long __read_mostly sysctl_hung_task_detect_count;
  37
  38 /*
  39  * Limit number of tasks checked in a batch.
  40  *
  41  * This value controls the preemptibility of khungtaskd since preemption
  42  * is disabled during the critical section. It also controls the size of
  43  * the RCU grace period. So it needs to be upper-bound.
  44  */
  45 #define HUNG_TASK_LOCK_BREAK (HZ / 10)
  46
  47 /*
  48  * Zero means infinite timeout - no checking done:
  49  */
  50 unsigned long __read_mostly sysctl_hung_task_timeout_secs = CONFIG_DEFAULT_HUNG_TASK_TIMEOUT;
  51 EXPORT_SYMBOL_GPL(sysctl_hung_task_timeout_secs);
  52
  53 /*
  54  * Zero (default value) means use sysctl_hung_task_timeout_secs:
  55  */
  56 static unsigned long __read_mostly sysctl_hung_task_check_interval_secs;
  57
  58 static int __read_mostly sysctl_hung_task_warnings = 10;
  59
  60 static int __read_mostly did_panic;
  61 static bool hung_task_show_lock;
  62 static bool hung_task_call_panic;
  63 static bool hung_task_show_all_bt;
  64
  65 static struct task_struct *watchdog_task;
  66
  67 #ifdef CONFIG_SMP
  68 /*
  69  * Should we dump all CPUs backtraces in a hung task event?
  70  * Defaults to 0, can be changed via sysctl.
  71  */
  72 static unsigned int __read_mostly sysctl_hung_task_all_cpu_backtrace;
  73 #else
  74 #define sysctl_hung_task_all_cpu_backtrace 0
  75 #endif /* CONFIG_SMP */
  76
  77 /*
  78  * Should we panic (and reboot, if panic_timeout= is set) when a
  79  * hung task is detected:
  80  */
  81 static unsigned int __read_mostly sysctl_hung_task_panic =
  82         IS_ENABLED(CONFIG_BOOTPARAM_HUNG_TASK_PANIC);
  83
  84 static int
  85 hung_task_panic(struct notifier_block *this, unsigned long event, void *ptr)
  86 {
  87         did_panic = 1;
  88
  89         return NOTIFY_DONE;
  90 }
  91
  92 static struct notifier_block panic_block = {
  93         .notifier_call = hung_task_panic,
  94 };
  95
  96 static void check_hung_task(struct task_struct *t, unsigned long timeout)
  97 {
  98         unsigned long switch_count = t->nvcsw + t->nivcsw;
  99
 100         /*
 101          * Ensure the task is not frozen.
 102          * Also, skip vfork and any other user process that freezer should skip.
 103          */
 104         if (unlikely(READ_ONCE(t->__state) & TASK_FROZEN))
 105                 return;
 106
 107         /*
 108          * When a freshly created task is scheduled once, changes its state to
 109          * TASK_UNINTERRUPTIBLE without having ever been switched out once, it
 110          * musn't be checked.
 111          */
 112         if (unlikely(!switch_count))
 113                 return;
 114
 115         if (switch_count != t->last_switch_count) {
 116                 t->last_switch_count = switch_count;
 117                 t->last_switch_time = jiffies;
 118                 return;
 119         }
 120         if (time_is_after_jiffies(t->last_switch_time + timeout * HZ))
 121                 return;
 122
 123         /*
 124          * This counter tracks the total number of tasks detected as hung
 125          * since boot.
 126          */
 127         sysctl_hung_task_detect_count++;
 128
 129         trace_sched_process_hang(t);
 130
 131         if (sysctl_hung_task_panic) {
 132                 console_verbose();
 133                 hung_task_show_lock = true;
 134                 hung_task_call_panic = true;
 135         }
 136
 137         /*
 138          * Ok, the task did not get scheduled for more than 2 minutes,
 139          * complain:
 140          */
 141         if (sysctl_hung_task_warnings || hung_task_call_panic) {
 142                 if (sysctl_hung_task_warnings > 0)
 143                         sysctl_hung_task_warnings--;
 144                 pr_err("INFO: task %s:%d blocked for more than %ld seconds.\n",
 145                        t->comm, t->pid, (jiffies - t->last_switch_time) / HZ);
 146                 pr_err("      %s %s %.*s\n",
 147                         print_tainted(), init_utsname()->release,
 148                         (int)strcspn(init_utsname()->version, " "),
 149                         init_utsname()->version);
 150                 pr_err("\"echo 0 > /proc/sys/kernel/hung_task_timeout_secs\""
 151                         " disables this message.\n");
 152                 sched_show_task(t);
 153                 hung_task_show_lock = true;
 154
 155                 if (sysctl_hung_task_all_cpu_backtrace)
 156                         hung_task_show_all_bt = true;
 157                 if (!sysctl_hung_task_warnings)
 158                         pr_info("Future hung task reports are suppressed, see sysctl kernel.hung_task_warnings\n");
 159         }
 160
 161         touch_nmi_watchdog();
 162 }
 163
 164 /*
 165  * To avoid extending the RCU grace period for an unbounded amount of time,
 166  * periodically exit the critical section and enter a new one.
 167  *
 168  * For preemptible RCU it is sufficient to call rcu_read_unlock in order
 169  * to exit the grace period. For classic RCU, a reschedule is required.
 170  */
 171 static bool rcu_lock_break(struct task_struct *g, struct task_struct *t)
 172 {
 173         bool can_cont;
 174
 175         get_task_struct(g);
 176         get_task_struct(t);
 177         rcu_read_unlock();
 178         cond_resched();
 179         rcu_read_lock();
 180         can_cont = pid_alive(g) && pid_alive(t);
 181         put_task_struct(t);
 182         put_task_struct(g);
 183
 184         return can_cont;
 185 }
 186
 187 /*
 188  * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for
 189  * a really long time (120 seconds). If that happens, print out
 190  * a warning.
 191  */
 192 static void check_hung_uninterruptible_tasks(unsigned long timeout)
 193 {
 194         int max_count = sysctl_hung_task_check_count;
 195         unsigned long last_break = jiffies;
 196         struct task_struct *g, *t;
 197
 198         /*
 199          * If the system crashed already then all bets are off,
 200          * do not report extra hung tasks:
 201          */
 202         if (test_taint(TAINT_DIE) || did_panic)
 203                 return;
 204
 205         hung_task_show_lock = false;
 206         rcu_read_lock();
 207         for_each_process_thread(g, t) {
 208                 unsigned int state;
 209
 210                 if (!max_count--)
 211                         goto unlock;
 212                 if (time_after(jiffies, last_break + HUNG_TASK_LOCK_BREAK)) {
 213                         if (!rcu_lock_break(g, t))
 214                                 goto unlock;
 215                         last_break = jiffies;
 216                 }
 217                 /*
 218                  * skip the TASK_KILLABLE tasks -- these can be killed
 219                  * skip the TASK_IDLE tasks -- those are genuinely idle
 220                  */
 221                 state = READ_ONCE(t->__state);
 222                 if ((state & TASK_UNINTERRUPTIBLE) &&
 223                     !(state & TASK_WAKEKILL) &&
 224                     !(state & TASK_NOLOAD))
 225                         check_hung_task(t, timeout);
 226         }
 227  unlock:
 228         rcu_read_unlock();
 229         if (hung_task_show_lock)
 230                 debug_show_all_locks();
 231
 232         if (hung_task_show_all_bt) {
 233                 hung_task_show_all_bt = false;
 234                 trigger_all_cpu_backtrace();
 235         }
 236
 237         if (hung_task_call_panic)
 238                 panic("hung_task: blocked tasks");
 239 }
 240
 241 static long hung_timeout_jiffies(unsigned long last_checked,
 242                                  unsigned long timeout)
 243 {
 244         /* timeout of 0 will disable the watchdog */
 245         return timeout ? last_checked - jiffies + timeout * HZ :
 246                 MAX_SCHEDULE_TIMEOUT;
 247 }
 248
 249 #ifdef CONFIG_SYSCTL
 250 /*
 251  * Process updating of timeout sysctl
 252  */
 253 static int proc_dohung_task_timeout_secs(const struct ctl_table *table, int write,
 254                                   void *buffer,
 255                                   size_t *lenp, loff_t *ppos)
 256 {
 257         int ret;
 258
 259         ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
 260
 261         if (ret || !write)
 262                 goto out;
 263
 264         wake_up_process(watchdog_task);
 265
 266  out:
 267         return ret;
 268 }
 269
 270 /*
 271  * This is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs
 272  * and hung_task_check_interval_secs
 273  */
 274 static const unsigned long hung_task_timeout_max = (LONG_MAX / HZ);
 275 static struct ctl_table hung_task_sysctls[] = {
 276 #ifdef CONFIG_SMP
 277         {
 278                 .procname       = "hung_task_all_cpu_backtrace",
 279                 .data           = &sysctl_hung_task_all_cpu_backtrace,
 280                 .maxlen         = sizeof(int),
 281                 .mode           = 0644,
 282                 .proc_handler   = proc_dointvec_minmax,
 283                 .extra1         = SYSCTL_ZERO,
 284                 .extra2         = SYSCTL_ONE,
 285         },
 286 #endif /* CONFIG_SMP */
 287         {
 288                 .procname       = "hung_task_panic",
 289                 .data           = &sysctl_hung_task_panic,
 290                 .maxlen         = sizeof(int),
 291                 .mode           = 0644,
 292                 .proc_handler   = proc_dointvec_minmax,
 293                 .extra1         = SYSCTL_ZERO,
 294                 .extra2         = SYSCTL_ONE,
 295         },
 296         {
 297                 .procname       = "hung_task_check_count",
 298                 .data           = &sysctl_hung_task_check_count,
 299                 .maxlen         = sizeof(int),
 300                 .mode           = 0644,
 301                 .proc_handler   = proc_dointvec_minmax,
 302                 .extra1         = SYSCTL_ZERO,
 303         },
 304         {
 305                 .procname       = "hung_task_timeout_secs",
 306                 .data           = &sysctl_hung_task_timeout_secs,
 307                 .maxlen         = sizeof(unsigned long),
 308                 .mode           = 0644,
 309                 .proc_handler   = proc_dohung_task_timeout_secs,
 310                 .extra2         = (void *)&hung_task_timeout_max,
 311         },
 312         {
 313                 .procname       = "hung_task_check_interval_secs",
 314                 .data           = &sysctl_hung_task_check_interval_secs,
 315                 .maxlen         = sizeof(unsigned long),
 316                 .mode           = 0644,
 317                 .proc_handler   = proc_dohung_task_timeout_secs,
 318                 .extra2         = (void *)&hung_task_timeout_max,
 319         },
 320         {
 321                 .procname       = "hung_task_warnings",
 322                 .data           = &sysctl_hung_task_warnings,
 323                 .maxlen         = sizeof(int),
 324                 .mode           = 0644,
 325                 .proc_handler   = proc_dointvec_minmax,
 326                 .extra1         = SYSCTL_NEG_ONE,
 327         },
 328         {
 329                 .procname       = "hung_task_detect_count",
 330                 .data           = &sysctl_hung_task_detect_count,
 331                 .maxlen         = sizeof(unsigned long),
 332                 .mode           = 0444,
 333                 .proc_handler   = proc_doulongvec_minmax,
 334         },
 335 };
 336
 337 static void __init hung_task_sysctl_init(void)
 338 {
 339         register_sysctl_init("kernel", hung_task_sysctls);
 340 }
 341 #else
 342 #define hung_task_sysctl_init() do { } while (0)
 343 #endif /* CONFIG_SYSCTL */
 344
 345
 346 static atomic_t reset_hung_task = ATOMIC_INIT(0);
 347
 348 void reset_hung_task_detector(void)
 349 {
 350         atomic_set(&reset_hung_task, 1);
 351 }
 352 EXPORT_SYMBOL_GPL(reset_hung_task_detector);
 353
 354 static bool hung_detector_suspended;
 355
 356 static int hungtask_pm_notify(struct notifier_block *self,
 357                               unsigned long action, void *hcpu)
 358 {
 359         switch (action) {
 360         case PM_SUSPEND_PREPARE:
 361         case PM_HIBERNATION_PREPARE:
 362         case PM_RESTORE_PREPARE:
 363                 hung_detector_suspended = true;
 364                 break;
 365         case PM_POST_SUSPEND:
 366         case PM_POST_HIBERNATION:
 367         case PM_POST_RESTORE:
 368                 hung_detector_suspended = false;
 369                 break;
 370         default:
 371                 break;
 372         }
 373         return NOTIFY_OK;
 374 }
 375
 376 /*
 377  * kthread which checks for tasks stuck in D state
 378  */
 379 static int watchdog(void *dummy)
 380 {
 381         unsigned long hung_last_checked = jiffies;
 382
 383         set_user_nice(current, 0);
 384
 385         for ( ; ; ) {
 386                 unsigned long timeout = sysctl_hung_task_timeout_secs;
 387                 unsigned long interval = sysctl_hung_task_check_interval_secs;
 388                 long t;
 389
 390                 if (interval == 0)
 391                         interval = timeout;
 392                 interval = min_t(unsigned long, interval, timeout);
 393                 t = hung_timeout_jiffies(hung_last_checked, interval);
 394                 if (t <= 0) {
 395                         if (!atomic_xchg(&reset_hung_task, 0) &&
 396                             !hung_detector_suspended)
 397                                 check_hung_uninterruptible_tasks(timeout);
 398                         hung_last_checked = jiffies;
 399                         continue;
 400                 }
 401                 schedule_timeout_interruptible(t);
 402         }
 403
 404         return 0;
 405 }
 406
 407 static int __init hung_task_init(void)
 408 {
 409         atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 410
 411         /* Disable hung task detector on suspend */
 412         pm_notifier(hungtask_pm_notify, 0);
 413
 414         watchdog_task = kthread_run(watchdog, NULL, "khungtaskd");
 415         hung_task_sysctl_init();
 416
 417         return 0;
 418 }
 419 subsys_initcall(hung_task_init);