X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=libcfs%2Flibcfs%2Fwatchdog.c;h=4c437ab1fd027daecfc7d357a5cbb696b4a64493;hp=04e4da7cd2ad3d845e9ac039436f28145846e797;hb=782ff36d50c77652d0358dc2d0bbddf81fac8759;hpb=72057a3af19ee02d9a686bd7e7d074917e381310 diff --git a/libcfs/libcfs/watchdog.c b/libcfs/libcfs/watchdog.c index 04e4da7..4c437ab 100644 --- a/libcfs/libcfs/watchdog.c +++ b/libcfs/libcfs/watchdog.c @@ -23,7 +23,7 @@ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2012, 2014, Intel Corporation. + * Copyright (c) 2012, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -40,12 +40,16 @@ #include #include "tracefile.h" +#ifndef WITH_WATCHDOG +#define WITH_WATCHDOG +#endif + struct lc_watchdog { spinlock_t lcw_lock; /* check or change lcw_list */ int lcw_refcount; /* must hold lcw_pending_timers_lock */ struct timer_list lcw_timer; /* kernel timer */ struct list_head lcw_list; /* chain on pending list */ - cfs_time_t lcw_last_touched;/* last touched stamp */ + ktime_t lcw_last_touched;/* last touched stamp */ struct task_struct *lcw_task; /* owner task */ void (*lcw_callback)(pid_t, void *); void *lcw_data; @@ -94,7 +98,7 @@ static DEFINE_SPINLOCK(lcw_pending_timers_lock); static struct list_head lcw_pending_timers = LIST_HEAD_INIT(lcw_pending_timers); /* Last time a watchdog expired */ -static cfs_time_t lcw_last_watchdog_time; +static time64_t lcw_last_watchdog_time; static int lcw_recent_watchdog_count; static void @@ -114,9 +118,9 @@ lcw_dump(struct lc_watchdog *lcw) EXIT; } -static void lcw_cb(uintptr_t data) +static void lcw_cb(cfs_timer_cb_arg_t data) { - struct lc_watchdog *lcw = (struct lc_watchdog *)data; + struct lc_watchdog *lcw = cfs_from_timer(lcw, data, lcw_timer); ENTRY; if (lcw->lcw_state != LC_WATCHDOG_ENABLED) { @@ -154,49 +158,44 @@ static int is_watchdog_fired(void) static void lcw_dump_stack(struct lc_watchdog *lcw) { - cfs_time_t current_time; - cfs_duration_t delta_time; - struct timeval timediff; - - current_time = cfs_time_current(); - delta_time = cfs_time_sub(current_time, lcw->lcw_last_touched); - cfs_duration_usec(delta_time, &timediff); - - /* - * Check to see if we should throttle the watchdog timer to avoid - * too many dumps going to the console thus triggering an NMI. - */ - delta_time = cfs_duration_sec(cfs_time_sub(current_time, - lcw_last_watchdog_time)); - - if (delta_time < libcfs_watchdog_ratelimit && - lcw_recent_watchdog_count > 3) { - LCONSOLE_WARN("Service thread pid %u was inactive for " - "%lu.%.02lus. Watchdog stack traces are limited " - "to 3 per %d seconds, skipping this one.\n", - (int)lcw->lcw_pid, - timediff.tv_sec, - timediff.tv_usec / 10000, - libcfs_watchdog_ratelimit); - } else { - if (delta_time < libcfs_watchdog_ratelimit) { - lcw_recent_watchdog_count++; - } else { - memcpy(&lcw_last_watchdog_time, ¤t_time, - sizeof(current_time)); - lcw_recent_watchdog_count = 0; - } - - LCONSOLE_WARN("Service thread pid %u was inactive for " - "%lu.%.02lus. The thread might be hung, or it " - "might only be slow and will resume later. " - "Dumping the stack trace for debugging purposes:" - "\n", - (int)lcw->lcw_pid, - timediff.tv_sec, - timediff.tv_usec / 10000); - lcw_dump(lcw); - } + time64_t current_time = ktime_get_seconds(); + struct timespec64 timediff; + time64_t delta_time; + + timediff = ktime_to_timespec64(ktime_sub(ktime_get(), + lcw->lcw_last_touched)); + + /* LU-9235: Don't dump stack if the thread is just touched. */ + if (timediff.tv_sec == 0) + return; + + /* + * Check to see if we should throttle the watchdog timer to avoid + * too many dumps going to the console thus triggering an NMI. + */ + delta_time = current_time - lcw_last_watchdog_time; + if (delta_time < libcfs_watchdog_ratelimit && + lcw_recent_watchdog_count > 3) { + LCONSOLE_WARN("Service thread pid %u was inactive for %lu.%.02lus. Watchdog stack traces are limited to 3 per %d seconds, skipping this one.\n", + (int)lcw->lcw_pid, + timediff.tv_sec, + timediff.tv_nsec / (NSEC_PER_SEC / 100), + libcfs_watchdog_ratelimit); + } else { + if (delta_time < libcfs_watchdog_ratelimit) { + lcw_recent_watchdog_count++; + } else { + memcpy(&lcw_last_watchdog_time, ¤t_time, + sizeof(current_time)); + lcw_recent_watchdog_count = 0; + } + + LCONSOLE_WARN("Service thread pid %u was inactive for %lu.%.02lus. The thread might be hung, or it might only be slow and will resume later. Dumping the stack trace for debugging purposes:\n", + (int)lcw->lcw_pid, + timediff.tv_sec, + timediff.tv_nsec / (NSEC_PER_SEC / 100)); + lcw_dump(lcw); + } } /* @@ -336,6 +335,7 @@ static void lcw_dispatch_stop(void) wake_up(&lcw_event_waitq); wait_for_completion(&lcw_stop_completion); + clear_bit(LCW_FLAG_STOP, &lcw_flags); CDEBUG(D_INFO, "watchdog dispatcher has shut down.\n"); @@ -364,19 +364,19 @@ struct lc_watchdog *lc_watchdog_add(int timeout, lcw->lcw_state = LC_WATCHDOG_DISABLED; INIT_LIST_HEAD(&lcw->lcw_list); - cfs_timer_init(&lcw->lcw_timer, lcw_cb, lcw); + cfs_timer_setup(&lcw->lcw_timer, lcw_cb, (unsigned long)lcw, 0); mutex_lock(&lcw_refcount_mutex); if (++lcw_refcount == 1) lcw_dispatch_start(); mutex_unlock(&lcw_refcount_mutex); - /* Keep this working in case we enable them by default */ - if (lcw->lcw_state == LC_WATCHDOG_ENABLED) { - lcw->lcw_last_touched = cfs_time_current(); - cfs_timer_arm(&lcw->lcw_timer, cfs_time_seconds(timeout) + - cfs_time_current()); - } + /* Keep this working in case we enable them by default */ + if (lcw->lcw_state == LC_WATCHDOG_ENABLED) { + lcw->lcw_last_touched = ktime_get(); + mod_timer(&lcw->lcw_timer, cfs_time_seconds(timeout) + + jiffies); + } RETURN(lcw); } @@ -384,24 +384,19 @@ EXPORT_SYMBOL(lc_watchdog_add); static void lcw_update_time(struct lc_watchdog *lcw, const char *message) { - cfs_time_t newtime = cfs_time_current(); - - if (lcw->lcw_state == LC_WATCHDOG_EXPIRED) { - struct timeval timediff; - cfs_time_t delta_time = cfs_time_sub(newtime, - lcw->lcw_last_touched); - cfs_duration_usec(delta_time, &timediff); - - LCONSOLE_WARN("Service thread pid %u %s after %lu.%.02lus. " - "This indicates the system was overloaded (too " - "many service threads, or there were not enough " - "hardware resources).\n", - lcw->lcw_pid, - message, - timediff.tv_sec, - timediff.tv_usec / 10000); - } - lcw->lcw_last_touched = newtime; + ktime_t newtime = ktime_get(); + + if (lcw->lcw_state == LC_WATCHDOG_EXPIRED) { + ktime_t lapse = ktime_sub(newtime, lcw->lcw_last_touched); + struct timespec64 timediff; + + timediff = ktime_to_timespec64(lapse); + LCONSOLE_WARN("Service thread pid %u %s after %lu.%.02lus. This indicates the system was overloaded (too many service threads, or there were not enough hardware resources).\n", + lcw->lcw_pid, message, + timediff.tv_sec, + timediff.tv_nsec / (NSEC_PER_SEC / 100)); + } + lcw->lcw_last_touched = newtime; } static void lc_watchdog_del_pending(struct lc_watchdog *lcw) @@ -419,18 +414,17 @@ static void lc_watchdog_del_pending(struct lc_watchdog *lcw) void lc_watchdog_touch(struct lc_watchdog *lcw, int timeout) { - ENTRY; - LASSERT(lcw != NULL); + ENTRY; + LASSERT(lcw != NULL); - lc_watchdog_del_pending(lcw); + lc_watchdog_del_pending(lcw); - lcw_update_time(lcw, "resumed"); + lcw_update_time(lcw, "resumed"); - cfs_timer_arm(&lcw->lcw_timer, cfs_time_current() + - cfs_time_seconds(timeout)); + mod_timer(&lcw->lcw_timer, jiffies + cfs_time_seconds(timeout)); lcw->lcw_state = LC_WATCHDOG_ENABLED; - EXIT; + EXIT; } EXPORT_SYMBOL(lc_watchdog_touch); @@ -455,7 +449,7 @@ void lc_watchdog_delete(struct lc_watchdog *lcw) ENTRY; LASSERT(lcw != NULL); - cfs_timer_disarm(&lcw->lcw_timer); + del_timer(&lcw->lcw_timer); lcw_update_time(lcw, "stopped");