Whamcloud - gitweb
LU-6142 lnet: use list_first_entry() in lnet/lnet subdirectory.
[fs/lustre-release.git] / lnet / lnet / lib-ptl.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, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 021110-1307, USA
20  *
21  * GPL HEADER END
22  */
23 /*
24  * Copyright (c) 2012, 2017, Intel Corporation.
25  */
26 /*
27  * This file is part of Lustre, http://www.lustre.org/
28  *
29  * lnet/lnet/lib-ptl.c
30  *
31  * portal & match routines
32  *
33  * Author: liang@whamcloud.com
34  */
35
36 #define DEBUG_SUBSYSTEM S_LNET
37
38 #include <lnet/lib-lnet.h>
39
40 /* NB: add /proc interfaces in upcoming patches */
41 int portal_rotor = LNET_PTL_ROTOR_HASH_RT;
42 module_param(portal_rotor, int, 0644);
43 MODULE_PARM_DESC(portal_rotor, "redirect PUTs to different cpu-partitions");
44
45 static int
46 lnet_ptl_match_type(unsigned int index, struct lnet_processid *match_id,
47                     __u64 mbits, __u64 ignore_bits)
48 {
49         struct lnet_portal      *ptl = the_lnet.ln_portals[index];
50         int                     unique;
51
52         unique = (ignore_bits == 0 &&
53                   !LNET_NID_IS_ANY(&match_id->nid) &&
54                   match_id->pid != LNET_PID_ANY);
55
56         LASSERT(!lnet_ptl_is_unique(ptl) || !lnet_ptl_is_wildcard(ptl));
57
58         /* prefer to check w/o any lock */
59         if (likely(lnet_ptl_is_unique(ptl) || lnet_ptl_is_wildcard(ptl)))
60                 goto match;
61
62         /* unset, new portal */
63         lnet_ptl_lock(ptl);
64         /* check again with lock */
65         if (unlikely(lnet_ptl_is_unique(ptl) || lnet_ptl_is_wildcard(ptl))) {
66                 lnet_ptl_unlock(ptl);
67                 goto match;
68         }
69
70         /* still not set */
71         if (unique)
72                 lnet_ptl_setopt(ptl, LNET_PTL_MATCH_UNIQUE);
73         else
74                 lnet_ptl_setopt(ptl, LNET_PTL_MATCH_WILDCARD);
75
76         lnet_ptl_unlock(ptl);
77
78         return 1;
79
80  match:
81         if ((lnet_ptl_is_unique(ptl) && !unique) ||
82             (lnet_ptl_is_wildcard(ptl) && unique))
83                 return 0;
84         return 1;
85 }
86
87 static void
88 lnet_ptl_enable_mt(struct lnet_portal *ptl, int cpt)
89 {
90         struct lnet_match_table *mtable = ptl->ptl_mtables[cpt];
91         int                     i;
92
93         /* with hold of both lnet_res_lock(cpt) and lnet_ptl_lock */
94         LASSERT(lnet_ptl_is_wildcard(ptl));
95
96         mtable->mt_enabled = 1;
97
98         ptl->ptl_mt_maps[ptl->ptl_mt_nmaps] = cpt;
99         for (i = ptl->ptl_mt_nmaps - 1; i >= 0; i--) {
100                 LASSERT(ptl->ptl_mt_maps[i] != cpt);
101                 if (ptl->ptl_mt_maps[i] < cpt)
102                         break;
103
104                 /* swap to order */
105                 ptl->ptl_mt_maps[i + 1] = ptl->ptl_mt_maps[i];
106                 ptl->ptl_mt_maps[i] = cpt;
107         }
108
109         ptl->ptl_mt_nmaps++;
110 }
111
112 static void
113 lnet_ptl_disable_mt(struct lnet_portal *ptl, int cpt)
114 {
115         struct lnet_match_table *mtable = ptl->ptl_mtables[cpt];
116         int                     i;
117
118         /* with hold of both lnet_res_lock(cpt) and lnet_ptl_lock */
119         LASSERT(lnet_ptl_is_wildcard(ptl));
120
121         if (LNET_CPT_NUMBER == 1)
122                 return; /* never disable the only match-table */
123
124         mtable->mt_enabled = 0;
125
126         LASSERT(ptl->ptl_mt_nmaps > 0 &&
127                 ptl->ptl_mt_nmaps <= LNET_CPT_NUMBER);
128
129         /* remove it from mt_maps */
130         ptl->ptl_mt_nmaps--;
131         for (i = 0; i < ptl->ptl_mt_nmaps; i++) {
132                 if (ptl->ptl_mt_maps[i] >= cpt) /* overwrite it */
133                         ptl->ptl_mt_maps[i] = ptl->ptl_mt_maps[i + 1];
134         }
135 }
136
137 static int
138 lnet_try_match_md(struct lnet_libmd *md,
139                   struct lnet_match_info *info, struct lnet_msg *msg)
140 {
141         /* ALWAYS called holding the lnet_res_lock, and can't lnet_res_unlock;
142          * lnet_match_blocked_msg() relies on this to avoid races */
143         unsigned int    offset;
144         unsigned int    mlength;
145         struct lnet_me  *me = md->md_me;
146
147         /* MD exhausted */
148         if (lnet_md_exhausted(md))
149                 return LNET_MATCHMD_NONE | LNET_MATCHMD_EXHAUSTED;
150
151         /* mismatched MD op */
152         if ((md->md_options & info->mi_opc) == 0)
153                 return LNET_MATCHMD_NONE;
154
155         /* mismatched ME nid/pid? */
156         if (!LNET_NID_IS_ANY(&me->me_match_id.nid) &&
157             !nid_same(&me->me_match_id.nid, &info->mi_id.nid))
158                 return LNET_MATCHMD_NONE;
159
160         if (me->me_match_id.pid != LNET_PID_ANY &&
161             me->me_match_id.pid != info->mi_id.pid)
162                 return LNET_MATCHMD_NONE;
163
164         /* mismatched ME matchbits? */
165         if (((me->me_match_bits ^ info->mi_mbits) & ~me->me_ignore_bits) != 0)
166                 return LNET_MATCHMD_NONE;
167
168         /* Hurrah! This _is_ a match; check it out... */
169
170         if ((md->md_options & LNET_MD_MANAGE_REMOTE) == 0)
171                 offset = md->md_offset;
172         else
173                 offset = info->mi_roffset;
174
175         if ((md->md_options & LNET_MD_MAX_SIZE) != 0) {
176                 mlength = md->md_max_size;
177                 LASSERT(md->md_offset + mlength <= md->md_length);
178         } else {
179                 mlength = md->md_length - offset;
180         }
181
182         if (info->mi_rlength <= mlength) {      /* fits in allowed space */
183                 mlength = info->mi_rlength;
184         } else if ((md->md_options & LNET_MD_TRUNCATE) == 0) {
185                 /* this packet _really_ is too big */
186                 CERROR("Matching packet from %s, match %llu"
187                        " length %d too big: %d left, %d allowed\n",
188                        libcfs_idstr(&info->mi_id), info->mi_mbits,
189                        info->mi_rlength, md->md_length - offset, mlength);
190
191                 return LNET_MATCHMD_DROP;
192         }
193
194         /* Commit to this ME/MD */
195         CDEBUG(D_NET, "Incoming %s index %x from %s of "
196                "length %d/%d into md %#llx [%d] + %d\n",
197                (info->mi_opc == LNET_MD_OP_PUT) ? "put" : "get",
198                info->mi_portal, libcfs_idstr(&info->mi_id), mlength,
199                info->mi_rlength, md->md_lh.lh_cookie, md->md_niov, offset);
200
201         lnet_msg_attach_md(msg, md, offset, mlength);
202         md->md_offset = offset + mlength;
203
204         if (!lnet_md_exhausted(md))
205                 return LNET_MATCHMD_OK;
206
207         /* Auto-unlink NOW, so the ME gets unlinked if required.
208          * We bumped md->md_refcount above so the MD just gets flagged
209          * for unlink when it is finalized. */
210         if ((md->md_flags & LNET_MD_FLAG_AUTO_UNLINK) != 0)
211                 lnet_md_unlink(md);
212
213         return LNET_MATCHMD_OK | LNET_MATCHMD_EXHAUSTED;
214 }
215
216 static struct lnet_match_table *
217 lnet_match2mt(struct lnet_portal *ptl, struct lnet_processid *id, __u64 mbits)
218 {
219         if (LNET_CPT_NUMBER == 1)
220                 return ptl->ptl_mtables[0]; /* the only one */
221
222         /* if it's a unique portal, return match-table hashed by NID */
223         return lnet_ptl_is_unique(ptl) ?
224                ptl->ptl_mtables[lnet_nid2cpt(&id->nid, NULL)] : NULL;
225 }
226
227 struct lnet_match_table *
228 lnet_mt_of_attach(unsigned int index, struct lnet_processid *id,
229                   __u64 mbits, __u64 ignore_bits, enum lnet_ins_pos pos)
230 {
231         struct lnet_portal      *ptl;
232         struct lnet_match_table *mtable;
233
234         /* NB: called w/o lock */
235         LASSERT(index < the_lnet.ln_nportals);
236
237         if (!lnet_ptl_match_type(index, id, mbits, ignore_bits))
238                 return NULL;
239
240         ptl = the_lnet.ln_portals[index];
241
242         mtable = lnet_match2mt(ptl, id, mbits);
243         if (mtable != NULL) /* unique portal or only one match-table */
244                 return mtable;
245
246         /* it's a wildcard portal */
247         switch (pos) {
248         default:
249                 return NULL;
250         case LNET_INS_BEFORE:
251         case LNET_INS_AFTER:
252                 /* posted by no affinity thread, always hash to specific
253                  * match-table to avoid buffer stealing which is heavy */
254                 return ptl->ptl_mtables[ptl->ptl_index % LNET_CPT_NUMBER];
255         case LNET_INS_LOCAL:
256                 /* posted by cpu-affinity thread */
257                 return ptl->ptl_mtables[lnet_cpt_current()];
258         }
259 }
260
261 static struct lnet_match_table *
262 lnet_mt_of_match(struct lnet_match_info *info, struct lnet_msg *msg)
263 {
264         struct lnet_match_table *mtable;
265         struct lnet_portal      *ptl;
266         unsigned int            nmaps;
267         unsigned int            rotor;
268         unsigned int            cpt;
269         bool                    routed;
270
271         /* NB: called w/o lock */
272         LASSERT(info->mi_portal < the_lnet.ln_nportals);
273         ptl = the_lnet.ln_portals[info->mi_portal];
274
275         LASSERT(lnet_ptl_is_wildcard(ptl) || lnet_ptl_is_unique(ptl));
276
277         mtable = lnet_match2mt(ptl, &info->mi_id, info->mi_mbits);
278         if (mtable != NULL)
279                 return mtable;
280
281         /* it's a wildcard portal */
282         routed = LNET_NID_NET(&msg->msg_hdr.src_nid) !=
283                  LNET_NID_NET(&msg->msg_hdr.dest_nid);
284
285         if (portal_rotor == LNET_PTL_ROTOR_OFF ||
286             (portal_rotor != LNET_PTL_ROTOR_ON && !routed)) {
287                 cpt = lnet_cpt_current();
288                 if (ptl->ptl_mtables[cpt]->mt_enabled)
289                         return ptl->ptl_mtables[cpt];
290         }
291
292         rotor = ptl->ptl_rotor++; /* get round-robin factor */
293         if (portal_rotor == LNET_PTL_ROTOR_HASH_RT && routed)
294                 cpt = info->mi_cpt;
295         else
296                 cpt = rotor % LNET_CPT_NUMBER;
297
298         if (!ptl->ptl_mtables[cpt]->mt_enabled) {
299                 /* is there any active entry for this portal? */
300                 nmaps = ptl->ptl_mt_nmaps;
301                 /* map to an active mtable to avoid heavy "stealing" */
302                 if (nmaps != 0) {
303                         /* NB: there is possibility that ptl_mt_maps is being
304                          * changed because we are not under protection of
305                          * lnet_ptl_lock, but it shouldn't hurt anything */
306                         cpt = ptl->ptl_mt_maps[rotor % nmaps];
307                 }
308         }
309
310         return ptl->ptl_mtables[cpt];
311 }
312
313 static int
314 lnet_mt_test_exhausted(struct lnet_match_table *mtable, int pos)
315 {
316         __u64   *bmap;
317         int     i;
318
319         if (!lnet_ptl_is_wildcard(the_lnet.ln_portals[mtable->mt_portal]))
320                 return 0;
321
322         if (pos < 0) { /* check all bits */
323                 for (i = 0; i < LNET_MT_EXHAUSTED_BMAP; i++) {
324                         if (mtable->mt_exhausted[i] != (__u64)(-1))
325                                 return 0;
326                 }
327                 return 1;
328         }
329
330         LASSERT(pos <= LNET_MT_HASH_IGNORE);
331         /* mtable::mt_mhash[pos] is marked as exhausted or not */
332         bmap = &mtable->mt_exhausted[pos >> LNET_MT_BITS_U64];
333         pos &= (1 << LNET_MT_BITS_U64) - 1;
334
335         return ((*bmap) & (1ULL << pos)) != 0;
336 }
337
338 static void
339 lnet_mt_set_exhausted(struct lnet_match_table *mtable, int pos, int exhausted)
340 {
341         __u64   *bmap;
342
343         LASSERT(lnet_ptl_is_wildcard(the_lnet.ln_portals[mtable->mt_portal]));
344         LASSERT(pos <= LNET_MT_HASH_IGNORE);
345
346         /* set mtable::mt_mhash[pos] as exhausted/non-exhausted */
347         bmap = &mtable->mt_exhausted[pos >> LNET_MT_BITS_U64];
348         pos &= (1 << LNET_MT_BITS_U64) - 1;
349
350         if (!exhausted)
351                 *bmap &= ~(1ULL << pos);
352         else
353                 *bmap |= 1ULL << pos;
354 }
355
356 struct list_head *
357 lnet_mt_match_head(struct lnet_match_table *mtable,
358                    struct lnet_processid *id, __u64 mbits)
359 {
360         struct lnet_portal *ptl = the_lnet.ln_portals[mtable->mt_portal];
361
362         if (lnet_ptl_is_wildcard(ptl)) {
363                 return &mtable->mt_mhash[mbits & LNET_MT_HASH_MASK];
364         } else {
365                 unsigned long hash = mbits + nidhash(&id->nid) + id->pid;
366
367                 LASSERT(lnet_ptl_is_unique(ptl));
368                 hash = hash_long(hash, LNET_MT_HASH_BITS);
369                 return &mtable->mt_mhash[hash & LNET_MT_HASH_MASK];
370         }
371 }
372
373 int
374 lnet_mt_match_md(struct lnet_match_table *mtable,
375                  struct lnet_match_info *info, struct lnet_msg *msg)
376 {
377         struct list_head        *head;
378         struct lnet_me          *me;
379         struct lnet_me          *tmp;
380         int                     exhausted = 0;
381         int                     rc;
382
383         /* any ME with ignore bits? */
384         if (!list_empty(&mtable->mt_mhash[LNET_MT_HASH_IGNORE]))
385                 head = &mtable->mt_mhash[LNET_MT_HASH_IGNORE];
386         else
387                 head = lnet_mt_match_head(mtable, &info->mi_id,
388                                           info->mi_mbits);
389  again:
390         /* NB: only wildcard portal needs to return LNET_MATCHMD_EXHAUSTED */
391         if (lnet_ptl_is_wildcard(the_lnet.ln_portals[mtable->mt_portal]))
392                 exhausted = LNET_MATCHMD_EXHAUSTED;
393
394         list_for_each_entry_safe(me, tmp, head, me_list) {
395                 /* ME attached but MD not attached yet */
396                 if (me->me_md == NULL)
397                         continue;
398
399                 LASSERT(me == me->me_md->md_me);
400
401                 rc = lnet_try_match_md(me->me_md, info, msg);
402                 if ((rc & LNET_MATCHMD_EXHAUSTED) == 0)
403                         exhausted = 0; /* mlist is not empty */
404
405                 if ((rc & LNET_MATCHMD_FINISH) != 0) {
406                         /* don't return EXHAUSTED bit because we don't know
407                          * whether the mlist is empty or not */
408                         return rc & ~LNET_MATCHMD_EXHAUSTED;
409                 }
410         }
411
412         if (exhausted == LNET_MATCHMD_EXHAUSTED) { /* @head is exhausted */
413                 lnet_mt_set_exhausted(mtable, head - mtable->mt_mhash, 1);
414                 if (!lnet_mt_test_exhausted(mtable, -1))
415                         exhausted = 0;
416         }
417
418         if (exhausted == 0 && head == &mtable->mt_mhash[LNET_MT_HASH_IGNORE]) {
419                 head = lnet_mt_match_head(mtable, &info->mi_id,
420                                           info->mi_mbits);
421                 goto again; /* re-check MEs w/o ignore-bits */
422         }
423
424         if (info->mi_opc == LNET_MD_OP_GET ||
425             !lnet_ptl_is_lazy(the_lnet.ln_portals[info->mi_portal]))
426                 return LNET_MATCHMD_DROP | exhausted;
427
428         return LNET_MATCHMD_NONE | exhausted;
429 }
430
431 static int
432 lnet_ptl_match_early(struct lnet_portal *ptl, struct lnet_msg *msg)
433 {
434         int     rc;
435
436         /* message arrived before any buffer posting on this portal,
437          * simply delay or drop this message */
438         if (likely(lnet_ptl_is_wildcard(ptl) || lnet_ptl_is_unique(ptl)))
439                 return 0;
440
441         lnet_ptl_lock(ptl);
442         /* check it again with hold of lock */
443         if (lnet_ptl_is_wildcard(ptl) || lnet_ptl_is_unique(ptl)) {
444                 lnet_ptl_unlock(ptl);
445                 return 0;
446         }
447
448         if (lnet_ptl_is_lazy(ptl)) {
449                 if (msg->msg_rx_ready_delay) {
450                         msg->msg_rx_delayed = 1;
451                         list_add_tail(&msg->msg_list,
452                                       &ptl->ptl_msg_delayed);
453                 }
454                 rc = LNET_MATCHMD_NONE;
455         } else {
456                 rc = LNET_MATCHMD_DROP;
457         }
458
459         lnet_ptl_unlock(ptl);
460         return rc;
461 }
462
463 static int
464 lnet_ptl_match_delay(struct lnet_portal *ptl,
465                      struct lnet_match_info *info, struct lnet_msg *msg)
466 {
467         int     first = ptl->ptl_mt_maps[0]; /* read w/o lock */
468         int     rc = 0;
469         int     i;
470
471         /*
472          * Steal buffer from other CPTs, and delay msg if nothing to
473          * steal.  This function is more expensive than a regular
474          * match, but we don't expect it can happen a lot. The return
475          * code contains one of LNET_MATCHMD_OK, LNET_MATCHMD_DROP, or
476          * LNET_MATCHMD_NONE.
477          */
478         LASSERT(lnet_ptl_is_wildcard(ptl));
479
480         for (i = 0; i < LNET_CPT_NUMBER; i++) {
481                 struct lnet_match_table *mtable;
482                 int                     cpt;
483
484                 cpt = (first + i) % LNET_CPT_NUMBER;
485                 mtable = ptl->ptl_mtables[cpt];
486                 if (i != 0 && i != LNET_CPT_NUMBER - 1 && !mtable->mt_enabled)
487                         continue;
488
489                 lnet_res_lock(cpt);
490                 lnet_ptl_lock(ptl);
491
492                 if (i == 0) {
493                         /* The first try, add to stealing list. */
494                         list_add_tail(&msg->msg_list,
495                                       &ptl->ptl_msg_stealing);
496                 }
497
498                 if (!list_empty(&msg->msg_list)) {
499                         /* On stealing list. */
500                         rc = lnet_mt_match_md(mtable, info, msg);
501
502                         if ((rc & LNET_MATCHMD_EXHAUSTED) != 0 &&
503                             mtable->mt_enabled)
504                                 lnet_ptl_disable_mt(ptl, cpt);
505
506                         if ((rc & LNET_MATCHMD_FINISH) != 0) {
507                                 /* Match found, remove from stealing list. */
508                                 list_del_init(&msg->msg_list);
509                         } else if (i == LNET_CPT_NUMBER - 1 || /* (1) */
510                                    ptl->ptl_mt_nmaps == 0 ||   /* (2) */
511                                    (ptl->ptl_mt_nmaps == 1 &&  /* (3) */
512                                     ptl->ptl_mt_maps[0] == cpt)) {
513                                 /*
514                                  * No match found, and this is either
515                                  * (1) the last cpt to check, or
516                                  * (2) there is no active cpt, or
517                                  * (3) this is the only active cpt.
518                                  * There is nothing to steal: delay or
519                                  * drop the message.
520                                  */
521                                 list_del_init(&msg->msg_list);
522
523                                 if (lnet_ptl_is_lazy(ptl)) {
524                                         msg->msg_rx_delayed = 1;
525                                         list_add_tail(&msg->msg_list,
526                                                       &ptl->ptl_msg_delayed);
527                                         rc = LNET_MATCHMD_NONE;
528                                 } else {
529                                         rc = LNET_MATCHMD_DROP;
530                                 }
531                         } else {
532                                 /* Do another iteration. */
533                                 rc = 0;
534                         }
535                 } else {
536                         /*
537                          * No longer on stealing list: another thread
538                          * matched the message in lnet_ptl_attach_md().
539                          * We are now expected to handle the message.
540                          */
541                         rc = msg->msg_md == NULL ?
542                                 LNET_MATCHMD_DROP : LNET_MATCHMD_OK;
543                 }
544
545                 lnet_ptl_unlock(ptl);
546                 lnet_res_unlock(cpt);
547
548                 /*
549                  * Note that test (1) above ensures that we always
550                  * exit the loop through this break statement.
551                  *
552                  * LNET_MATCHMD_NONE means msg was added to the
553                  * delayed queue, and we may no longer reference it
554                  * after lnet_ptl_unlock() and lnet_res_unlock().
555                  */
556                 if (rc & (LNET_MATCHMD_FINISH | LNET_MATCHMD_NONE))
557                         break;
558         }
559
560         return rc;
561 }
562
563 int
564 lnet_ptl_match_md(struct lnet_match_info *info, struct lnet_msg *msg)
565 {
566         struct lnet_match_table *mtable;
567         struct lnet_portal      *ptl;
568         int                     rc;
569
570         CDEBUG(D_NET,
571                "Request from %s of length %d into portal %d MB=%#llx\n",
572                libcfs_idstr(&info->mi_id),
573                info->mi_rlength, info->mi_portal, info->mi_mbits);
574
575         if (info->mi_portal >= the_lnet.ln_nportals) {
576                 CERROR("Invalid portal %d not in [0-%d]\n",
577                        info->mi_portal, the_lnet.ln_nportals);
578                 return LNET_MATCHMD_DROP;
579         }
580
581         ptl = the_lnet.ln_portals[info->mi_portal];
582         rc = lnet_ptl_match_early(ptl, msg);
583         if (rc != 0) /* matched or delayed early message */
584                 return rc;
585
586         mtable = lnet_mt_of_match(info, msg);
587         lnet_res_lock(mtable->mt_cpt);
588
589         if (the_lnet.ln_state != LNET_STATE_RUNNING) {
590                 rc = LNET_MATCHMD_DROP;
591                 goto out1;
592         }
593
594         rc = lnet_mt_match_md(mtable, info, msg);
595         if ((rc & LNET_MATCHMD_EXHAUSTED) != 0 && mtable->mt_enabled) {
596                 lnet_ptl_lock(ptl);
597                 lnet_ptl_disable_mt(ptl, mtable->mt_cpt);
598                 lnet_ptl_unlock(ptl);
599         }
600
601         if ((rc & LNET_MATCHMD_FINISH) != 0)    /* matched or dropping */
602                 goto out1;
603
604         if (!msg->msg_rx_ready_delay)
605                 goto out1;
606
607         LASSERT(lnet_ptl_is_lazy(ptl));
608         LASSERT(!msg->msg_rx_delayed);
609
610         /* NB: we don't expect "delay" can happen a lot */
611         if (lnet_ptl_is_unique(ptl) || LNET_CPT_NUMBER == 1) {
612                 lnet_ptl_lock(ptl);
613
614                 msg->msg_rx_delayed = 1;
615                 list_add_tail(&msg->msg_list, &ptl->ptl_msg_delayed);
616
617                 lnet_ptl_unlock(ptl);
618                 lnet_res_unlock(mtable->mt_cpt);
619                 rc = LNET_MATCHMD_NONE;
620         } else  {
621                 lnet_res_unlock(mtable->mt_cpt);
622                 rc = lnet_ptl_match_delay(ptl, info, msg);
623         }
624
625         /* LNET_MATCHMD_NONE means msg was added to the delay queue */
626         if (rc & LNET_MATCHMD_NONE) {
627                 CDEBUG(D_NET,
628                        "Delaying %s from %s ptl %d MB %#llx off %d len %d\n",
629                        info->mi_opc == LNET_MD_OP_PUT ? "PUT" : "GET",
630                        libcfs_idstr(&info->mi_id), info->mi_portal,
631                        info->mi_mbits, info->mi_roffset, info->mi_rlength);
632         }
633         goto out0;
634  out1:
635         lnet_res_unlock(mtable->mt_cpt);
636  out0:
637         /* EXHAUSTED bit is only meaningful for internal functions */
638         return rc & ~LNET_MATCHMD_EXHAUSTED;
639 }
640
641 void
642 lnet_ptl_detach_md(struct lnet_me *me, struct lnet_libmd *md)
643 {
644         LASSERT(me->me_md == md && md->md_me == me);
645
646         me->me_md = NULL;
647         md->md_me = NULL;
648 }
649
650 /* called with lnet_res_lock held */
651 void
652 lnet_ptl_attach_md(struct lnet_me *me, struct lnet_libmd *md,
653                    struct list_head *matches, struct list_head *drops)
654 {
655         struct lnet_portal *ptl = the_lnet.ln_portals[me->me_portal];
656         struct lnet_match_table *mtable;
657         struct list_head *head;
658         struct lnet_msg *tmp;
659         struct lnet_msg *msg;
660         int exhausted = 0;
661         int cpt;
662
663         LASSERT(md->md_refcount == 0); /* a brand new MD */
664
665         me->me_md = md;
666         md->md_me = me;
667
668         cpt = lnet_cpt_of_cookie(md->md_lh.lh_cookie);
669         mtable = ptl->ptl_mtables[cpt];
670
671         if (list_empty(&ptl->ptl_msg_stealing) &&
672             list_empty(&ptl->ptl_msg_delayed) &&
673             !lnet_mt_test_exhausted(mtable, me->me_pos))
674                 return;
675
676         lnet_ptl_lock(ptl);
677         head = &ptl->ptl_msg_stealing;
678  again:
679         list_for_each_entry_safe(msg, tmp, head, msg_list) {
680                 struct lnet_match_info  info;
681                 struct lnet_hdr         *hdr;
682                 int                     rc;
683
684                 LASSERT(msg->msg_rx_delayed || head == &ptl->ptl_msg_stealing);
685
686                 hdr   = &msg->msg_hdr;
687                 /* Multi-Rail: Primary peer NID */
688                 info.mi_id.nid  = msg->msg_initiator;
689                 info.mi_id.pid  = hdr->src_pid;
690                 info.mi_opc     = LNET_MD_OP_PUT;
691                 info.mi_portal  = hdr->msg.put.ptl_index;
692                 info.mi_rlength = hdr->payload_length;
693                 info.mi_roffset = hdr->msg.put.offset;
694                 info.mi_mbits   = hdr->msg.put.match_bits;
695
696                 rc = lnet_try_match_md(md, &info, msg);
697
698                 exhausted = (rc & LNET_MATCHMD_EXHAUSTED) != 0;
699                 if ((rc & LNET_MATCHMD_NONE) != 0) {
700                         if (exhausted)
701                                 break;
702                         continue;
703                 }
704
705                 /* Hurrah! This _is_ a match */
706                 LASSERT((rc & LNET_MATCHMD_FINISH) != 0);
707                 list_del_init(&msg->msg_list);
708
709                 if (head == &ptl->ptl_msg_stealing) {
710                         if (exhausted)
711                                 break;
712                         /* stealing thread will handle the message */
713                         continue;
714                 }
715
716                 if ((rc & LNET_MATCHMD_OK) != 0) {
717                         list_add_tail(&msg->msg_list, matches);
718
719                         CDEBUG(D_NET, "Resuming delayed PUT from %s portal %d "
720                                "match %llu offset %d length %d.\n",
721                                libcfs_idstr(&info.mi_id),
722                                info.mi_portal, info.mi_mbits,
723                                info.mi_roffset, info.mi_rlength);
724                 } else {
725                         list_add_tail(&msg->msg_list, drops);
726                 }
727
728                 if (exhausted)
729                         break;
730         }
731
732         if (!exhausted && head == &ptl->ptl_msg_stealing) {
733                 head = &ptl->ptl_msg_delayed;
734                 goto again;
735         }
736
737         if (lnet_ptl_is_wildcard(ptl) && !exhausted) {
738                 lnet_mt_set_exhausted(mtable, me->me_pos, 0);
739                 if (!mtable->mt_enabled)
740                         lnet_ptl_enable_mt(ptl, cpt);
741         }
742
743         lnet_ptl_unlock(ptl);
744 }
745
746 static void
747 lnet_ptl_cleanup(struct lnet_portal *ptl)
748 {
749         struct lnet_match_table *mtable;
750         int                     i;
751
752         if (ptl->ptl_mtables == NULL) /* uninitialized portal */
753                 return;
754
755         LASSERT(list_empty(&ptl->ptl_msg_delayed));
756         LASSERT(list_empty(&ptl->ptl_msg_stealing));
757         cfs_percpt_for_each(mtable, i, ptl->ptl_mtables) {
758                 struct list_head *mhash;
759                 struct lnet_me   *me;
760                 int               j;
761
762                 if (mtable->mt_mhash == NULL) /* uninitialized match-table */
763                         continue;
764
765                 mhash = mtable->mt_mhash;
766                 /* cleanup ME */
767                 for (j = 0; j < LNET_MT_HASH_SIZE + 1; j++) {
768                         while ((me = list_first_entry_or_null(&mhash[j],
769                                                               struct lnet_me,
770                                                               me_list)) != NULL) {
771                                 CERROR("Active ME %p on exit\n", me);
772                                 list_del(&me->me_list);
773                                 CDEBUG(D_MALLOC,
774                                        "slab-freed 'me' at %p in cleanup.\n",
775                                        me);
776                                 kmem_cache_free(lnet_mes_cachep, me);
777                         }
778                 }
779                 /* the extra entry is for MEs with ignore bits */
780                 CFS_FREE_PTR_ARRAY(mhash, LNET_MT_HASH_SIZE + 1);
781         }
782
783         cfs_percpt_free(ptl->ptl_mtables);
784         ptl->ptl_mtables = NULL;
785 }
786
787 static int
788 lnet_ptl_setup(struct lnet_portal *ptl, int index)
789 {
790         struct lnet_match_table *mtable;
791         struct list_head        *mhash;
792         int                     i;
793         int                     j;
794
795         ptl->ptl_mtables = cfs_percpt_alloc(lnet_cpt_table(),
796                                             sizeof(struct lnet_match_table));
797         if (ptl->ptl_mtables == NULL) {
798                 CERROR("Failed to create match table for portal %d\n", index);
799                 return -ENOMEM;
800         }
801
802         ptl->ptl_index = index;
803         INIT_LIST_HEAD(&ptl->ptl_msg_delayed);
804         INIT_LIST_HEAD(&ptl->ptl_msg_stealing);
805         spin_lock_init(&ptl->ptl_lock);
806         cfs_percpt_for_each(mtable, i, ptl->ptl_mtables) {
807                 /* the extra entry is for MEs with ignore bits */
808                 LIBCFS_CPT_ALLOC(mhash, lnet_cpt_table(), i,
809                                  sizeof(*mhash) * (LNET_MT_HASH_SIZE + 1));
810                 if (mhash == NULL) {
811                         CERROR("Failed to create match hash for portal %d\n",
812                                index);
813                         goto failed;
814                 }
815
816                 memset(&mtable->mt_exhausted[0], -1,
817                        sizeof(mtable->mt_exhausted[0]) *
818                        LNET_MT_EXHAUSTED_BMAP);
819                 mtable->mt_mhash = mhash;
820                 for (j = 0; j < LNET_MT_HASH_SIZE + 1; j++)
821                         INIT_LIST_HEAD(&mhash[j]);
822
823                 mtable->mt_portal = index;
824                 mtable->mt_cpt = i;
825         }
826
827         return 0;
828  failed:
829         lnet_ptl_cleanup(ptl);
830         return -ENOMEM;
831 }
832
833 #define PORTAL_SIZE (offsetof(struct lnet_portal, ptl_mt_maps[LNET_CPT_NUMBER]))
834 void
835 lnet_portals_destroy(void)
836 {
837         int     i;
838
839         if (the_lnet.ln_portals == NULL)
840                 return;
841
842         for (i = 0; i < the_lnet.ln_nportals; i++)
843                 if (the_lnet.ln_portals[i]) {
844                         lnet_ptl_cleanup(the_lnet.ln_portals[i]);
845                         LIBCFS_FREE(the_lnet.ln_portals[i], PORTAL_SIZE);
846                 }
847
848         CFS_FREE_PTR_ARRAY(the_lnet.ln_portals, the_lnet.ln_nportals);
849         the_lnet.ln_portals = NULL;
850 }
851
852 int
853 lnet_portals_create(void)
854 {
855         int     i;
856
857         the_lnet.ln_nportals = MAX_PORTALS;
858         CFS_ALLOC_PTR_ARRAY(the_lnet.ln_portals, the_lnet.ln_nportals);
859         if (the_lnet.ln_portals == NULL) {
860                 CERROR("Failed to allocate portals table\n");
861                 return -ENOMEM;
862         }
863
864         for (i = 0; i < the_lnet.ln_nportals; i++) {
865                 LIBCFS_ALLOC(the_lnet.ln_portals[i], PORTAL_SIZE);
866                 if (!the_lnet.ln_portals[i] ||
867                     lnet_ptl_setup(the_lnet.ln_portals[i], i)) {
868                         lnet_portals_destroy();
869                         return -ENOMEM;
870                 }
871         }
872
873         return 0;
874 }
875
876 /**
877  * Turn on the lazy portal attribute. Use with caution!
878  *
879  * This portal attribute only affects incoming PUT requests to the portal,
880  * and is off by default. By default, if there's no matching MD for an
881  * incoming PUT request, it is simply dropped. With the lazy attribute on,
882  * such requests are queued indefinitely until either a matching MD is
883  * posted to the portal or the lazy attribute is turned off.
884  *
885  * It would prevent dropped requests, however it should be regarded as the
886  * last line of defense - i.e. users must keep a close watch on active
887  * buffers on a lazy portal and once it becomes too low post more buffers as
888  * soon as possible. This is because delayed requests usually have detrimental
889  * effects on underlying network connections. A few delayed requests often
890  * suffice to bring an underlying connection to a complete halt, due to flow
891  * control mechanisms.
892  *
893  * There's also a DOS attack risk. If users don't post match-all MDs on a
894  * lazy portal, a malicious peer can easily stop a service by sending some
895  * PUT requests with match bits that won't match any MD. A routed server is
896  * especially vulnerable since the connections to its neighbor routers are
897  * shared among all clients.
898  *
899  * \param portal Index of the portal to enable the lazy attribute on.
900  *
901  * \retval 0       On success.
902  * \retval -EINVAL If \a portal is not a valid index.
903  */
904 int
905 LNetSetLazyPortal(int portal)
906 {
907         struct lnet_portal *ptl;
908
909         if (portal < 0 || portal >= the_lnet.ln_nportals)
910                 return -EINVAL;
911
912         CDEBUG(D_NET, "Setting portal %d lazy\n", portal);
913         ptl = the_lnet.ln_portals[portal];
914
915         lnet_res_lock(LNET_LOCK_EX);
916         lnet_ptl_lock(ptl);
917
918         lnet_ptl_setopt(ptl, LNET_PTL_LAZY);
919
920         lnet_ptl_unlock(ptl);
921         lnet_res_unlock(LNET_LOCK_EX);
922
923         return 0;
924 }
925 EXPORT_SYMBOL(LNetSetLazyPortal);
926
927 int
928 lnet_clear_lazy_portal(struct lnet_ni *ni, int portal, char *reason)
929 {
930         struct lnet_portal      *ptl;
931         LIST_HEAD(zombies);
932
933         if (portal < 0 || portal >= the_lnet.ln_nportals)
934                 return -EINVAL;
935
936         ptl = the_lnet.ln_portals[portal];
937
938         lnet_res_lock(LNET_LOCK_EX);
939         lnet_ptl_lock(ptl);
940
941         if (!lnet_ptl_is_lazy(ptl)) {
942                 lnet_ptl_unlock(ptl);
943                 lnet_res_unlock(LNET_LOCK_EX);
944                 return 0;
945         }
946
947         if (ni != NULL) {
948                 struct lnet_msg *msg, *tmp;
949
950                 /* grab all messages which are on the NI passed in */
951                 list_for_each_entry_safe(msg, tmp, &ptl->ptl_msg_delayed,
952                                          msg_list) {
953                         if (msg->msg_txni == ni || msg->msg_rxni == ni)
954                                 list_move(&msg->msg_list, &zombies);
955                 }
956         } else {
957                 if (the_lnet.ln_state != LNET_STATE_RUNNING)
958                         CWARN("Active lazy portal %d on exit\n", portal);
959                 else
960                         CDEBUG(D_NET, "clearing portal %d lazy\n", portal);
961
962                 /* grab all the blocked messages atomically */
963                 list_splice_init(&ptl->ptl_msg_delayed, &zombies);
964
965                 lnet_ptl_unsetopt(ptl, LNET_PTL_LAZY);
966         }
967
968         lnet_ptl_unlock(ptl);
969         lnet_res_unlock(LNET_LOCK_EX);
970
971         lnet_drop_delayed_msg_list(&zombies, reason);
972
973         return 0;
974 }
975
976 /**
977  * Turn off the lazy portal attribute. Delayed requests on the portal,
978  * if any, will be all dropped when this function returns.
979  *
980  * \param portal Index of the portal to disable the lazy attribute on.
981  *
982  * \retval 0       On success.
983  * \retval -EINVAL If \a portal is not a valid index.
984  */
985 int
986 LNetClearLazyPortal(int portal)
987 {
988         return lnet_clear_lazy_portal(NULL, portal,
989                                       "Clearing lazy portal attr");
990 }
991 EXPORT_SYMBOL(LNetClearLazyPortal);