projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'ntb-3.15' of git://github.com/jonmason/ntb
[deliverable/linux.git] / drivers / staging / lustre / 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, Intel Corporation.
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 <linux/lnet/lib-lnet.h>
40
41 /* NB: add /proc interfaces in upcoming patches */
42 int portal_rotor = LNET_PTL_ROTOR_HASH_RT;
43 module_param(portal_rotor, int, 0644);
44 MODULE_PARM_DESC(portal_rotor, "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 struct list_head *
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 = 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 struct list_head *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 (!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 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 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 list_add_tail(&msg->msg_list,
489 &ptl->ptl_msg_stealing);
490 }
491
492 if (!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 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 (!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 list_del_init(&msg->msg_list);
516
517 if (lnet_ptl_is_lazy(ptl)) {
518 msg->msg_rx_delayed = 1;
519 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 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 struct list_head *matches, struct list_head *drops)
626 {
627 struct lnet_portal *ptl = the_lnet.ln_portals[me->me_portal];
628 struct lnet_match_table *mtable;
629 struct list_head *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 (list_empty(&ptl->ptl_msg_stealing) &&
644 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 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 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 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 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(list_empty(&ptl->ptl_msg_delayed));
727 LASSERT(list_empty(&ptl->ptl_msg_stealing));
728 cfs_percpt_for_each(mtable, i, ptl->ptl_mtables) {
729 struct list_head *mhash;
730 lnet_me_t *me;
731 int j;
732
733 if (mtable->mt_mhash == NULL) /* uninitialized match-table */
734 continue;
735
736 mhash = mtable->mt_mhash;
737 /* cleanup ME */
738 for (j = 0; j < LNET_MT_HASH_SIZE + 1; j++) {
739 while (!list_empty(&mhash[j])) {
740 me = list_entry(mhash[j].next,
741 lnet_me_t, me_list);
742 CERROR("Active ME %p on exit\n", me);
743 list_del(&me->me_list);
744 lnet_me_free(me);
745 }
746 }
747 /* the extra entry is for MEs with ignore bits */
748 LIBCFS_FREE(mhash, sizeof(*mhash) * (LNET_MT_HASH_SIZE + 1));
749 }
750
751 cfs_percpt_free(ptl->ptl_mtables);
752 ptl->ptl_mtables = NULL;
753 }
754
755 int
756 lnet_ptl_setup(struct lnet_portal *ptl, int index)
757 {
758 struct lnet_match_table *mtable;
759 struct list_head *mhash;
760 int i;
761 int j;
762
763 ptl->ptl_mtables = cfs_percpt_alloc(lnet_cpt_table(),
764 sizeof(struct lnet_match_table));
765 if (ptl->ptl_mtables == NULL) {
766 CERROR("Failed to create match table for portal %d\n", index);
767 return -ENOMEM;
768 }
769
770 ptl->ptl_index = index;
771 INIT_LIST_HEAD(&ptl->ptl_msg_delayed);
772 INIT_LIST_HEAD(&ptl->ptl_msg_stealing);
773 spin_lock_init(&ptl->ptl_lock);
774 cfs_percpt_for_each(mtable, i, ptl->ptl_mtables) {
775 /* the extra entry is for MEs with ignore bits */
776 LIBCFS_CPT_ALLOC(mhash, lnet_cpt_table(), i,
777 sizeof(*mhash) * (LNET_MT_HASH_SIZE + 1));
778 if (mhash == NULL) {
779 CERROR("Failed to create match hash for portal %d\n",
780 index);
781 goto failed;
782 }
783
784 memset(&mtable->mt_exhausted[0], -1,
785 sizeof(mtable->mt_exhausted[0]) *
786 LNET_MT_EXHAUSTED_BMAP);
787 mtable->mt_mhash = mhash;
788 for (j = 0; j < LNET_MT_HASH_SIZE + 1; j++)
789 INIT_LIST_HEAD(&mhash[j]);
790
791 mtable->mt_portal = index;
792 mtable->mt_cpt = i;
793 }
794
795 return 0;
796 failed:
797 lnet_ptl_cleanup(ptl);
798 return -ENOMEM;
799 }
800
801 void
802 lnet_portals_destroy(void)
803 {
804 int i;
805
806 if (the_lnet.ln_portals == NULL)
807 return;
808
809 for (i = 0; i < the_lnet.ln_nportals; i++)
810 lnet_ptl_cleanup(the_lnet.ln_portals[i]);
811
812 cfs_array_free(the_lnet.ln_portals);
813 the_lnet.ln_portals = NULL;
814 }
815
816 int
817 lnet_portals_create(void)
818 {
819 int size;
820 int i;
821
822 size = offsetof(struct lnet_portal, ptl_mt_maps[LNET_CPT_NUMBER]);
823
824 the_lnet.ln_nportals = MAX_PORTALS;
825 the_lnet.ln_portals = cfs_array_alloc(the_lnet.ln_nportals, size);
826 if (the_lnet.ln_portals == NULL) {
827 CERROR("Failed to allocate portals table\n");
828 return -ENOMEM;
829 }
830
831 for (i = 0; i < the_lnet.ln_nportals; i++) {
832 if (lnet_ptl_setup(the_lnet.ln_portals[i], i)) {
833 lnet_portals_destroy();
834 return -ENOMEM;
835 }
836 }
837
838 return 0;
839 }
840
841 /**
842 * Turn on the lazy portal attribute. Use with caution!
843 *
844 * This portal attribute only affects incoming PUT requests to the portal,
845 * and is off by default. By default, if there's no matching MD for an
846 * incoming PUT request, it is simply dropped. With the lazy attribute on,
847 * such requests are queued indefinitely until either a matching MD is
848 * posted to the portal or the lazy attribute is turned off.
849 *
850 * It would prevent dropped requests, however it should be regarded as the
851 * last line of defense - i.e. users must keep a close watch on active
852 * buffers on a lazy portal and once it becomes too low post more buffers as
853 * soon as possible. This is because delayed requests usually have detrimental
854 * effects on underlying network connections. A few delayed requests often
855 * suffice to bring an underlying connection to a complete halt, due to flow
856 * control mechanisms.
857 *
858 * There's also a DOS attack risk. If users don't post match-all MDs on a
859 * lazy portal, a malicious peer can easily stop a service by sending some
860 * PUT requests with match bits that won't match any MD. A routed server is
861 * especially vulnerable since the connections to its neighbor routers are
862 * shared among all clients.
863 *
864 * \param portal Index of the portal to enable the lazy attribute on.
865 *
866 * \retval 0 On success.
867 * \retval -EINVAL If \a portal is not a valid index.
868 */
869 int
870 LNetSetLazyPortal(int portal)
871 {
872 struct lnet_portal *ptl;
873
874 if (portal < 0 || portal >= the_lnet.ln_nportals)
875 return -EINVAL;
876
877 CDEBUG(D_NET, "Setting portal %d lazy\n", portal);
878 ptl = the_lnet.ln_portals[portal];
879
880 lnet_res_lock(LNET_LOCK_EX);
881 lnet_ptl_lock(ptl);
882
883 lnet_ptl_setopt(ptl, LNET_PTL_LAZY);
884
885 lnet_ptl_unlock(ptl);
886 lnet_res_unlock(LNET_LOCK_EX);
887
888 return 0;
889 }
890 EXPORT_SYMBOL(LNetSetLazyPortal);
891
892 /**
893 * Turn off the lazy portal attribute. Delayed requests on the portal,
894 * if any, will be all dropped when this function returns.
895 *
896 * \param portal Index of the portal to disable the lazy attribute on.
897 *
898 * \retval 0 On success.
899 * \retval -EINVAL If \a portal is not a valid index.
900 */
901 int
902 LNetClearLazyPortal(int portal)
903 {
904 struct lnet_portal *ptl;
905 LIST_HEAD (zombies);
906
907 if (portal < 0 || portal >= the_lnet.ln_nportals)
908 return -EINVAL;
909
910 ptl = the_lnet.ln_portals[portal];
911
912 lnet_res_lock(LNET_LOCK_EX);
913 lnet_ptl_lock(ptl);
914
915 if (!lnet_ptl_is_lazy(ptl)) {
916 lnet_ptl_unlock(ptl);
917 lnet_res_unlock(LNET_LOCK_EX);
918 return 0;
919 }
920
921 if (the_lnet.ln_shutdown)
922 CWARN("Active lazy portal %d on exit\n", portal);
923 else
924 CDEBUG(D_NET, "clearing portal %d lazy\n", portal);
925
926 /* grab all the blocked messages atomically */
927 list_splice_init(&ptl->ptl_msg_delayed, &zombies);
928
929 lnet_ptl_unsetopt(ptl, LNET_PTL_LAZY);
930
931 lnet_ptl_unlock(ptl);
932 lnet_res_unlock(LNET_LOCK_EX);
933
934 lnet_drop_delayed_msg_list(&zombies, "Clearing lazy portal attr");
935
936 return 0;
937 }
938 EXPORT_SYMBOL(LNetClearLazyPortal);
Linux kernel - Deliverables
This page took 0.061811 seconds and 6 git commands to generate.