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