Whamcloud - gitweb
LU-13569 lnet: Age peer NI out of recovery
[fs/lustre-release.git] / lnet / lnet / lib-msg.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2012, 2017, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lnet/lnet/lib-msg.c
33  *
34  * Message decoding, parsing and finalizing routines
35  */
36
37 #define DEBUG_SUBSYSTEM S_LNET
38
39 #include <lnet/lib-lnet.h>
40
41 void
42 lnet_build_unlink_event(struct lnet_libmd *md, struct lnet_event *ev)
43 {
44         ENTRY;
45
46         memset(ev, 0, sizeof(*ev));
47
48         ev->status   = 0;
49         ev->unlinked = 1;
50         ev->type     = LNET_EVENT_UNLINK;
51         lnet_md_deconstruct(md, ev);
52         lnet_md2handle(&ev->md_handle, md);
53         EXIT;
54 }
55
56 /*
57  * Don't need any lock, must be called after lnet_commit_md
58  */
59 void
60 lnet_build_msg_event(struct lnet_msg *msg, enum lnet_event_kind ev_type)
61 {
62         struct lnet_hdr *hdr = &msg->msg_hdr;
63         struct lnet_event *ev = &msg->msg_ev;
64
65         LASSERT(!msg->msg_routing);
66
67         ev->type = ev_type;
68         ev->msg_type = msg->msg_type;
69
70         if (ev_type == LNET_EVENT_SEND) {
71                 /* event for active message */
72                 ev->target.nid    = le64_to_cpu(hdr->dest_nid);
73                 ev->target.pid    = le32_to_cpu(hdr->dest_pid);
74                 ev->initiator.nid = LNET_NID_ANY;
75                 ev->initiator.pid = the_lnet.ln_pid;
76                 ev->source.nid    = LNET_NID_ANY;
77                 ev->source.pid    = the_lnet.ln_pid;
78                 ev->sender        = LNET_NID_ANY;
79         } else {
80                 /* event for passive message */
81                 ev->target.pid    = hdr->dest_pid;
82                 ev->target.nid    = hdr->dest_nid;
83                 ev->initiator.pid = hdr->src_pid;
84                 /* Multi-Rail: resolve src_nid to "primary" peer NID */
85                 ev->initiator.nid = msg->msg_initiator;
86                 /* Multi-Rail: track source NID. */
87                 ev->source.pid    = hdr->src_pid;
88                 ev->source.nid    = hdr->src_nid;
89                 ev->rlength       = hdr->payload_length;
90                 ev->sender        = msg->msg_from;
91                 ev->mlength       = msg->msg_wanted;
92                 ev->offset        = msg->msg_offset;
93         }
94
95         switch (ev_type) {
96         default:
97                 LBUG();
98
99         case LNET_EVENT_PUT: /* passive PUT */
100                 ev->pt_index   = hdr->msg.put.ptl_index;
101                 ev->match_bits = hdr->msg.put.match_bits;
102                 ev->hdr_data   = hdr->msg.put.hdr_data;
103                 return;
104
105         case LNET_EVENT_GET: /* passive GET */
106                 ev->pt_index   = hdr->msg.get.ptl_index;
107                 ev->match_bits = hdr->msg.get.match_bits;
108                 ev->hdr_data   = 0;
109                 return;
110
111         case LNET_EVENT_ACK: /* ACK */
112                 ev->match_bits = hdr->msg.ack.match_bits;
113                 ev->mlength    = hdr->msg.ack.mlength;
114                 return;
115
116         case LNET_EVENT_REPLY: /* REPLY */
117                 return;
118
119         case LNET_EVENT_SEND: /* active message */
120                 if (msg->msg_type == LNET_MSG_PUT) {
121                         ev->pt_index   = le32_to_cpu(hdr->msg.put.ptl_index);
122                         ev->match_bits = le64_to_cpu(hdr->msg.put.match_bits);
123                         ev->offset     = le32_to_cpu(hdr->msg.put.offset);
124                         ev->mlength    =
125                         ev->rlength    = le32_to_cpu(hdr->payload_length);
126                         ev->hdr_data   = le64_to_cpu(hdr->msg.put.hdr_data);
127
128                 } else {
129                         LASSERT(msg->msg_type == LNET_MSG_GET);
130                         ev->pt_index   = le32_to_cpu(hdr->msg.get.ptl_index);
131                         ev->match_bits = le64_to_cpu(hdr->msg.get.match_bits);
132                         ev->mlength    =
133                         ev->rlength    = le32_to_cpu(hdr->msg.get.sink_length);
134                         ev->offset     = le32_to_cpu(hdr->msg.get.src_offset);
135                         ev->hdr_data   = 0;
136                 }
137                 return;
138         }
139 }
140
141 void
142 lnet_msg_commit(struct lnet_msg *msg, int cpt)
143 {
144         struct lnet_msg_container *container = the_lnet.ln_msg_containers[cpt];
145         struct lnet_counters_common *common;
146         s64 timeout_ns;
147
148         /* set the message deadline */
149         timeout_ns = lnet_transaction_timeout * NSEC_PER_SEC;
150         msg->msg_deadline = ktime_add_ns(ktime_get(), timeout_ns);
151
152         /* routed message can be committed for both receiving and sending */
153         LASSERT(!msg->msg_tx_committed);
154
155         if (msg->msg_sending) {
156                 LASSERT(!msg->msg_receiving);
157                 msg->msg_tx_cpt = cpt;
158                 msg->msg_tx_committed = 1;
159                 if (msg->msg_rx_committed) { /* routed message REPLY */
160                         LASSERT(msg->msg_onactivelist);
161                         return;
162                 }
163         } else {
164                 LASSERT(!msg->msg_sending);
165                 msg->msg_rx_cpt = cpt;
166                 msg->msg_rx_committed = 1;
167         }
168
169         LASSERT(!msg->msg_onactivelist);
170
171         msg->msg_onactivelist = 1;
172         list_add_tail(&msg->msg_activelist, &container->msc_active);
173
174         common = &the_lnet.ln_counters[cpt]->lct_common;
175         common->lcc_msgs_alloc++;
176         if (common->lcc_msgs_alloc > common->lcc_msgs_max)
177                 common->lcc_msgs_max = common->lcc_msgs_alloc;
178 }
179
180 static void
181 lnet_msg_decommit_tx(struct lnet_msg *msg, int status)
182 {
183         struct lnet_counters_common *common;
184         struct lnet_event *ev = &msg->msg_ev;
185
186         LASSERT(msg->msg_tx_committed);
187         if (status != 0)
188                 goto out;
189
190         common = &(the_lnet.ln_counters[msg->msg_tx_cpt]->lct_common);
191         switch (ev->type) {
192         default: /* routed message */
193                 LASSERT(msg->msg_routing);
194                 LASSERT(msg->msg_rx_committed);
195                 LASSERT(ev->type == 0);
196
197                 common->lcc_route_length += msg->msg_len;
198                 common->lcc_route_count++;
199                 goto incr_stats;
200
201         case LNET_EVENT_PUT:
202                 /* should have been decommitted */
203                 LASSERT(!msg->msg_rx_committed);
204                 /* overwritten while sending ACK */
205                 LASSERT(msg->msg_type == LNET_MSG_ACK);
206                 msg->msg_type = LNET_MSG_PUT; /* fix type */
207                 break;
208
209         case LNET_EVENT_SEND:
210                 LASSERT(!msg->msg_rx_committed);
211                 if (msg->msg_type == LNET_MSG_PUT)
212                         common->lcc_send_length += msg->msg_len;
213                 break;
214
215         case LNET_EVENT_GET:
216                 LASSERT(msg->msg_rx_committed);
217                 /* overwritten while sending reply, we should never be
218                  * here for optimized GET */
219                 LASSERT(msg->msg_type == LNET_MSG_REPLY);
220                 msg->msg_type = LNET_MSG_GET; /* fix type */
221                 break;
222         }
223
224         common->lcc_send_count++;
225
226 incr_stats:
227         if (msg->msg_txpeer)
228                 lnet_incr_stats(&msg->msg_txpeer->lpni_stats,
229                                 msg->msg_type,
230                                 LNET_STATS_TYPE_SEND);
231         if (msg->msg_txni)
232                 lnet_incr_stats(&msg->msg_txni->ni_stats,
233                                 msg->msg_type,
234                                 LNET_STATS_TYPE_SEND);
235  out:
236         lnet_return_tx_credits_locked(msg);
237         msg->msg_tx_committed = 0;
238 }
239
240 static void
241 lnet_msg_decommit_rx(struct lnet_msg *msg, int status)
242 {
243         struct lnet_counters_common *common;
244         struct lnet_event *ev = &msg->msg_ev;
245
246         LASSERT(!msg->msg_tx_committed); /* decommitted or never committed */
247         LASSERT(msg->msg_rx_committed);
248
249         if (status != 0)
250                 goto out;
251
252         common = &(the_lnet.ln_counters[msg->msg_rx_cpt]->lct_common);
253         switch (ev->type) {
254         default:
255                 LASSERT(ev->type == 0);
256                 LASSERT(msg->msg_routing);
257                 goto incr_stats;
258
259         case LNET_EVENT_ACK:
260                 LASSERT(msg->msg_type == LNET_MSG_ACK);
261                 break;
262
263         case LNET_EVENT_GET:
264                 /* type is "REPLY" if it's an optimized GET on passive side,
265                  * because optimized GET will never be committed for sending,
266                  * so message type wouldn't be changed back to "GET" by
267                  * lnet_msg_decommit_tx(), see details in lnet_parse_get() */
268                 LASSERT(msg->msg_type == LNET_MSG_REPLY ||
269                         msg->msg_type == LNET_MSG_GET);
270                 common->lcc_send_length += msg->msg_wanted;
271                 break;
272
273         case LNET_EVENT_PUT:
274                 LASSERT(msg->msg_type == LNET_MSG_PUT);
275                 break;
276
277         case LNET_EVENT_REPLY:
278                 /* type is "GET" if it's an optimized GET on active side,
279                  * see details in lnet_create_reply_msg() */
280                 LASSERT(msg->msg_type == LNET_MSG_GET ||
281                         msg->msg_type == LNET_MSG_REPLY);
282                 break;
283         }
284
285         common->lcc_recv_count++;
286
287 incr_stats:
288         if (msg->msg_rxpeer)
289                 lnet_incr_stats(&msg->msg_rxpeer->lpni_stats,
290                                 msg->msg_type,
291                                 LNET_STATS_TYPE_RECV);
292         if (msg->msg_rxni)
293                 lnet_incr_stats(&msg->msg_rxni->ni_stats,
294                                 msg->msg_type,
295                                 LNET_STATS_TYPE_RECV);
296         if (ev->type == LNET_EVENT_PUT || ev->type == LNET_EVENT_REPLY)
297                 common->lcc_recv_length += msg->msg_wanted;
298
299  out:
300         lnet_return_rx_credits_locked(msg);
301         msg->msg_rx_committed = 0;
302 }
303
304 void
305 lnet_msg_decommit(struct lnet_msg *msg, int cpt, int status)
306 {
307         int     cpt2 = cpt;
308
309         LASSERT(msg->msg_tx_committed || msg->msg_rx_committed);
310         LASSERT(msg->msg_onactivelist);
311
312         if (msg->msg_tx_committed) { /* always decommit for sending first */
313                 LASSERT(cpt == msg->msg_tx_cpt);
314                 lnet_msg_decommit_tx(msg, status);
315         }
316
317         if (msg->msg_rx_committed) {
318                 /* forwarding msg committed for both receiving and sending */
319                 if (cpt != msg->msg_rx_cpt) {
320                         lnet_net_unlock(cpt);
321                         cpt2 = msg->msg_rx_cpt;
322                         lnet_net_lock(cpt2);
323                 }
324                 lnet_msg_decommit_rx(msg, status);
325         }
326
327         list_del(&msg->msg_activelist);
328         msg->msg_onactivelist = 0;
329
330         the_lnet.ln_counters[cpt2]->lct_common.lcc_msgs_alloc--;
331
332         if (cpt2 != cpt) {
333                 lnet_net_unlock(cpt2);
334                 lnet_net_lock(cpt);
335         }
336 }
337
338 void
339 lnet_msg_attach_md(struct lnet_msg *msg, struct lnet_libmd *md,
340                    unsigned int offset, unsigned int mlen)
341 {
342         /* NB: @offset and @len are only useful for receiving */
343         /* Here, we attach the MD on lnet_msg and mark it busy and
344          * decrementing its threshold. Come what may, the lnet_msg "owns"
345          * the MD until a call to lnet_msg_detach_md or lnet_finalize()
346          * signals completion. */
347         LASSERT(!msg->msg_routing);
348
349         msg->msg_md = md;
350         if (msg->msg_receiving) { /* committed for receiving */
351                 msg->msg_offset = offset;
352                 msg->msg_wanted = mlen;
353         }
354
355         md->md_refcount++;
356         if (md->md_threshold != LNET_MD_THRESH_INF) {
357                 LASSERT(md->md_threshold > 0);
358                 md->md_threshold--;
359         }
360
361         /* build umd in event */
362         lnet_md2handle(&msg->msg_ev.md_handle, md);
363         lnet_md_deconstruct(md, &msg->msg_ev);
364 }
365
366 static int
367 lnet_complete_msg_locked(struct lnet_msg *msg, int cpt)
368 {
369         struct lnet_handle_wire ack_wmd;
370         int                rc;
371         int                status = msg->msg_ev.status;
372
373         LASSERT(msg->msg_onactivelist);
374
375         if (status == 0 && msg->msg_ack) {
376                 /* Only send an ACK if the PUT completed successfully */
377
378                 lnet_msg_decommit(msg, cpt, 0);
379
380                 msg->msg_ack = 0;
381                 lnet_net_unlock(cpt);
382
383                 LASSERT(msg->msg_ev.type == LNET_EVENT_PUT);
384                 LASSERT(!msg->msg_routing);
385
386                 ack_wmd = msg->msg_hdr.msg.put.ack_wmd;
387
388                 lnet_prep_send(msg, LNET_MSG_ACK, msg->msg_ev.source, 0, 0);
389
390                 msg->msg_hdr.msg.ack.dst_wmd = ack_wmd;
391                 msg->msg_hdr.msg.ack.match_bits = msg->msg_ev.match_bits;
392                 msg->msg_hdr.msg.ack.mlength = cpu_to_le32(msg->msg_ev.mlength);
393
394                 rc = lnet_send(msg->msg_ev.target.nid, msg, msg->msg_from);
395
396                 lnet_net_lock(cpt);
397                 /*
398                  * NB: message is committed for sending, we should return
399                  * on success because LND will finalize this message later.
400                  *
401                  * Also, there is possibility that message is committed for
402                  * sending and also failed before delivering to LND,
403                  * i.e: ENOMEM, in that case we can't fall through either
404                  * because CPT for sending can be different with CPT for
405                  * receiving, so we should return back to lnet_finalize()
406                  * to make sure we are locking the correct partition.
407                  */
408                 return rc;
409
410         } else if (status == 0 &&       /* OK so far */
411                    (msg->msg_routing && !msg->msg_sending)) {
412                 /* not forwarded */
413                 LASSERT(!msg->msg_receiving);   /* called back recv already */
414                 lnet_net_unlock(cpt);
415
416                 rc = lnet_send(LNET_NID_ANY, msg, LNET_NID_ANY);
417
418                 lnet_net_lock(cpt);
419                 /*
420                  * NB: message is committed for sending, we should return
421                  * on success because LND will finalize this message later.
422                  *
423                  * Also, there is possibility that message is committed for
424                  * sending and also failed before delivering to LND,
425                  * i.e: ENOMEM, in that case we can't fall through either:
426                  * - The rule is message must decommit for sending first if
427                  *   the it's committed for both sending and receiving
428                  * - CPT for sending can be different with CPT for receiving,
429                  *   so we should return back to lnet_finalize() to make
430                  *   sure we are locking the correct partition.
431                  */
432                 return rc;
433         }
434
435         lnet_msg_decommit(msg, cpt, status);
436         lnet_msg_free(msg);
437         return 0;
438 }
439
440 static void
441 lnet_dec_healthv_locked(atomic_t *healthv, int sensitivity)
442 {
443         int h = atomic_read(healthv);
444
445         if (h < sensitivity) {
446                 atomic_set(healthv, 0);
447         } else {
448                 h -= sensitivity;
449                 atomic_set(healthv, h);
450         }
451 }
452
453 static void
454 lnet_handle_local_failure(struct lnet_ni *local_ni)
455 {
456         /*
457          * the lnet_net_lock(0) is used to protect the addref on the ni
458          * and the recovery queue.
459          */
460         lnet_net_lock(0);
461         /* the mt could've shutdown and cleaned up the queues */
462         if (the_lnet.ln_mt_state != LNET_MT_STATE_RUNNING) {
463                 lnet_net_unlock(0);
464                 return;
465         }
466
467         lnet_dec_healthv_locked(&local_ni->ni_healthv, lnet_health_sensitivity);
468         /*
469          * add the NI to the recovery queue if it's not already there
470          * and it's health value is actually below the maximum. It's
471          * possible that the sensitivity might be set to 0, and the health
472          * value will not be reduced. In this case, there is no reason to
473          * invoke recovery
474          */
475         if (list_empty(&local_ni->ni_recovery) &&
476             atomic_read(&local_ni->ni_healthv) < LNET_MAX_HEALTH_VALUE) {
477                 CDEBUG(D_NET, "ni %s added to recovery queue. Health = %d\n",
478                         libcfs_nid2str(local_ni->ni_nid),
479                         atomic_read(&local_ni->ni_healthv));
480                 list_add_tail(&local_ni->ni_recovery,
481                               &the_lnet.ln_mt_localNIRecovq);
482                 lnet_ni_addref_locked(local_ni, 0);
483         }
484         lnet_net_unlock(0);
485 }
486
487 /* must hold net_lock/0 */
488 void
489 lnet_handle_remote_failure_locked(struct lnet_peer_ni *lpni)
490 {
491         __u32 sensitivity = lnet_health_sensitivity;
492         __u32 lp_sensitivity;
493
494         /*
495          * If there is a health sensitivity in the peer then use that
496          * instead of the globally set one.
497          */
498         lp_sensitivity = lpni->lpni_peer_net->lpn_peer->lp_health_sensitivity;
499         if (lp_sensitivity)
500                 sensitivity = lp_sensitivity;
501
502         lnet_dec_healthv_locked(&lpni->lpni_healthv, sensitivity);
503
504         /* update the peer_net's health value */
505         lnet_update_peer_net_healthv(lpni);
506
507         /*
508          * add the peer NI to the recovery queue if it's not already there
509          * and it's health value is actually below the maximum. It's
510          * possible that the sensitivity might be set to 0, and the health
511          * value will not be reduced. In this case, there is no reason to
512          * invoke recovery
513          */
514         lnet_peer_ni_add_to_recoveryq_locked(lpni,
515                                              &the_lnet.ln_mt_peerNIRecovq,
516                                              ktime_get_seconds());
517 }
518
519 static void
520 lnet_handle_remote_failure(struct lnet_peer_ni *lpni)
521 {
522         /* lpni could be NULL if we're in the LOLND case */
523         if (!lpni)
524                 return;
525
526         lnet_net_lock(0);
527         /* the mt could've shutdown and cleaned up the queues */
528         if (the_lnet.ln_mt_state != LNET_MT_STATE_RUNNING) {
529                 lnet_net_unlock(0);
530                 return;
531         }
532         lnet_handle_remote_failure_locked(lpni);
533         lnet_net_unlock(0);
534 }
535
536 static void
537 lnet_incr_hstats(struct lnet_ni *ni, struct lnet_peer_ni *lpni,
538                  enum lnet_msg_hstatus hstatus)
539 {
540         struct lnet_counters_health *health;
541
542         health = &the_lnet.ln_counters[0]->lct_health;
543
544         switch (hstatus) {
545         case LNET_MSG_STATUS_LOCAL_INTERRUPT:
546                 atomic_inc(&ni->ni_hstats.hlt_local_interrupt);
547                 health->lch_local_interrupt_count++;
548                 break;
549         case LNET_MSG_STATUS_LOCAL_DROPPED:
550                 atomic_inc(&ni->ni_hstats.hlt_local_dropped);
551                 health->lch_local_dropped_count++;
552                 break;
553         case LNET_MSG_STATUS_LOCAL_ABORTED:
554                 atomic_inc(&ni->ni_hstats.hlt_local_aborted);
555                 health->lch_local_aborted_count++;
556                 break;
557         case LNET_MSG_STATUS_LOCAL_NO_ROUTE:
558                 atomic_inc(&ni->ni_hstats.hlt_local_no_route);
559                 health->lch_local_no_route_count++;
560                 break;
561         case LNET_MSG_STATUS_LOCAL_TIMEOUT:
562                 atomic_inc(&ni->ni_hstats.hlt_local_timeout);
563                 health->lch_local_timeout_count++;
564                 break;
565         case LNET_MSG_STATUS_LOCAL_ERROR:
566                 atomic_inc(&ni->ni_hstats.hlt_local_error);
567                 health->lch_local_error_count++;
568                 break;
569         case LNET_MSG_STATUS_REMOTE_DROPPED:
570                 if (lpni)
571                         atomic_inc(&lpni->lpni_hstats.hlt_remote_dropped);
572                 health->lch_remote_dropped_count++;
573                 break;
574         case LNET_MSG_STATUS_REMOTE_ERROR:
575                 if (lpni)
576                         atomic_inc(&lpni->lpni_hstats.hlt_remote_error);
577                 health->lch_remote_error_count++;
578                 break;
579         case LNET_MSG_STATUS_REMOTE_TIMEOUT:
580                 if (lpni)
581                         atomic_inc(&lpni->lpni_hstats.hlt_remote_timeout);
582                 health->lch_remote_timeout_count++;
583                 break;
584         case LNET_MSG_STATUS_NETWORK_TIMEOUT:
585                 if (lpni)
586                         atomic_inc(&lpni->lpni_hstats.hlt_network_timeout);
587                 health->lch_network_timeout_count++;
588                 break;
589         case LNET_MSG_STATUS_OK:
590                 break;
591         default:
592                 LBUG();
593         }
594 }
595
596 static void
597 lnet_resend_msg_locked(struct lnet_msg *msg)
598 {
599         msg->msg_retry_count++;
600
601         /*
602          * remove message from the active list and reset it to prepare
603          * for a resend. Two exceptions to this
604          *
605          * 1. the router case. When a message is being routed it is
606          * committed for rx when received and committed for tx when
607          * forwarded. We don't want to remove it from the active list, since
608          * code which handles receiving expects it to remain on the active
609          * list.
610          *
611          * 2. The REPLY case. Reply messages use the same message
612          * structure for the GET that was received.
613          */
614         if (!msg->msg_routing && msg->msg_type != LNET_MSG_REPLY) {
615                 list_del_init(&msg->msg_activelist);
616                 msg->msg_onactivelist = 0;
617         }
618         /*
619          * The msg_target.nid which was originally set
620          * when calling LNetGet() or LNetPut() might've
621          * been overwritten if we're routing this message.
622          * Call lnet_msg_decommit_tx() to return the credit
623          * this message consumed. The message will
624          * consume another credit when it gets resent.
625          */
626         msg->msg_target.nid = msg->msg_hdr.dest_nid;
627         lnet_msg_decommit_tx(msg, -EAGAIN);
628         msg->msg_sending = 0;
629         msg->msg_receiving = 0;
630         msg->msg_target_is_router = 0;
631
632         CDEBUG(D_NET, "%s->%s:%s:%s - queuing msg (%p) for resend\n",
633                libcfs_nid2str(msg->msg_hdr.src_nid),
634                libcfs_nid2str(msg->msg_hdr.dest_nid),
635                lnet_msgtyp2str(msg->msg_type),
636                lnet_health_error2str(msg->msg_health_status), msg);
637
638         list_add_tail(&msg->msg_list, the_lnet.ln_mt_resendqs[msg->msg_tx_cpt]);
639
640         complete(&the_lnet.ln_mt_wait_complete);
641 }
642
643 int
644 lnet_check_finalize_recursion_locked(struct lnet_msg *msg,
645                                      struct list_head *containerq,
646                                      int nworkers, void **workers)
647 {
648         int my_slot = -1;
649         int i;
650
651         list_add_tail(&msg->msg_list, containerq);
652
653         for (i = 0; i < nworkers; i++) {
654                 if (workers[i] == current)
655                         break;
656
657                 if (my_slot < 0 && workers[i] == NULL)
658                         my_slot = i;
659         }
660
661         if (i < nworkers || my_slot < 0)
662                 return -1;
663
664         workers[my_slot] = current;
665
666         return my_slot;
667 }
668
669 int
670 lnet_attempt_msg_resend(struct lnet_msg *msg)
671 {
672         struct lnet_msg_container *container;
673         int my_slot;
674         int cpt;
675
676         /* we can only resend tx_committed messages */
677         LASSERT(msg->msg_tx_committed);
678
679         /* don't resend recovery messages */
680         if (msg->msg_recovery) {
681                 CDEBUG(D_NET, "msg %s->%s is a recovery ping. retry# %d\n",
682                         libcfs_nid2str(msg->msg_from),
683                         libcfs_nid2str(msg->msg_target.nid),
684                         msg->msg_retry_count);
685                 return -ENOTRECOVERABLE;
686         }
687
688         /*
689          * if we explicitly indicated we don't want to resend then just
690          * return
691          */
692         if (msg->msg_no_resend) {
693                 CDEBUG(D_NET, "msg %s->%s requested no resend. retry# %d\n",
694                         libcfs_nid2str(msg->msg_from),
695                         libcfs_nid2str(msg->msg_target.nid),
696                         msg->msg_retry_count);
697                 return -ENOTRECOVERABLE;
698         }
699
700         /* check if the message has exceeded the number of retries */
701         if (msg->msg_retry_count >= lnet_retry_count) {
702                 CNETERR("msg %s->%s exceeded retry count %d\n",
703                         libcfs_nid2str(msg->msg_from),
704                         libcfs_nid2str(msg->msg_target.nid),
705                         msg->msg_retry_count);
706                 return -ENOTRECOVERABLE;
707         }
708
709         cpt = msg->msg_tx_cpt;
710         lnet_net_lock(cpt);
711
712         /* check again under lock */
713         if (the_lnet.ln_mt_state != LNET_MT_STATE_RUNNING) {
714                 lnet_net_unlock(cpt);
715                 return -ESHUTDOWN;
716         }
717
718         container = the_lnet.ln_msg_containers[cpt];
719         my_slot =
720                 lnet_check_finalize_recursion_locked(msg,
721                                         &container->msc_resending,
722                                         container->msc_nfinalizers,
723                                         container->msc_resenders);
724
725         /* enough threads are resending */
726         if (my_slot == -1) {
727                 lnet_net_unlock(cpt);
728                 return 0;
729         }
730
731         while (!list_empty(&container->msc_resending)) {
732                 msg = list_entry(container->msc_resending.next,
733                                         struct lnet_msg, msg_list);
734                 list_del(&msg->msg_list);
735
736                 /*
737                  * resending the message will require us to call
738                  * lnet_msg_decommit_tx() which will return the credit
739                  * which this message holds. This could trigger another
740                  * queued message to be sent. If that message fails and
741                  * requires a resend we will recurse.
742                  * But since at this point the slot is taken, the message
743                  * will be queued in the container and dealt with
744                  * later. This breaks the recursion.
745                  */
746                 lnet_resend_msg_locked(msg);
747         }
748
749         /*
750          * msc_resenders is an array of process pointers. Each entry holds
751          * a pointer to the current process operating on the message. An
752          * array entry is created per CPT. If the array slot is already
753          * set, then it means that there is a thread on the CPT currently
754          * resending a message.
755          * Once the thread finishes clear the slot to enable the thread to
756          * take on more resend work.
757          */
758         container->msc_resenders[my_slot] = NULL;
759         lnet_net_unlock(cpt);
760
761         return 0;
762 }
763
764 /*
765  * Do a health check on the message:
766  * return -1 if we're not going to handle the error or
767  *   if we've reached the maximum number of retries.
768  *   success case will return -1 as well
769  * return 0 if it the message is requeued for send
770  */
771 static int
772 lnet_health_check(struct lnet_msg *msg)
773 {
774         enum lnet_msg_hstatus hstatus = msg->msg_health_status;
775         struct lnet_peer_ni *lpni;
776         struct lnet_ni *ni;
777         bool lo = false;
778         bool attempt_local_resend;
779         bool attempt_remote_resend;
780         bool handle_local_health;
781         bool handle_remote_health;
782
783         /* if we're shutting down no point in handling health. */
784         if (the_lnet.ln_mt_state != LNET_MT_STATE_RUNNING)
785                 return -1;
786
787         LASSERT(msg->msg_tx_committed || msg->msg_rx_committed);
788
789         /*
790          * if we're sending to the LOLND then the msg_txpeer will not be
791          * set. So no need to sanity check it.
792          */
793         if (msg->msg_tx_committed && msg->msg_txni->ni_nid != LNET_NID_LO_0)
794                 LASSERT(msg->msg_txpeer);
795         else if (msg->msg_tx_committed &&
796                  msg->msg_txni->ni_nid == LNET_NID_LO_0)
797                 lo = true;
798
799         if (hstatus != LNET_MSG_STATUS_OK &&
800             ktime_compare(ktime_get(), msg->msg_deadline) >= 0)
801                 return -1;
802
803         /*
804          * always prefer txni/txpeer if they message is committed for both
805          * directions.
806          */
807         if (msg->msg_tx_committed) {
808                 ni = msg->msg_txni;
809                 lpni = msg->msg_txpeer;
810                 attempt_local_resend = attempt_remote_resend = true;
811         } else {
812                 ni = msg->msg_rxni;
813                 lpni = msg->msg_rxpeer;
814                 attempt_local_resend = attempt_remote_resend = false;
815         }
816
817         /* Don't further decrement the health value if a recovery message
818          * failed.
819          */
820         if (msg->msg_recovery)
821                 handle_local_health = handle_remote_health = false;
822         else
823                 handle_local_health = handle_remote_health = true;
824
825         /* For local failures, health/recovery/resends are not needed if I only
826          * have a single (non-lolnd) interface. NB: pb_nnis includes the lolnd
827          * interface, so a single-rail node would have pb_nnis == 2.
828          */
829         if (the_lnet.ln_ping_target->pb_nnis <= 2) {
830                 handle_local_health = false;
831                 attempt_local_resend = false;
832         }
833
834         /* For remote failures, health/recovery/resends are not needed if the
835          * peer only has a single interface. Special case for routers where we
836          * rely on health feature to manage route aliveness. NB: unlike pb_nnis
837          * above, lp_nnis does _not_ include the lolnd, so a single-rail node
838          * would have lp_nnis == 1.
839          */
840         if (lpni && lpni->lpni_peer_net->lpn_peer->lp_nnis <= 1) {
841                 attempt_remote_resend = false;
842                 if (!lnet_isrouter(lpni))
843                         handle_remote_health = false;
844         }
845
846         if (!lo)
847                 LASSERT(ni && lpni);
848         else
849                 LASSERT(ni);
850
851         CDEBUG(D_NET, "health check: %s->%s: %s: %s\n",
852                libcfs_nid2str(ni->ni_nid),
853                (lo) ? "self" : libcfs_nid2str(lpni->lpni_nid),
854                lnet_msgtyp2str(msg->msg_type),
855                lnet_health_error2str(hstatus));
856
857         /*
858          * stats are only incremented for errors so avoid wasting time
859          * incrementing statistics if there is no error.
860          */
861         if (hstatus != LNET_MSG_STATUS_OK) {
862                 lnet_net_lock(0);
863                 lnet_incr_hstats(ni, lpni, hstatus);
864                 lnet_net_unlock(0);
865         }
866
867         switch (hstatus) {
868         case LNET_MSG_STATUS_OK:
869                 /*
870                  * increment the local ni health weather we successfully
871                  * received or sent a message on it.
872                  */
873                 lnet_inc_healthv(&ni->ni_healthv, lnet_health_sensitivity);
874                 /*
875                  * It's possible msg_txpeer is NULL in the LOLND
876                  * case. Only increment the peer's health if we're
877                  * receiving a message from it. It's the only sure way to
878                  * know that a remote interface is up.
879                  * If this interface is part of a router, then take that
880                  * as indication that the router is fully healthy.
881                  */
882                 if (lpni && msg->msg_rx_committed) {
883                         /*
884                          * If we're receiving a message from the router or
885                          * I'm a router, then set that lpni's health to
886                          * maximum so we can commence communication
887                          */
888                         lnet_net_lock(0);
889                         if (lnet_isrouter(lpni) || the_lnet.ln_routing) {
890                                 lnet_set_lpni_healthv_locked(lpni,
891                                         LNET_MAX_HEALTH_VALUE);
892                         } else {
893                                 __u32 sensitivity = lpni->lpni_peer_net->
894                                         lpn_peer->lp_health_sensitivity;
895
896                                 lnet_inc_lpni_healthv_locked(lpni,
897                                         (sensitivity) ? sensitivity :
898                                         lnet_health_sensitivity);
899                                 /* This peer NI may have previously aged out
900                                  * of recovery. Now that we've received a
901                                  * message from it, we can continue recovery
902                                  * if its health value is still below the
903                                  * maximum.
904                                  */
905                                 lnet_peer_ni_add_to_recoveryq_locked(lpni,
906                                                 &the_lnet.ln_mt_peerNIRecovq,
907                                                 ktime_get_seconds());
908                         }
909                         lnet_net_unlock(0);
910                 }
911
912                 /* we can finalize this message */
913                 return -1;
914         case LNET_MSG_STATUS_LOCAL_INTERRUPT:
915         case LNET_MSG_STATUS_LOCAL_DROPPED:
916         case LNET_MSG_STATUS_LOCAL_ABORTED:
917         case LNET_MSG_STATUS_LOCAL_NO_ROUTE:
918         case LNET_MSG_STATUS_LOCAL_TIMEOUT:
919                 if (handle_local_health)
920                         lnet_handle_local_failure(ni);
921                 if (attempt_local_resend)
922                         return lnet_attempt_msg_resend(msg);
923                 break;
924         case LNET_MSG_STATUS_LOCAL_ERROR:
925                 if (handle_local_health)
926                         lnet_handle_local_failure(ni);
927                 return -1;
928         case LNET_MSG_STATUS_REMOTE_DROPPED:
929                 if (handle_remote_health)
930                         lnet_handle_remote_failure(lpni);
931                 if (attempt_remote_resend)
932                         return lnet_attempt_msg_resend(msg);
933                 break;
934         case LNET_MSG_STATUS_REMOTE_ERROR:
935         case LNET_MSG_STATUS_REMOTE_TIMEOUT:
936                 if (handle_remote_health)
937                         lnet_handle_remote_failure(lpni);
938                 return -1;
939         case LNET_MSG_STATUS_NETWORK_TIMEOUT:
940                 if (handle_remote_health)
941                         lnet_handle_remote_failure(lpni);
942                 if (handle_local_health)
943                         lnet_handle_local_failure(ni);
944                 return -1;
945         default:
946                 LBUG();
947         }
948
949         /* no resend is needed */
950         return -1;
951 }
952
953 static void
954 lnet_msg_detach_md(struct lnet_msg *msg, int status)
955 {
956         struct lnet_libmd *md = msg->msg_md;
957         lnet_handler_t handler = NULL;
958         int cpt = lnet_cpt_of_cookie(md->md_lh.lh_cookie);
959         int unlink;
960
961         lnet_res_lock(cpt);
962         while (md->md_flags & LNET_MD_FLAG_HANDLING)
963                 /* An event handler is running - wait for it to
964                  * complete to avoid races.
965                  */
966                 lnet_md_wait_handling(md, cpt);
967
968         /* Now it's safe to drop my caller's ref */
969         md->md_refcount--;
970         LASSERT(md->md_refcount >= 0);
971
972         unlink = lnet_md_unlinkable(md);
973         if (md->md_handler) {
974                 if ((md->md_flags & LNET_MD_FLAG_ABORTED) && !status) {
975                         msg->msg_ev.status   = -ETIMEDOUT;
976                         CDEBUG(D_NET, "md 0x%p already unlinked\n", md);
977                 } else {
978                         msg->msg_ev.status   = status;
979                 }
980                 msg->msg_ev.unlinked = unlink;
981                 handler = md->md_handler;
982                 if (!unlink)
983                         md->md_flags |= LNET_MD_FLAG_HANDLING;
984         }
985
986         if (unlink || (md->md_refcount == 0 &&
987                        md->md_threshold == LNET_MD_THRESH_INF))
988                 lnet_detach_rsp_tracker(md, cpt);
989
990         msg->msg_md = NULL;
991         if (unlink)
992                 lnet_md_unlink(md);
993
994         lnet_res_unlock(cpt);
995
996         if (handler) {
997                 handler(&msg->msg_ev);
998                 if (!unlink) {
999                         lnet_res_lock(cpt);
1000                         md->md_flags &= ~LNET_MD_FLAG_HANDLING;
1001                         wake_up_var(md);
1002                         lnet_res_unlock(cpt);
1003                 }
1004         }
1005 }
1006
1007 static bool
1008 lnet_is_health_check(struct lnet_msg *msg)
1009 {
1010         bool hc = true;
1011         int status = msg->msg_ev.status;
1012
1013         if ((!msg->msg_tx_committed && !msg->msg_rx_committed) ||
1014             !msg->msg_onactivelist) {
1015                 CDEBUG(D_NET, "msg %p not committed for send or receive\n",
1016                        msg);
1017                 return false;
1018         }
1019
1020         if ((msg->msg_tx_committed && !msg->msg_txpeer) ||
1021             (msg->msg_rx_committed && !msg->msg_rxpeer)) {
1022                 /* The optimized GET case does not set msg_rxpeer, but status
1023                  * could be zero. Only print the error message if we have a
1024                  * non-zero status.
1025                  */
1026                 if (status)
1027                         CDEBUG(D_NET, "msg %p status %d cannot retry\n", msg,
1028                                status);
1029                 return false;
1030         }
1031
1032         /* Check for status inconsistencies */
1033         if ((!status && msg->msg_health_status != LNET_MSG_STATUS_OK) ||
1034              (status && msg->msg_health_status == LNET_MSG_STATUS_OK)) {
1035                 CDEBUG(D_NET, "Msg %p is in inconsistent state, don't perform health "
1036                        "checking (%d, %d)\n", msg, status,
1037                        msg->msg_health_status);
1038                 hc = false;
1039         }
1040
1041         CDEBUG(D_NET, "health check = %d, status = %d, hstatus = %d\n",
1042                hc, status, msg->msg_health_status);
1043
1044         return hc;
1045 }
1046
1047 char *
1048 lnet_health_error2str(enum lnet_msg_hstatus hstatus)
1049 {
1050         switch (hstatus) {
1051         case LNET_MSG_STATUS_LOCAL_INTERRUPT:
1052                 return "LOCAL_INTERRUPT";
1053         case LNET_MSG_STATUS_LOCAL_DROPPED:
1054                 return "LOCAL_DROPPED";
1055         case LNET_MSG_STATUS_LOCAL_ABORTED:
1056                 return "LOCAL_ABORTED";
1057         case LNET_MSG_STATUS_LOCAL_NO_ROUTE:
1058                 return "LOCAL_NO_ROUTE";
1059         case LNET_MSG_STATUS_LOCAL_TIMEOUT:
1060                 return "LOCAL_TIMEOUT";
1061         case LNET_MSG_STATUS_LOCAL_ERROR:
1062                 return "LOCAL_ERROR";
1063         case LNET_MSG_STATUS_REMOTE_DROPPED:
1064                 return "REMOTE_DROPPED";
1065         case LNET_MSG_STATUS_REMOTE_ERROR:
1066                 return "REMOTE_ERROR";
1067         case LNET_MSG_STATUS_REMOTE_TIMEOUT:
1068                 return "REMOTE_TIMEOUT";
1069         case LNET_MSG_STATUS_NETWORK_TIMEOUT:
1070                 return "NETWORK_TIMEOUT";
1071         case LNET_MSG_STATUS_OK:
1072                 return "OK";
1073         default:
1074                 return "<UNKNOWN>";
1075         }
1076 }
1077
1078 bool
1079 lnet_send_error_simulation(struct lnet_msg *msg,
1080                            enum lnet_msg_hstatus *hstatus)
1081 {
1082         if (!msg)
1083                 return false;
1084
1085         if (list_empty(&the_lnet.ln_drop_rules))
1086             return false;
1087
1088         /* match only health rules */
1089         if (!lnet_drop_rule_match(&msg->msg_hdr, LNET_NID_ANY,
1090                                   hstatus))
1091                 return false;
1092
1093         CDEBUG(D_NET, "src %s(%s)->dst %s: %s simulate health error: %s\n",
1094                 libcfs_nid2str(msg->msg_hdr.src_nid),
1095                 libcfs_nid2str(msg->msg_txni->ni_nid),
1096                 libcfs_nid2str(msg->msg_hdr.dest_nid),
1097                 lnet_msgtyp2str(msg->msg_type),
1098                 lnet_health_error2str(*hstatus));
1099
1100         return true;
1101 }
1102 EXPORT_SYMBOL(lnet_send_error_simulation);
1103
1104 void
1105 lnet_finalize(struct lnet_msg *msg, int status)
1106 {
1107         struct lnet_msg_container *container;
1108         int my_slot;
1109         int cpt;
1110         int rc;
1111
1112         LASSERT(!in_interrupt());
1113
1114         if (msg == NULL)
1115                 return;
1116
1117         msg->msg_ev.status = status;
1118
1119         if (lnet_is_health_check(msg)) {
1120                 /*
1121                  * Check the health status of the message. If it has one
1122                  * of the errors that we're supposed to handle, and it has
1123                  * not timed out, then
1124                  *      1. Decrement the appropriate health_value
1125                  *      2. queue the message on the resend queue
1126
1127                  * if the message send is success, timed out or failed in the
1128                  * health check for any reason then we'll just finalize the
1129                  * message. Otherwise just return since the message has been
1130                  * put on the resend queue.
1131                  */
1132                 if (!lnet_health_check(msg))
1133                         return;
1134         }
1135
1136         /*
1137          * We're not going to resend this message so detach its MD and invoke
1138          * the appropriate callbacks
1139          */
1140         if (msg->msg_md != NULL)
1141                 lnet_msg_detach_md(msg, status);
1142
1143 again:
1144         if (!msg->msg_tx_committed && !msg->msg_rx_committed) {
1145                 /* not committed to network yet */
1146                 LASSERT(!msg->msg_onactivelist);
1147                 lnet_msg_free(msg);
1148                 return;
1149         }
1150
1151         /*
1152          * NB: routed message can be committed for both receiving and sending,
1153          * we should finalize in LIFO order and keep counters correct.
1154          * (finalize sending first then finalize receiving)
1155          */
1156         cpt = msg->msg_tx_committed ? msg->msg_tx_cpt : msg->msg_rx_cpt;
1157         lnet_net_lock(cpt);
1158
1159         container = the_lnet.ln_msg_containers[cpt];
1160
1161         /* Recursion breaker.  Don't complete the message here if I am (or
1162          * enough other threads are) already completing messages */
1163         my_slot = lnet_check_finalize_recursion_locked(msg,
1164                                                 &container->msc_finalizing,
1165                                                 container->msc_nfinalizers,
1166                                                 container->msc_finalizers);
1167
1168         /* enough threads are resending */
1169         if (my_slot == -1) {
1170                 lnet_net_unlock(cpt);
1171                 return;
1172         }
1173
1174         rc = 0;
1175         while (!list_empty(&container->msc_finalizing)) {
1176                 msg = list_entry(container->msc_finalizing.next,
1177                                  struct lnet_msg, msg_list);
1178
1179                 list_del_init(&msg->msg_list);
1180
1181                 /* NB drops and regains the lnet lock if it actually does
1182                  * anything, so my finalizing friends can chomp along too */
1183                 rc = lnet_complete_msg_locked(msg, cpt);
1184                 if (rc != 0)
1185                         break;
1186         }
1187
1188         if (unlikely(!list_empty(&the_lnet.ln_delay_rules))) {
1189                 lnet_net_unlock(cpt);
1190                 lnet_delay_rule_check();
1191                 lnet_net_lock(cpt);
1192         }
1193
1194         container->msc_finalizers[my_slot] = NULL;
1195         lnet_net_unlock(cpt);
1196
1197         if (rc != 0)
1198                 goto again;
1199 }
1200 EXPORT_SYMBOL(lnet_finalize);
1201
1202 void
1203 lnet_msg_container_cleanup(struct lnet_msg_container *container)
1204 {
1205         int     count = 0;
1206
1207         if (container->msc_init == 0)
1208                 return;
1209
1210         while (!list_empty(&container->msc_active)) {
1211                 struct lnet_msg *msg;
1212
1213                 msg  = list_entry(container->msc_active.next,
1214                                   struct lnet_msg, msg_activelist);
1215                 LASSERT(msg->msg_onactivelist);
1216                 msg->msg_onactivelist = 0;
1217                 list_del_init(&msg->msg_activelist);
1218                 lnet_msg_free(msg);
1219                 count++;
1220         }
1221
1222         if (count > 0)
1223                 CERROR("%d active msg on exit\n", count);
1224
1225         if (container->msc_finalizers != NULL) {
1226                 CFS_FREE_PTR_ARRAY(container->msc_finalizers,
1227                                    container->msc_nfinalizers);
1228                 container->msc_finalizers = NULL;
1229         }
1230
1231         if (container->msc_resenders != NULL) {
1232                 CFS_FREE_PTR_ARRAY(container->msc_resenders,
1233                                    container->msc_nfinalizers);
1234                 container->msc_resenders = NULL;
1235         }
1236         container->msc_init = 0;
1237 }
1238
1239 int
1240 lnet_msg_container_setup(struct lnet_msg_container *container, int cpt)
1241 {
1242         int rc = 0;
1243
1244         container->msc_init = 1;
1245
1246         INIT_LIST_HEAD(&container->msc_active);
1247         INIT_LIST_HEAD(&container->msc_finalizing);
1248         INIT_LIST_HEAD(&container->msc_resending);
1249
1250         /* number of CPUs */
1251         container->msc_nfinalizers = cfs_cpt_weight(lnet_cpt_table(), cpt);
1252         if (container->msc_nfinalizers == 0)
1253                 container->msc_nfinalizers = 1;
1254
1255         LIBCFS_CPT_ALLOC(container->msc_finalizers, lnet_cpt_table(), cpt,
1256                          container->msc_nfinalizers *
1257                          sizeof(*container->msc_finalizers));
1258
1259         if (container->msc_finalizers == NULL) {
1260                 CERROR("Failed to allocate message finalizers\n");
1261                 lnet_msg_container_cleanup(container);
1262                 return -ENOMEM;
1263         }
1264
1265         LIBCFS_CPT_ALLOC(container->msc_resenders, lnet_cpt_table(), cpt,
1266                          container->msc_nfinalizers *
1267                          sizeof(*container->msc_resenders));
1268
1269         if (container->msc_resenders == NULL) {
1270                 CERROR("Failed to allocate message resenders\n");
1271                 lnet_msg_container_cleanup(container);
1272                 return -ENOMEM;
1273         }
1274
1275         return rc;
1276 }
1277
1278 void
1279 lnet_msg_containers_destroy(void)
1280 {
1281         struct lnet_msg_container *container;
1282         int     i;
1283
1284         if (the_lnet.ln_msg_containers == NULL)
1285                 return;
1286
1287         cfs_percpt_for_each(container, i, the_lnet.ln_msg_containers)
1288                 lnet_msg_container_cleanup(container);
1289
1290         cfs_percpt_free(the_lnet.ln_msg_containers);
1291         the_lnet.ln_msg_containers = NULL;
1292 }
1293
1294 int
1295 lnet_msg_containers_create(void)
1296 {
1297         struct lnet_msg_container *container;
1298         int     rc;
1299         int     i;
1300
1301         the_lnet.ln_msg_containers = cfs_percpt_alloc(lnet_cpt_table(),
1302                                                       sizeof(*container));
1303
1304         if (the_lnet.ln_msg_containers == NULL) {
1305                 CERROR("Failed to allocate cpu-partition data for network\n");
1306                 return -ENOMEM;
1307         }
1308
1309         cfs_percpt_for_each(container, i, the_lnet.ln_msg_containers) {
1310                 rc = lnet_msg_container_setup(container, i);
1311                 if (rc != 0) {
1312                         lnet_msg_containers_destroy();
1313                         return rc;
1314                 }
1315         }
1316
1317         return 0;
1318 }