Branch data     Line data    Source code

       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/sysctl.h>
      19                 :            : #include <linux/suspend.h>
      20                 :            : #include <linux/utsname.h>
      21                 :            : #include <linux/sched/signal.h>
      22                 :            : #include <linux/sched/debug.h>
      23                 :            : #include <linux/sched/sysctl.h>
      24                 :            : 
      25                 :            : #include <trace/events/sched.h>
      26                 :            : 
      27                 :            : /*
      28                 :            :  * The number of tasks checked:
      29                 :            :  */
      30                 :            : int __read_mostly sysctl_hung_task_check_count = PID_MAX_LIMIT;
      31                 :            : 
      32                 :            : /*
      33                 :            :  * Limit number of tasks checked in a batch.
      34                 :            :  *
      35                 :            :  * This value controls the preemptibility of khungtaskd since preemption
      36                 :            :  * is disabled during the critical section. It also controls the size of
      37                 :            :  * the RCU grace period. So it needs to be upper-bound.
      38                 :            :  */
      39                 :            : #define HUNG_TASK_LOCK_BREAK (HZ / 10)
      40                 :            : 
      41                 :            : /*
      42                 :            :  * Zero means infinite timeout - no checking done:
      43                 :            :  */
      44                 :            : unsigned long __read_mostly sysctl_hung_task_timeout_secs = CONFIG_DEFAULT_HUNG_TASK_TIMEOUT;
      45                 :            : 
      46                 :            : /*
      47                 :            :  * Zero (default value) means use sysctl_hung_task_timeout_secs:
      48                 :            :  */
      49                 :            : unsigned long __read_mostly sysctl_hung_task_check_interval_secs;
      50                 :            : 
      51                 :            : int __read_mostly sysctl_hung_task_warnings = 10;
      52                 :            : 
      53                 :            : static int __read_mostly did_panic;
      54                 :            : static bool hung_task_show_lock;
      55                 :            : static bool hung_task_call_panic;
      56                 :            : 
      57                 :            : static struct task_struct *watchdog_task;
      58                 :            : 
      59                 :            : /*
      60                 :            :  * Should we panic (and reboot, if panic_timeout= is set) when a
      61                 :            :  * hung task is detected:
      62                 :            :  */
      63                 :            : unsigned int __read_mostly sysctl_hung_task_panic =
      64                 :            :                                 CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE;
      65                 :            : 
      66                 :          0 : static int __init hung_task_panic_setup(char *str)
      67                 :            : {
      68                 :          0 :         int rc = kstrtouint(str, 0, &sysctl_hung_task_panic);
      69                 :            : 
      70                 :          0 :         if (rc)
      71                 :          0 :                 return rc;
      72                 :            :         return 1;
      73                 :            : }
      74                 :            : __setup("hung_task_panic=", hung_task_panic_setup);
      75                 :            : 
      76                 :            : static int
      77                 :          0 : hung_task_panic(struct notifier_block *this, unsigned long event, void *ptr)
      78                 :            : {
      79                 :          0 :         did_panic = 1;
      80                 :            : 
      81                 :          0 :         return NOTIFY_DONE;
      82                 :            : }
      83                 :            : 
      84                 :            : static struct notifier_block panic_block = {
      85                 :            :         .notifier_call = hung_task_panic,
      86                 :            : };
      87                 :            : 
      88                 :          1 : static void check_hung_task(struct task_struct *t, unsigned long timeout)
      89                 :            : {
      90                 :          1 :         unsigned long switch_count = t->nvcsw + t->nivcsw;
      91                 :            : 
      92                 :            :         /*
      93                 :            :          * Ensure the task is not frozen.
      94                 :            :          * Also, skip vfork and any other user process that freezer should skip.
      95                 :            :          */
      96                 :          1 :         if (unlikely(t->flags & (PF_FROZEN | PF_FREEZER_SKIP)))
      97                 :            :             return;
      98                 :            : 
      99                 :            :         /*
     100                 :            :          * When a freshly created task is scheduled once, changes its state to
     101                 :            :          * TASK_UNINTERRUPTIBLE without having ever been switched out once, it
     102                 :            :          * musn't be checked.
     103                 :            :          */
     104                 :          1 :         if (unlikely(!switch_count))
     105                 :            :                 return;
     106                 :            : 
     107                 :          1 :         if (switch_count != t->last_switch_count) {
     108                 :          1 :                 t->last_switch_count = switch_count;
     109                 :          1 :                 t->last_switch_time = jiffies;
     110                 :          1 :                 return;
     111                 :            :         }
     112                 :          0 :         if (time_is_after_jiffies(t->last_switch_time + timeout * HZ))
     113                 :            :                 return;
     114                 :            : 
     115                 :          0 :         trace_sched_process_hang(t);
     116                 :            : 
     117                 :          0 :         if (sysctl_hung_task_panic) {
     118                 :            :                 console_verbose();
     119                 :          0 :                 hung_task_show_lock = true;
     120                 :          0 :                 hung_task_call_panic = true;
     121                 :            :         }
     122                 :            : 
     123                 :            :         /*
     124                 :            :          * Ok, the task did not get scheduled for more than 2 minutes,
     125                 :            :          * complain:
     126                 :            :          */
     127                 :          0 :         if (sysctl_hung_task_warnings) {
     128                 :          0 :                 if (sysctl_hung_task_warnings > 0)
     129                 :          0 :                         sysctl_hung_task_warnings--;
     130                 :          0 :                 pr_err("INFO: task %s:%d blocked for more than %ld seconds.\n",
     131                 :            :                        t->comm, t->pid, (jiffies - t->last_switch_time) / HZ);
     132                 :          0 :                 pr_err("      %s %s %.*s\n",
     133                 :            :                         print_tainted(), init_utsname()->release,
     134                 :            :                         (int)strcspn(init_utsname()->version, " "),
     135                 :            :                         init_utsname()->version);
     136                 :          0 :                 pr_err("\"echo 0 > /proc/sys/kernel/hung_task_timeout_secs\""
     137                 :            :                         " disables this message.\n");
     138                 :          0 :                 sched_show_task(t);
     139                 :          0 :                 hung_task_show_lock = true;
     140                 :            :         }
     141                 :            : 
     142                 :            :         touch_nmi_watchdog();
     143                 :            : }
     144                 :            : 
     145                 :            : /*
     146                 :            :  * To avoid extending the RCU grace period for an unbounded amount of time,
     147                 :            :  * periodically exit the critical section and enter a new one.
     148                 :            :  *
     149                 :            :  * For preemptible RCU it is sufficient to call rcu_read_unlock in order
     150                 :            :  * to exit the grace period. For classic RCU, a reschedule is required.
     151                 :            :  */
     152                 :          0 : static bool rcu_lock_break(struct task_struct *g, struct task_struct *t)
     153                 :            : {
     154                 :            :         bool can_cont;
     155                 :            : 
     156                 :            :         get_task_struct(g);
     157                 :            :         get_task_struct(t);
     158                 :            :         rcu_read_unlock();
     159                 :          0 :         cond_resched();
     160                 :            :         rcu_read_lock();
     161                 :          0 :         can_cont = pid_alive(g) && pid_alive(t);
     162                 :          0 :         put_task_struct(t);
     163                 :          0 :         put_task_struct(g);
     164                 :            : 
     165                 :          0 :         return can_cont;
     166                 :            : }
     167                 :            : 
     168                 :            : /*
     169                 :            :  * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for
     170                 :            :  * a really long time (120 seconds). If that happens, print out
     171                 :            :  * a warning.
     172                 :            :  */
     173                 :          1 : static void check_hung_uninterruptible_tasks(unsigned long timeout)
     174                 :            : {
     175                 :          1 :         int max_count = sysctl_hung_task_check_count;
     176                 :          1 :         unsigned long last_break = jiffies;
     177                 :            :         struct task_struct *g, *t;
     178                 :            : 
     179                 :            :         /*
     180                 :            :          * If the system crashed already then all bets are off,
     181                 :            :          * do not report extra hung tasks:
     182                 :            :          */
     183                 :          1 :         if (test_taint(TAINT_DIE) || did_panic)
     184                 :          1 :                 return;
     185                 :            : 
     186                 :          1 :         hung_task_show_lock = false;
     187                 :            :         rcu_read_lock();
     188                 :          1 :         for_each_process_thread(g, t) {
     189                 :          1 :                 if (!max_count--)
     190                 :            :                         goto unlock;
     191                 :          1 :                 if (time_after(jiffies, last_break + HUNG_TASK_LOCK_BREAK)) {
     192                 :          0 :                         if (!rcu_lock_break(g, t))
     193                 :            :                                 goto unlock;
     194                 :          0 :                         last_break = jiffies;
     195                 :            :                 }
     196                 :            :                 /* use "==" to skip the TASK_KILLABLE tasks waiting on NFS */
     197                 :          1 :                 if (t->state == TASK_UNINTERRUPTIBLE)
     198                 :          1 :                         check_hung_task(t, timeout);
     199                 :            :         }
     200                 :            :  unlock:
     201                 :            :         rcu_read_unlock();
     202                 :            :         if (hung_task_show_lock)
     203                 :            :                 debug_show_all_locks();
     204                 :          1 :         if (hung_task_call_panic) {
     205                 :            :                 trigger_all_cpu_backtrace();
     206                 :          0 :                 panic("hung_task: blocked tasks");
     207                 :            :         }
     208                 :            : }
     209                 :            : 
     210                 :            : static long hung_timeout_jiffies(unsigned long last_checked,
     211                 :            :                                  unsigned long timeout)
     212                 :            : {
     213                 :            :         /* timeout of 0 will disable the watchdog */
     214                 :          3 :         return timeout ? last_checked - jiffies + timeout * HZ :
     215                 :            :                 MAX_SCHEDULE_TIMEOUT;
     216                 :            : }
     217                 :            : 
     218                 :            : /*
     219                 :            :  * Process updating of timeout sysctl
     220                 :            :  */
     221                 :          0 : int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
     222                 :            :                                   void __user *buffer,
     223                 :            :                                   size_t *lenp, loff_t *ppos)
     224                 :            : {
     225                 :            :         int ret;
     226                 :            : 
     227                 :          0 :         ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
     228                 :            : 
     229                 :          0 :         if (ret || !write)
     230                 :            :                 goto out;
     231                 :            : 
     232                 :          0 :         wake_up_process(watchdog_task);
     233                 :            : 
     234                 :            :  out:
     235                 :          0 :         return ret;
     236                 :            : }
     237                 :            : 
     238                 :            : static atomic_t reset_hung_task = ATOMIC_INIT(0);
     239                 :            : 
     240                 :          0 : void reset_hung_task_detector(void)
     241                 :            : {
     242                 :            :         atomic_set(&reset_hung_task, 1);
     243                 :          0 : }
     244                 :            : EXPORT_SYMBOL_GPL(reset_hung_task_detector);
     245                 :            : 
     246                 :            : static bool hung_detector_suspended;
     247                 :            : 
     248                 :            : static int hungtask_pm_notify(struct notifier_block *self,
     249                 :            :                               unsigned long action, void *hcpu)
     250                 :            : {
     251                 :            :         switch (action) {
     252                 :            :         case PM_SUSPEND_PREPARE:
     253                 :            :         case PM_HIBERNATION_PREPARE:
     254                 :            :         case PM_RESTORE_PREPARE:
     255                 :            :                 hung_detector_suspended = true;
     256                 :            :                 break;
     257                 :            :         case PM_POST_SUSPEND:
     258                 :            :         case PM_POST_HIBERNATION:
     259                 :            :         case PM_POST_RESTORE:
     260                 :            :                 hung_detector_suspended = false;
     261                 :            :                 break;
     262                 :            :         default:
     263                 :            :                 break;
     264                 :            :         }
     265                 :            :         return NOTIFY_OK;
     266                 :            : }
     267                 :            : 
     268                 :            : /*
     269                 :            :  * kthread which checks for tasks stuck in D state
     270                 :            :  */
     271                 :          3 : static int watchdog(void *dummy)
     272                 :            : {
     273                 :          3 :         unsigned long hung_last_checked = jiffies;
     274                 :            : 
     275                 :          3 :         set_user_nice(current, 0);
     276                 :            : 
     277                 :            :         for ( ; ; ) {
     278                 :          3 :                 unsigned long timeout = sysctl_hung_task_timeout_secs;
     279                 :          3 :                 unsigned long interval = sysctl_hung_task_check_interval_secs;
     280                 :            :                 long t;
     281                 :            : 
     282                 :          3 :                 if (interval == 0)
     283                 :            :                         interval = timeout;
     284                 :          3 :                 interval = min_t(unsigned long, interval, timeout);
     285                 :            :                 t = hung_timeout_jiffies(hung_last_checked, interval);
     286                 :          3 :                 if (t <= 0) {
     287                 :          1 :                         if (!atomic_xchg(&reset_hung_task, 0) &&
     288                 :          1 :                             !hung_detector_suspended)
     289                 :          1 :                                 check_hung_uninterruptible_tasks(timeout);
     290                 :          1 :                         hung_last_checked = jiffies;
     291                 :          1 :                         continue;
     292                 :            :                 }
     293                 :          3 :                 schedule_timeout_interruptible(t);
     294                 :            :         }
     295                 :            : 
     296                 :            :         return 0;
     297                 :            : }
     298                 :            : 
     299                 :          3 : static int __init hung_task_init(void)
     300                 :            : {
     301                 :          3 :         atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
     302                 :            : 
     303                 :            :         /* Disable hung task detector on suspend */
     304                 :            :         pm_notifier(hungtask_pm_notify, 0);
     305                 :            : 
     306                 :          3 :         watchdog_task = kthread_run(watchdog, NULL, "khungtaskd");
     307                 :            : 
     308                 :          3 :         return 0;
     309                 :            : }
     310                 :            : subsys_initcall(hung_task_init);