~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/hung_task.c

Version: ~ [ linux-6.11.5 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.58 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.114 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.169 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.228 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.284 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.322 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /kernel/hung_task.c (Version linux-6.11.5) and /kernel/hung_task.c (Version linux-5.16.20)


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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

sflogo.php