LU-13210 lnet: gcc8 add implicit-fallthrough decorator

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

diff --git a/lnet/lnet/net_fault.c b/lnet/lnet/net_fault.c
index 7fdd8df..56365fd 100644 (file)
--- a/lnet/lnet/net_fault.c
+++ b/lnet/lnet/net_fault.c
@@ -36,6 +36,7 @@
 
 #define DEBUG_SUBSYSTEM S_LNET
 
 
 #define DEBUG_SUBSYSTEM S_LNET
 

+#include <linux/random.h>

 #include <lnet/lib-lnet.h>
 #include <uapi/linux/lnet/lnetctl.h>
 
 #include <lnet/lib-lnet.h>
 #include <uapi/linux/lnet/lnetctl.h>
 


@@ -174,9 +175,9 @@ lnet_drop_rule_add(struct lnet_fault_attr *attr)
        if (attr->u.drop.da_interval != 0) {
                rule->dr_time_base = ktime_get_seconds() + attr->u.drop.da_interval;
                rule->dr_drop_time = ktime_get_seconds() +
        if (attr->u.drop.da_interval != 0) {
                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;
+                                    prandom_u32_max(attr->u.drop.da_interval);

        } else {
        } else {

-               rule->dr_drop_at = cfs_rand() % attr->u.drop.da_rate;
+               rule->dr_drop_at = prandom_u32_max(attr->u.drop.da_rate);

        }
 
        lnet_net_lock(LNET_LOCK_EX);
        }
 
        lnet_net_lock(LNET_LOCK_EX);


@@ -201,12 +202,10 @@ lnet_drop_rule_del(lnet_nid_t src, lnet_nid_t dst)
 {
        struct lnet_drop_rule *rule;
        struct lnet_drop_rule *tmp;
 {
        struct lnet_drop_rule *rule;
        struct lnet_drop_rule *tmp;

-       struct list_head       zombies;
-       int                    n = 0;
+       LIST_HEAD(zombies);
+       int n = 0;

        ENTRY;
 
        ENTRY;
 

-       INIT_LIST_HEAD(&zombies);
-

        lnet_net_lock(LNET_LOCK_EX);
        list_for_each_entry_safe(rule, tmp, &the_lnet.ln_drop_rules, dr_link) {
                if (rule->dr_attr.fa_src != src && src != 0)
        lnet_net_lock(LNET_LOCK_EX);
        list_for_each_entry_safe(rule, tmp, &the_lnet.ln_drop_rules, dr_link) {
                if (rule->dr_attr.fa_src != src && src != 0)


@@ -283,10 +282,10 @@ lnet_drop_rule_reset(void)
 
                memset(&rule->dr_stat, 0, sizeof(rule->dr_stat));
                if (attr->u.drop.da_rate != 0) {
 
                memset(&rule->dr_stat, 0, sizeof(rule->dr_stat));
                if (attr->u.drop.da_rate != 0) {

-                       rule->dr_drop_at = cfs_rand() % attr->u.drop.da_rate;
+                       rule->dr_drop_at = prandom_u32_max(attr->u.drop.da_rate);

                } else {
                        rule->dr_drop_time = ktime_get_seconds() +
                } else {
                        rule->dr_drop_time = ktime_get_seconds() +

-                                            cfs_rand() % attr->u.drop.da_interval;
+                                            prandom_u32_max(attr->u.drop.da_interval);

                        rule->dr_time_base = ktime_get_seconds() + attr->u.drop.da_interval;
                }
                spin_unlock(&rule->dr_lock);
                        rule->dr_time_base = ktime_get_seconds() + attr->u.drop.da_interval;
                }
                spin_unlock(&rule->dr_lock);


@@ -299,15 +298,13 @@ lnet_drop_rule_reset(void)
 static void
 lnet_fault_match_health(enum lnet_msg_hstatus *hstatus, __u32 mask)
 {
 static void
 lnet_fault_match_health(enum lnet_msg_hstatus *hstatus, __u32 mask)
 {

-       unsigned int random;

        int choice;
        int delta;
        int best_delta;
        int i;
 
        /* assign a random failure */
        int choice;
        int delta;
        int best_delta;
        int i;
 
        /* assign a random failure */

-       random = cfs_rand();
-       choice = random % (LNET_MSG_STATUS_END - LNET_MSG_STATUS_OK);
+       choice = prandom_u32_max(LNET_MSG_STATUS_END - LNET_MSG_STATUS_OK);

        if (choice == 0)
                choice++;
 
        if (choice == 0)
                choice++;
 


@@ -373,7 +370,7 @@ 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 (attr->u.drop.da_random) {
        /* match this rule, check drop rate now */
        spin_lock(&rule->dr_lock);
        if (attr->u.drop.da_random) {

-               int value = cfs_rand() % attr->u.drop.da_interval;
+               int value = prandom_u32_max(attr->u.drop.da_interval);

                if (value >= (attr->u.drop.da_interval / 2))
                        drop = true;
                else
                if (value >= (attr->u.drop.da_interval / 2))
                        drop = true;
                else


@@ -388,7 +385,7 @@ drop_rule_match(struct lnet_drop_rule *rule, lnet_nid_t src,
                                rule->dr_time_base = now;
 
                        rule->dr_drop_time = rule->dr_time_base +
                                rule->dr_time_base = now;
 
                        rule->dr_drop_time = rule->dr_time_base +

-                                            cfs_rand() % attr->u.drop.da_interval;
+                                            prandom_u32_max(attr->u.drop.da_interval);

                        rule->dr_time_base += attr->u.drop.da_interval;
 
                        CDEBUG(D_NET, "Drop Rule %s->%s: next drop : %lld\n",
                        rule->dr_time_base += attr->u.drop.da_interval;
 
                        CDEBUG(D_NET, "Drop Rule %s->%s: next drop : %lld\n",


@@ -404,7 +401,7 @@ drop_rule_match(struct lnet_drop_rule *rule, lnet_nid_t src,
                count = rule->dr_stat.fs_count;
                if (do_div(count, attr->u.drop.da_rate) == 0) {
                        rule->dr_drop_at = rule->dr_stat.fs_count +
                count = rule->dr_stat.fs_count;
                if (do_div(count, attr->u.drop.da_rate) == 0) {
                        rule->dr_drop_at = rule->dr_stat.fs_count +

-                                          cfs_rand() % attr->u.drop.da_rate;
+                                          prandom_u32_max(attr->u.drop.da_rate);

                        CDEBUG(D_NET, "Drop Rule %s->%s: next drop: %lu\n",
                               libcfs_nid2str(attr->fa_src),
                               libcfs_nid2str(attr->fa_dst), rule->dr_drop_at);
                        CDEBUG(D_NET, "Drop Rule %s->%s: next drop: %lu\n",
                               libcfs_nid2str(attr->fa_src),
                               libcfs_nid2str(attr->fa_dst), rule->dr_drop_at);


@@ -488,8 +485,8 @@ struct lnet_delay_rule {
        time64_t                dl_delay_time;
        /** baseline to caculate dl_delay_time */
        time64_t                dl_time_base;
        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 */
        /** delayed message list */
        struct list_head        dl_msg_list;
        /** statistic of delayed messages */


@@ -557,7 +554,7 @@ delay_rule_match(struct lnet_delay_rule *rule, lnet_nid_t src,
                                rule->dl_time_base = now;
 
                        rule->dl_delay_time = rule->dl_time_base +
                                rule->dl_time_base = now;
 
                        rule->dl_delay_time = rule->dl_time_base +

-                                             cfs_rand() % attr->u.delay.la_interval;
+                                             prandom_u32_max(attr->u.delay.la_interval);

                        rule->dl_time_base += attr->u.delay.la_interval;
 
                        CDEBUG(D_NET, "Delay Rule %s->%s: next delay : %lld\n",
                        rule->dl_time_base += attr->u.delay.la_interval;
 
                        CDEBUG(D_NET, "Delay Rule %s->%s: next delay : %lld\n",


@@ -574,7 +571,7 @@ delay_rule_match(struct lnet_delay_rule *rule, lnet_nid_t src,
                count = rule->dl_stat.fs_count;
                if (do_div(count, attr->u.delay.la_rate) == 0) {
                        rule->dl_delay_at = rule->dl_stat.fs_count +
                count = rule->dl_stat.fs_count;
                if (do_div(count, attr->u.delay.la_rate) == 0) {
                        rule->dl_delay_at = rule->dl_stat.fs_count +

-                                           cfs_rand() % attr->u.delay.la_rate;
+                                           prandom_u32_max(attr->u.delay.la_rate);

                        CDEBUG(D_NET, "Delay Rule %s->%s: next delay: %lu\n",
                               libcfs_nid2str(attr->fa_src),
                               libcfs_nid2str(attr->fa_dst), rule->dl_delay_at);
                        CDEBUG(D_NET, "Delay Rule %s->%s: next delay: %lu\n",
                               libcfs_nid2str(attr->fa_src),
                               libcfs_nid2str(attr->fa_dst), rule->dl_delay_at);


@@ -594,7 +591,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;
        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);
        }
 
        spin_unlock(&rule->dl_lock);


@@ -662,7 +660,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;
                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);
 }
        }
        spin_unlock(&rule->dl_lock);
 }


@@ -702,6 +701,7 @@ delayed_msg_process(struct list_head *msg_list, bool drop)
                        case LNET_CREDIT_OK:
                                lnet_ni_recv(ni, msg->msg_private, msg, 0,
                                             0, msg->msg_len, msg->msg_len);
                        case LNET_CREDIT_OK:
                                lnet_ni_recv(ni, msg->msg_private, msg, 0,
                                             0, msg->msg_len, msg->msg_len);

+                               /* fallthrough */

                        case LNET_CREDIT_WAIT:
                                continue;
                        default: /* failures */
                        case LNET_CREDIT_WAIT:
                                continue;
                        default: /* failures */


@@ -722,10 +722,9 @@ delayed_msg_process(struct list_head *msg_list, bool drop)
 void
 lnet_delay_rule_check(void)
 {
 void
 lnet_delay_rule_check(void)
 {

-       struct lnet_delay_rule  *rule;
-       struct list_head         msgs;
+       struct lnet_delay_rule *rule;
+       LIST_HEAD(msgs);

 
 

-       INIT_LIST_HEAD(&msgs);

        while (1) {
                if (list_empty(&delay_dd.dd_sched_rules))
                        break;
        while (1) {
                if (list_empty(&delay_dd.dd_sched_rules))
                        break;


@@ -849,9 +848,9 @@ lnet_delay_rule_add(struct lnet_fault_attr *attr)
                rule->dl_time_base = ktime_get_seconds() +
                                     attr->u.delay.la_interval;
                rule->dl_delay_time = ktime_get_seconds() +
                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;
+                                     prandom_u32_max(attr->u.delay.la_interval);

        } else {
        } else {

-               rule->dl_delay_at = cfs_rand() % attr->u.delay.la_rate;
+               rule->dl_delay_at = prandom_u32_max(attr->u.delay.la_rate);

        }
 
        rule->dl_msg_send = -1;
        }
 
        rule->dl_msg_send = -1;


@@ -887,16 +886,13 @@ int
 lnet_delay_rule_del(lnet_nid_t src, lnet_nid_t dst, bool shutdown)
 {
        struct lnet_delay_rule *rule;
 lnet_delay_rule_del(lnet_nid_t src, lnet_nid_t dst, bool shutdown)
 {
        struct lnet_delay_rule *rule;

-       struct lnet_delay_rule  *tmp;
-       struct list_head        rule_list;
-       struct list_head        msg_list;
-       int                     n = 0;
-       bool                    cleanup;
+       struct lnet_delay_rule *tmp;
+       LIST_HEAD(rule_list);
+       LIST_HEAD(msg_list);
+       int n = 0;
+       bool cleanup;

        ENTRY;
 
        ENTRY;
 

-       INIT_LIST_HEAD(&rule_list);
-       INIT_LIST_HEAD(&msg_list);
-

        if (shutdown)
                src = dst = 0;
 
        if (shutdown)
                src = dst = 0;
 


@@ -998,10 +994,10 @@ lnet_delay_rule_reset(void)
 
                memset(&rule->dl_stat, 0, sizeof(rule->dl_stat));
                if (attr->u.delay.la_rate != 0) {
 
                memset(&rule->dl_stat, 0, sizeof(rule->dl_stat));
                if (attr->u.delay.la_rate != 0) {

-                       rule->dl_delay_at = cfs_rand() % attr->u.delay.la_rate;
+                       rule->dl_delay_at = prandom_u32_max(attr->u.delay.la_rate);

                } else {
                        rule->dl_delay_time = ktime_get_seconds() +
                } else {
                        rule->dl_delay_time = ktime_get_seconds() +

-                                             cfs_rand() % attr->u.delay.la_interval;
+                                             prandom_u32_max(attr->u.delay.la_interval);

                        rule->dl_time_base = ktime_get_seconds() +
                                             attr->u.delay.la_interval;
                }
                        rule->dl_time_base = ktime_get_seconds() +
                                             attr->u.delay.la_interval;
                }


@@ -1079,10 +1075,10 @@ lnet_fault_ctl(int opc, struct libcfs_ioctl_data *data)
 int
 lnet_fault_init(void)
 {
 int
 lnet_fault_init(void)
 {

-       CLASSERT(LNET_PUT_BIT == 1 << LNET_MSG_PUT);
-       CLASSERT(LNET_ACK_BIT == 1 << LNET_MSG_ACK);
-       CLASSERT(LNET_GET_BIT == 1 << LNET_MSG_GET);
-       CLASSERT(LNET_REPLY_BIT == 1 << LNET_MSG_REPLY);
+       BUILD_BUG_ON(LNET_PUT_BIT != 1 << LNET_MSG_PUT);
+       BUILD_BUG_ON(LNET_ACK_BIT != 1 << LNET_MSG_ACK);
+       BUILD_BUG_ON(LNET_GET_BIT != 1 << LNET_MSG_GET);
+       BUILD_BUG_ON(LNET_REPLY_BIT != 1 << LNET_MSG_REPLY);

 
        mutex_init(&delay_dd.dd_mutex);
        spin_lock_init(&delay_dd.dd_lock);
 
        mutex_init(&delay_dd.dd_mutex);
        spin_lock_init(&delay_dd.dd_lock);