LU-12931 timers: correctly offset mod_timer.

During a high level code review of the lustre time code it was
discovered that some of the mod_timer() calles was missing
adding the current jiffies value to the timeout that converted
to jiffies from seconds. Add this proper offset.

Fixes: b11be372c21d ("LU-9019 lnet: move ping an delay injection to time64_t")
Fixes: e920b3681451 ("LU-9019 ldlm: migrate the rest of the code to 64 bit time")
Change-Id: Ie4be14946032308610aff2fe72d15d4d70773da1
Signed-off-by: James Simmons <jsimmons@infradead.org>
Reviewed-on: https://review.whamcloud.com/36688
Tested-by: jenkins <devops@whamcloud.com>
Reviewed-by: Neil Brown <neilb@suse.de>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Alex Zhuravlev <bzzz@whamcloud.com>
Reviewed-by: Shaun Tancheff <stancheff@cray.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lnet/lnet/net_fault.c b/lnet/lnet/net_fault.c
index 4f1bc30..ce68063 100644 (file)
--- a/lnet/lnet/net_fault.c
+++ b/lnet/lnet/net_fault.c
@@ -487,8 +487,8 @@ struct lnet_delay_rule {
        time64_t                dl_delay_time;
        /** baseline to caculate dl_delay_time */
        time64_t                dl_time_base;
-       /** jiffies to send the next delayed message */
-       unsigned long           dl_msg_send;
+       /** seconds until we send the next delayed message */
+       time64_t                dl_msg_send;
        /** delayed message list */
        struct list_head        dl_msg_list;
        /** statistic of delayed messages */
@@ -593,7 +593,8 @@ delay_rule_match(struct lnet_delay_rule *rule, lnet_nid_t src,
        msg->msg_delay_send = ktime_get_seconds() + attr->u.delay.la_latency;
        if (rule->dl_msg_send == -1) {
                rule->dl_msg_send = msg->msg_delay_send;
-               mod_timer(&rule->dl_timer, rule->dl_msg_send);
+               mod_timer(&rule->dl_timer,
+                         jiffies + cfs_time_seconds(rule->dl_msg_send));
        }
 
        spin_unlock(&rule->dl_lock);
@@ -661,7 +662,8 @@ delayed_msg_check(struct lnet_delay_rule *rule, bool all,
                msg = list_entry(rule->dl_msg_list.next,
                                 struct lnet_msg, msg_list);
                rule->dl_msg_send = msg->msg_delay_send;
-               mod_timer(&rule->dl_timer, rule->dl_msg_send);
+               mod_timer(&rule->dl_timer,
+                         jiffies + cfs_time_seconds(rule->dl_msg_send));
        }
        spin_unlock(&rule->dl_lock);
 }

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index 16ad0e7..12b9034 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -349,12 +349,15 @@ static void waiting_locks_callback(TIMER_DATA_TYPE unused)
         * left.
         */
        if (!list_empty(&waiting_locks_list)) {
-               unsigned long timeout_jiffies;
+               time64_t now = ktime_get_seconds();
+               time_t delta = 0;
 
                lock = list_entry(waiting_locks_list.next, struct ldlm_lock,
                                  l_pending_chain);
-               timeout_jiffies = cfs_time_seconds(lock->l_callback_timeout);
-               mod_timer(&waiting_locks_timer, timeout_jiffies);
+               if (lock->l_callback_timeout - now > 0)
+                       delta = lock->l_callback_timeout - now;
+               mod_timer(&waiting_locks_timer,
+                         jiffies + cfs_time_seconds(delta));
        }
        spin_unlock_bh(&waiting_locks_spinlock);
 }
@@ -373,8 +376,10 @@ static void waiting_locks_callback(TIMER_DATA_TYPE unused)
  */
 static int __ldlm_add_waiting_lock(struct ldlm_lock *lock, time64_t seconds)
 {
-       unsigned long timeout_jiffies;
-       time64_t timeout;
+       unsigned long timeout_jiffies = jiffies;
+       time64_t now = ktime_get_seconds();
+       time64_t deadline;
+       time_t timeout;
 
        if (!list_empty(&lock->l_pending_chain))
                return 0;
@@ -383,11 +388,13 @@ static int __ldlm_add_waiting_lock(struct ldlm_lock *lock, time64_t seconds)
            OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_HPREQ_TIMEOUT))
                seconds = 1;
 
-       timeout = ktime_get_seconds() + seconds;
-       if (likely(timeout > lock->l_callback_timeout))
-               lock->l_callback_timeout = timeout;
+       deadline = now + seconds;
+       if (likely(deadline > lock->l_callback_timeout))
+               lock->l_callback_timeout = deadline;
 
-       timeout_jiffies = cfs_time_seconds(lock->l_callback_timeout);
+       timeout = clamp_t(time_t, lock->l_callback_timeout - now,
+                         0, seconds);
+       timeout_jiffies += cfs_time_seconds(timeout);
 
        if (time_before(timeout_jiffies, waiting_locks_timer.expires) ||
            !timer_pending(&waiting_locks_timer))
@@ -504,12 +511,17 @@ static int __ldlm_del_waiting_lock(struct ldlm_lock *lock)
                        /* No more, just cancel. */
                        del_timer(&waiting_locks_timer);
                } else {
+                       time64_t now = ktime_get_seconds();
                        struct ldlm_lock *next;
+                       time_t delta = 0;
 
                        next = list_entry(list_next, struct ldlm_lock,
                                          l_pending_chain);
+                       if (next->l_callback_timeout - now > 0)
+                               delta = lock->l_callback_timeout - now;
+
                        mod_timer(&waiting_locks_timer,
-                                 cfs_time_seconds(next->l_callback_timeout));
+                                 jiffies + cfs_time_seconds(delta));
                }
        }
        list_del_init(&lock->l_pending_chain);