LU-9019 lnet: move ping and delay injection to time64_t

[fs/lustre-release.git] / lnet / lnet / net_fault.c

diff --git a/lnet/lnet/net_fault.c b/lnet/lnet/net_fault.c
index eaf2078..398864e 100644 (file)
--- a/lnet/lnet/net_fault.c
+++ b/lnet/lnet/net_fault.c
@@ -57,9 +57,9 @@ struct lnet_drop_rule {
        /**
         * seconds to drop the next message, it's exclusive with dr_drop_at
         */
-       cfs_time_t              dr_drop_time;
+       time64_t                dr_drop_time;
        /** baseline to caculate dr_drop_time */
-       cfs_time_t              dr_time_base;
+       time64_t                dr_time_base;
        /** statistic of dropped messages */
        struct lnet_fault_stat  dr_stat;
 };
@@ -170,9 +170,9 @@ lnet_drop_rule_add(struct lnet_fault_attr *attr)
 
        rule->dr_attr = *attr;
        if (attr->u.drop.da_interval != 0) {
-               rule->dr_time_base = cfs_time_shift(attr->u.drop.da_interval);
-               rule->dr_drop_time = cfs_time_shift(cfs_rand() %
-                                                   attr->u.drop.da_interval);
+               rule->dr_time_base = ktime_get_seconds() + attr->u.drop.da_interval;
+               rule->dr_drop_time = ktime_get_seconds() +
+                                    cfs_rand() % attr->u.drop.da_interval;
        } else {
                rule->dr_drop_at = cfs_rand() % attr->u.drop.da_rate;
        }
@@ -283,10 +283,9 @@ lnet_drop_rule_reset(void)
                if (attr->u.drop.da_rate != 0) {
                        rule->dr_drop_at = cfs_rand() % attr->u.drop.da_rate;
                } else {
-                       rule->dr_drop_time = cfs_time_shift(cfs_rand() %
-                                               attr->u.drop.da_interval);
-                       rule->dr_time_base = cfs_time_shift(attr->u.drop.
-                                                                 da_interval);
+                       rule->dr_drop_time = ktime_get_seconds() +
+                                            cfs_rand() % attr->u.drop.da_interval;
+                       rule->dr_time_base = ktime_get_seconds() + attr->u.drop.da_interval;
                }
                spin_unlock(&rule->dr_lock);
        }
@@ -312,21 +311,19 @@ drop_rule_match(struct lnet_drop_rule *rule, lnet_nid_t src,
        /* match this rule, check drop rate now */
        spin_lock(&rule->dr_lock);
        if (rule->dr_drop_time != 0) { /* time based drop */
-               cfs_time_t now = cfs_time_current();
+               time64_t now = ktime_get_seconds();
 
                rule->dr_stat.fs_count++;
-               drop = cfs_time_aftereq(now, rule->dr_drop_time);
+               drop = now >= rule->dr_drop_time;
                if (drop) {
-                       if (cfs_time_after(now, rule->dr_time_base))
+                       if (now > rule->dr_time_base)
                                rule->dr_time_base = now;
 
                        rule->dr_drop_time = rule->dr_time_base +
-                                            cfs_time_seconds(cfs_rand() %
-                                               attr->u.drop.da_interval);
-                       rule->dr_time_base += cfs_time_seconds(attr->u.drop.
-                                                              da_interval);
+                                            cfs_rand() % attr->u.drop.da_interval;
+                       rule->dr_time_base += attr->u.drop.da_interval;
 
-                       CDEBUG(D_NET, "Drop Rule %s->%s: next drop : %ld\n",
+                       CDEBUG(D_NET, "Drop Rule %s->%s: next drop : %lld\n",
                               libcfs_nid2str(attr->fa_src),
                               libcfs_nid2str(attr->fa_dst),
                               rule->dr_drop_time);
@@ -412,9 +409,9 @@ struct lnet_delay_rule {
        /**
         * seconds to delay the next message, it's exclusive with dl_delay_at
         */
-       cfs_time_t              dl_delay_time;
+       time64_t                dl_delay_time;
        /** baseline to caculate dl_delay_time */
-       cfs_time_t              dl_time_base;
+       time64_t                dl_time_base;
        /** jiffies to send the next delayed message */
        unsigned long           dl_msg_send;
        /** delayed message list */
@@ -444,13 +441,6 @@ struct delay_daemon_data {
 
 static struct delay_daemon_data        delay_dd;
 
-static cfs_time_t
-round_timeout(cfs_time_t timeout)
-{
-       return cfs_time_seconds((unsigned int)
-                       cfs_duration_sec(cfs_time_sub(timeout, 0)) + 1);
-}
-
 static void
 delay_rule_decref(struct lnet_delay_rule *rule)
 {
@@ -481,21 +471,19 @@ delay_rule_match(struct lnet_delay_rule *rule, lnet_nid_t src,
        /* match this rule, check delay rate now */
        spin_lock(&rule->dl_lock);
        if (rule->dl_delay_time != 0) { /* time based delay */
-               cfs_time_t now = cfs_time_current();
+               time64_t now = ktime_get_seconds();
 
                rule->dl_stat.fs_count++;
-               delay = cfs_time_aftereq(now, rule->dl_delay_time);
+               delay = now >= rule->dl_delay_time;
                if (delay) {
-                       if (cfs_time_after(now, rule->dl_time_base))
+                       if (now > rule->dl_time_base)
                                rule->dl_time_base = now;
 
                        rule->dl_delay_time = rule->dl_time_base +
-                                            cfs_time_seconds(cfs_rand() %
-                                               attr->u.delay.la_interval);
-                       rule->dl_time_base += cfs_time_seconds(attr->u.delay.
-                                                              la_interval);
+                                             cfs_rand() % attr->u.delay.la_interval;
+                       rule->dl_time_base += attr->u.delay.la_interval;
 
-                       CDEBUG(D_NET, "Delay Rule %s->%s: next delay : %ld\n",
+                       CDEBUG(D_NET, "Delay Rule %s->%s: next delay : %lld\n",
                               libcfs_nid2str(attr->fa_src),
                               libcfs_nid2str(attr->fa_dst),
                               rule->dl_delay_time);
@@ -526,8 +514,7 @@ delay_rule_match(struct lnet_delay_rule *rule, lnet_nid_t src,
        rule->dl_stat.u.delay.ls_delayed++;
 
        list_add_tail(&msg->msg_list, &rule->dl_msg_list);
-       msg->msg_delay_send = round_timeout(
-                       cfs_time_shift(attr->u.delay.la_latency));
+       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);
@@ -574,9 +561,9 @@ delayed_msg_check(struct lnet_delay_rule *rule, bool all,
 {
        struct lnet_msg *msg;
        struct lnet_msg *tmp;
-       unsigned long    now = cfs_time_current();
+       time64_t now = ktime_get_seconds();
 
-       if (!all && rule->dl_msg_send > now)
+       if (!all && cfs_time_seconds(rule->dl_msg_send) > now)
                return;
 
        spin_lock(&rule->dl_lock);
@@ -783,9 +770,10 @@ lnet_delay_rule_add(struct lnet_fault_attr *attr)
 
        rule->dl_attr = *attr;
        if (attr->u.delay.la_interval != 0) {
-               rule->dl_time_base = cfs_time_shift(attr->u.delay.la_interval);
-               rule->dl_delay_time = cfs_time_shift(cfs_rand() %
-                                                    attr->u.delay.la_interval);
+               rule->dl_time_base = ktime_get_seconds() +
+                                    attr->u.delay.la_interval;
+               rule->dl_delay_time = ktime_get_seconds() +
+                                     cfs_rand() % attr->u.delay.la_interval;
        } else {
                rule->dl_delay_at = cfs_rand() % attr->u.delay.la_rate;
        }
@@ -936,10 +924,10 @@ lnet_delay_rule_reset(void)
                if (attr->u.delay.la_rate != 0) {
                        rule->dl_delay_at = cfs_rand() % attr->u.delay.la_rate;
                } else {
-                       rule->dl_delay_time = cfs_time_shift(cfs_rand() %
-                                               attr->u.delay.la_interval);
-                       rule->dl_time_base = cfs_time_shift(attr->u.delay.
-                                                                 la_interval);
+                       rule->dl_delay_time = ktime_get_seconds() +
+                                             cfs_rand() % attr->u.delay.la_interval;
+                       rule->dl_time_base = ktime_get_seconds() +
+                                            attr->u.delay.la_interval;
                }
                spin_unlock(&rule->dl_lock);
        }