X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lnet%2Flnet%2Fnet_fault.c;h=98f9b314c5de5f46fdbb900f60eb3671b41c76e9;hp=b5c69f22c4290573f951eb7ac4aa8b015cf1efa2;hb=3b760208109b249fd9051d97dbc98664ca4b5769;hpb=e5ef85126953f866e155bb4f55cd85da963bde52 diff --git a/lnet/lnet/net_fault.c b/lnet/lnet/net_fault.c index b5c69f2..98f9b31 100644 --- a/lnet/lnet/net_fault.c +++ b/lnet/lnet/net_fault.c @@ -21,11 +21,10 @@ * GPL HEADER END */ /* - * Copyright (c) 2014, Intel Corporation. + * Copyright (c) 2014, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ - * Lustre is a trademark of Sun Microsystems, Inc. * * lnet/lnet/net_fault.c * @@ -36,8 +35,9 @@ #define DEBUG_SUBSYSTEM S_LNET +#include #include -#include +#include #define LNET_MSG_MASK (LNET_PUT_BIT | LNET_ACK_BIT | \ LNET_GET_BIT | LNET_REPLY_BIT) @@ -57,20 +57,24 @@ 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; }; static bool -lnet_fault_nid_match(lnet_nid_t nid, lnet_nid_t msg_nid) +lnet_fault_nid_match(lnet_nid_t nid, struct lnet_nid *msg_nid) { - if (nid == msg_nid || nid == LNET_NID_ANY) + if (nid == LNET_NID_ANY) + return true; + if (!msg_nid) + return false; + if (lnet_nid_to_nid4(msg_nid) == nid) return true; - if (LNET_NIDNET(nid) != LNET_NIDNET(msg_nid)) + if (LNET_NIDNET(nid) != LNET_NID_NET(msg_nid)) return false; /* 255.255.255.255@net is wildcard for all addresses in a network */ @@ -78,14 +82,18 @@ lnet_fault_nid_match(lnet_nid_t nid, lnet_nid_t msg_nid) } static bool -lnet_fault_attr_match(struct lnet_fault_attr *attr, lnet_nid_t src, - lnet_nid_t dst, unsigned int type, unsigned int portal) +lnet_fault_attr_match(struct lnet_fault_attr *attr, + struct lnet_nid *src, + struct lnet_nid *local_nid, + struct lnet_nid *dst, + unsigned int type, unsigned int portal) { if (!lnet_fault_nid_match(attr->fa_src, src) || - !lnet_fault_nid_match(attr->fa_dst, dst)) + !lnet_fault_nid_match(attr->fa_dst, dst) || + !lnet_fault_nid_match(attr->fa_local_nid, local_nid)) return false; - if (!(attr->fa_msg_mask & (1 << type))) + if (!(attr->fa_msg_mask & BIT(type))) return false; /* NB: ACK and REPLY have no portal, but they should have been @@ -170,11 +178,11 @@ 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() + + prandom_u32_max(attr->u.drop.da_interval); } 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); @@ -199,12 +207,10 @@ lnet_drop_rule_del(lnet_nid_t src, lnet_nid_t dst) { struct lnet_drop_rule *rule; struct lnet_drop_rule *tmp; - struct list_head zombies; - int n = 0; + LIST_HEAD(zombies); + int n = 0; 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) @@ -281,12 +287,11 @@ lnet_drop_rule_reset(void) 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 = 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() + + 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); } @@ -295,42 +300,105 @@ lnet_drop_rule_reset(void) EXIT; } +static void +lnet_fault_match_health(enum lnet_msg_hstatus *hstatus, __u32 mask) +{ + int choice; + int delta; + int best_delta; + int i; + + /* assign a random failure */ + choice = prandom_u32_max(LNET_MSG_STATUS_END - LNET_MSG_STATUS_OK); + if (choice == 0) + choice++; + + if (mask == HSTATUS_RANDOM) { + *hstatus = choice; + return; + } + + if (mask & BIT(choice)) { + *hstatus = choice; + return; + } + + /* round to the closest ON bit */ + i = HSTATUS_END; + best_delta = HSTATUS_END; + while (i > 0) { + if (mask & BIT(i)) { + delta = choice - i; + if (delta < 0) + delta *= -1; + if (delta < best_delta) { + best_delta = delta; + choice = i; + } + } + i--; + } + + *hstatus = choice; +} + /** * check source/destination NID, portal, message type and drop rate, * decide whether should drop this message or not */ static bool -drop_rule_match(struct lnet_drop_rule *rule, lnet_nid_t src, - lnet_nid_t dst, unsigned int type, unsigned int portal) +drop_rule_match(struct lnet_drop_rule *rule, + struct lnet_nid *src, + struct lnet_nid *local_nid, + struct lnet_nid *dst, + unsigned int type, unsigned int portal, + enum lnet_msg_hstatus *hstatus) { struct lnet_fault_attr *attr = &rule->dr_attr; bool drop; - if (!lnet_fault_attr_match(attr, src, dst, type, portal)) + if (!lnet_fault_attr_match(attr, src, local_nid, dst, type, portal)) + return false; + + if (attr->u.drop.da_drop_all) { + CDEBUG(D_NET, "set to drop all messages\n"); + drop = true; + goto drop_matched; + } + + /* + * if we're trying to match a health status error but it hasn't + * been set in the rule, then don't match + */ + if ((hstatus && !attr->u.drop.da_health_error_mask) || + (!hstatus && attr->u.drop.da_health_error_mask)) return false; /* 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(); + if (attr->u.drop.da_random) { + int value = prandom_u32_max(attr->u.drop.da_interval); + if (value >= (attr->u.drop.da_interval / 2)) + drop = true; + else + drop = false; + } else if (rule->dr_drop_time != 0) { /* time based drop */ + 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); - - CDEBUG(D_NET, "Drop Rule %s->%s: next drop : " - CFS_TIME_T"\n", - libcfs_nid2str(attr->fa_src), - libcfs_nid2str(attr->fa_dst), - rule->dr_drop_time); + 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", + libcfs_nid2str(attr->fa_src), + libcfs_nid2str(attr->fa_dst), + rule->dr_drop_time); } } else { /* rate based drop */ @@ -340,14 +408,19 @@ 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 + - 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); } } +drop_matched: + if (drop) { /* drop this message, update counters */ + if (hstatus) + lnet_fault_match_health(hstatus, + attr->u.drop.da_health_error_mask); lnet_fault_stat_inc(&rule->dr_stat, type); rule->dr_stat.u.drop.ds_dropped++; } @@ -360,15 +433,15 @@ drop_rule_match(struct lnet_drop_rule *rule, lnet_nid_t src, * Check if message from \a src to \a dst can match any existed drop rule */ bool -lnet_drop_rule_match(lnet_hdr_t *hdr) +lnet_drop_rule_match(struct lnet_hdr *hdr, + struct lnet_nid *local_nid, + enum lnet_msg_hstatus *hstatus) { - struct lnet_drop_rule *rule; - lnet_nid_t src = le64_to_cpu(hdr->src_nid); - lnet_nid_t dst = le64_to_cpu(hdr->dest_nid); - unsigned int typ = le32_to_cpu(hdr->type); - unsigned int ptl = -1; - bool drop = false; - int cpt; + unsigned int typ = hdr->type; + struct lnet_drop_rule *rule; + unsigned int ptl = -1; + bool drop = false; + int cpt; /* NB: if Portal is specified, then only PUT and GET will be * filtered by drop rule */ @@ -379,12 +452,14 @@ lnet_drop_rule_match(lnet_hdr_t *hdr) cpt = lnet_net_lock_current(); list_for_each_entry(rule, &the_lnet.ln_drop_rules, dr_link) { - drop = drop_rule_match(rule, src, dst, typ, ptl); + drop = drop_rule_match(rule, &hdr->src_nid, local_nid, + &hdr->dest_nid, typ, ptl, + hstatus); if (drop) break; } - lnet_net_unlock(cpt); + return drop; } @@ -413,11 +488,11 @@ 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; - /** jiffies to send the next delayed message */ - unsigned long dl_msg_send; + time64_t dl_time_base; + /** 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 */ @@ -445,13 +520,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) { @@ -469,38 +537,35 @@ delay_rule_decref(struct lnet_delay_rule *rule) * decide whether should delay this message or not */ static bool -delay_rule_match(struct lnet_delay_rule *rule, lnet_nid_t src, - lnet_nid_t dst, unsigned int type, unsigned int portal, - struct lnet_msg *msg) +delay_rule_match(struct lnet_delay_rule *rule, struct lnet_nid *src, + struct lnet_nid *dst, unsigned int type, unsigned int portal, + struct lnet_msg *msg) { - struct lnet_fault_attr *attr = &rule->dl_attr; - bool delay; + struct lnet_fault_attr *attr = &rule->dl_attr; + bool delay; + time64_t now = ktime_get_seconds(); - if (!lnet_fault_attr_match(attr, src, dst, type, portal)) + if (!lnet_fault_attr_match(attr, src, NULL, + dst, type, portal)) return false; /* 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(); - 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); - - CDEBUG(D_NET, "Delay Rule %s->%s: next delay : " - CFS_TIME_T"\n", - libcfs_nid2str(attr->fa_src), - libcfs_nid2str(attr->fa_dst), - rule->dl_delay_time); + 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", + libcfs_nid2str(attr->fa_src), + libcfs_nid2str(attr->fa_dst), + rule->dl_delay_time); } } else { /* rate based delay */ @@ -511,7 +576,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 + - 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); @@ -528,11 +593,11 @@ 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 = now + 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(attr->u.delay.la_latency)); } spin_unlock(&rule->dl_lock); @@ -544,12 +609,10 @@ delay_rule_match(struct lnet_delay_rule *rule, lnet_nid_t src, * will be delayed if there is a match. */ bool -lnet_delay_rule_match_locked(lnet_hdr_t *hdr, struct lnet_msg *msg) +lnet_delay_rule_match_locked(struct lnet_hdr *hdr, struct lnet_msg *msg) { struct lnet_delay_rule *rule; - lnet_nid_t src = le64_to_cpu(hdr->src_nid); - lnet_nid_t dst = le64_to_cpu(hdr->dest_nid); - unsigned int typ = le32_to_cpu(hdr->type); + unsigned int typ = hdr->type; unsigned int ptl = -1; /* NB: called with hold of lnet_net_lock */ @@ -562,7 +625,8 @@ lnet_delay_rule_match_locked(lnet_hdr_t *hdr, struct lnet_msg *msg) ptl = le32_to_cpu(hdr->msg.get.ptl_index); list_for_each_entry(rule, &the_lnet.ln_delay_rules, dl_link) { - if (delay_rule_match(rule, src, dst, typ, ptl, msg)) + if (delay_rule_match(rule, &hdr->src_nid, &hdr->dest_nid, + typ, ptl, msg)) return true; } @@ -576,7 +640,7 @@ 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) return; @@ -597,10 +661,12 @@ delayed_msg_check(struct lnet_delay_rule *rule, bool all, } else if (!list_empty(msg_list)) { /* dequeued some timedout messages, update timer for the * next delayed message on rule */ - msg = list_entry(rule->dl_msg_list.next, - struct lnet_msg, msg_list); + msg = list_first_entry(&rule->dl_msg_list, + 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(msg->msg_delay_send - now)); } spin_unlock(&rule->dl_lock); } @@ -610,15 +676,29 @@ delayed_msg_process(struct list_head *msg_list, bool drop) { struct lnet_msg *msg; - while (!list_empty(msg_list)) { + while ((msg = list_first_entry_or_null(msg_list, struct lnet_msg, + msg_list)) != NULL) { struct lnet_ni *ni; int cpt; int rc; - msg = list_entry(msg_list->next, struct lnet_msg, msg_list); + if (msg->msg_sending) { + /* Delayed send */ + list_del_init(&msg->msg_list); + ni = msg->msg_txni; + CDEBUG(D_NET, "TRACE: msg %p %s -> %s : %s\n", msg, + libcfs_nidstr(&ni->ni_nid), + libcfs_nidstr(&msg->msg_txpeer->lpni_nid), + lnet_msgtyp2str(msg->msg_type)); + lnet_ni_send(ni, msg); + continue; + } + + /* Delayed receive */ LASSERT(msg->msg_rxpeer != NULL); + LASSERT(msg->msg_rxni != NULL); - ni = msg->msg_rxpeer->lp_ni; + ni = msg->msg_rxni; cpt = msg->msg_rx_cpt; list_del_init(&msg->msg_list); @@ -639,6 +719,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); + fallthrough; case LNET_CREDIT_WAIT: continue; default: /* failures */ @@ -646,8 +727,9 @@ delayed_msg_process(struct list_head *msg_list, bool drop) } } - lnet_drop_message(ni, cpt, msg->msg_private, msg->msg_len); - lnet_finalize(ni, msg, rc); + lnet_drop_message(ni, cpt, msg->msg_private, msg->msg_len, + msg->msg_type); + lnet_finalize(msg, rc); } } @@ -658,10 +740,9 @@ delayed_msg_process(struct list_head *msg_list, bool drop) 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; @@ -672,8 +753,8 @@ lnet_delay_rule_check(void) break; } - rule = list_entry(delay_dd.dd_sched_rules.next, - struct lnet_delay_rule, dl_sched_link); + rule = list_first_entry(&delay_dd.dd_sched_rules, + struct lnet_delay_rule, dl_sched_link); list_del_init(&rule->dl_sched_link); spin_unlock_bh(&delay_dd.dd_lock); @@ -708,9 +789,9 @@ lnet_delay_rule_daemon(void *arg) } static void -delay_timer_cb(unsigned long arg) +delay_timer_cb(cfs_timer_cb_arg_t data) { - struct lnet_delay_rule *rule = (struct lnet_delay_rule *)arg; + struct lnet_delay_rule *rule = cfs_from_timer(rule, data, dl_timer); spin_lock_bh(&delay_dd.dd_lock); if (list_empty(&rule->dl_sched_link) && delay_dd.dd_running) { @@ -730,7 +811,7 @@ int lnet_delay_rule_add(struct lnet_fault_attr *attr) { struct lnet_delay_rule *rule; - int rc = 0; + int rc = 0; ENTRY; if (!((attr->u.delay.la_rate == 0) ^ @@ -773,9 +854,8 @@ lnet_delay_rule_add(struct lnet_fault_attr *attr) wait_event(delay_dd.dd_ctl_waitq, delay_dd.dd_running); } - init_timer(&rule->dl_timer); - rule->dl_timer.function = delay_timer_cb; - rule->dl_timer.data = (unsigned long)rule; + cfs_timer_setup(&rule->dl_timer, delay_timer_cb, + (unsigned long)rule, 0); spin_lock_init(&rule->dl_lock); INIT_LIST_HEAD(&rule->dl_msg_list); @@ -783,11 +863,12 @@ 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() + + prandom_u32_max(attr->u.delay.la_interval); } 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; @@ -823,16 +904,13 @@ int 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; - INIT_LIST_HEAD(&rule_list); - INIT_LIST_HEAD(&msg_list); - if (shutdown) src = dst = 0; @@ -893,9 +971,9 @@ lnet_delay_rule_list(int pos, struct lnet_fault_attr *attr, struct lnet_fault_stat *stat) { struct lnet_delay_rule *rule; - int cpt; - int i = 0; - int rc = -ENOENT; + int cpt; + int i = 0; + int rc = -ENOENT; ENTRY; cpt = lnet_net_lock_current(); @@ -922,7 +1000,7 @@ void lnet_delay_rule_reset(void) { struct lnet_delay_rule *rule; - int cpt; + int cpt; ENTRY; cpt = lnet_net_lock_current(); @@ -934,12 +1012,12 @@ lnet_delay_rule_reset(void) 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 = 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() + + prandom_u32_max(attr->u.delay.la_interval); + rule->dl_time_base = ktime_get_seconds() + + attr->u.delay.la_interval; } spin_unlock(&rule->dl_lock); } @@ -1015,10 +1093,10 @@ lnet_fault_ctl(int opc, struct libcfs_ioctl_data *data) 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 != BIT(LNET_MSG_PUT)); + BUILD_BUG_ON(LNET_ACK_BIT != BIT(LNET_MSG_ACK)); + BUILD_BUG_ON(LNET_GET_BIT != BIT(LNET_MSG_GET)); + BUILD_BUG_ON(LNET_REPLY_BIT != BIT(LNET_MSG_REPLY)); mutex_init(&delay_dd.dd_mutex); spin_lock_init(&delay_dd.dd_lock);