1/* 2 * GPL HEADER START 3 * 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 only, 8 * as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License version 2 for more details (a copy is included 14 * in the LICENSE file that accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License 17 * version 2 along with this program; If not, see 18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf 19 * 20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 21 * CA 95054 USA or visit www.sun.com if you need additional information or 22 * have any questions. 23 * 24 * GPL HEADER END 25 */ 26/* 27 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 28 * Use is subject to license terms. 29 * 30 * Copyright (c) 2012, Intel Corporation. 31 */ 32/* 33 * This file is part of Lustre, http://www.lustre.org/ 34 * Lustre is a trademark of Sun Microsystems, Inc. 35 * 36 * lnet/include/lnet/lib-lnet.h 37 * 38 * Top level include for library side routines 39 */ 40 41#ifndef __LNET_LIB_LNET_H__ 42#define __LNET_LIB_LNET_H__ 43 44#include "linux/lib-lnet.h" 45#include "../libcfs/libcfs.h" 46#include "types.h" 47#include "lnet.h" 48#include "lib-types.h" 49 50extern lnet_t the_lnet; /* THE network */ 51 52#if defined(LNET_USE_LIB_FREELIST) 53/* 1 CPT, simplify implementation... */ 54# define LNET_CPT_MAX_BITS 0 55 56#else /* KERNEL and no freelist */ 57 58# if (BITS_PER_LONG == 32) 59/* 2 CPTs, allowing more CPTs might make us under memory pressure */ 60# define LNET_CPT_MAX_BITS 1 61 62# else /* 64-bit system */ 63/* 64 * 256 CPTs for thousands of CPUs, allowing more CPTs might make us 65 * under risk of consuming all lh_cookie. 66 */ 67# define LNET_CPT_MAX_BITS 8 68# endif /* BITS_PER_LONG == 32 */ 69#endif 70 71/* max allowed CPT number */ 72#define LNET_CPT_MAX (1 << LNET_CPT_MAX_BITS) 73 74#define LNET_CPT_NUMBER (the_lnet.ln_cpt_number) 75#define LNET_CPT_BITS (the_lnet.ln_cpt_bits) 76#define LNET_CPT_MASK ((1ULL << LNET_CPT_BITS) - 1) 77 78/** exclusive lock */ 79#define LNET_LOCK_EX CFS_PERCPT_LOCK_EX 80 81static inline int lnet_is_wire_handle_none(lnet_handle_wire_t *wh) 82{ 83 return (wh->wh_interface_cookie == LNET_WIRE_HANDLE_COOKIE_NONE && 84 wh->wh_object_cookie == LNET_WIRE_HANDLE_COOKIE_NONE); 85} 86 87static inline int lnet_md_exhausted(lnet_libmd_t *md) 88{ 89 return (md->md_threshold == 0 || 90 ((md->md_options & LNET_MD_MAX_SIZE) != 0 && 91 md->md_offset + md->md_max_size > md->md_length)); 92} 93 94static inline int lnet_md_unlinkable(lnet_libmd_t *md) 95{ 96 /* Should unlink md when its refcount is 0 and either: 97 * - md has been flagged for deletion (by auto unlink or 98 * LNetM[DE]Unlink, in the latter case md may not be exhausted). 99 * - auto unlink is on and md is exhausted. 100 */ 101 if (md->md_refcount != 0) 102 return 0; 103 104 if ((md->md_flags & LNET_MD_FLAG_ZOMBIE) != 0) 105 return 1; 106 107 return ((md->md_flags & LNET_MD_FLAG_AUTO_UNLINK) != 0 && 108 lnet_md_exhausted(md)); 109} 110 111#define lnet_cpt_table() (the_lnet.ln_cpt_table) 112#define lnet_cpt_current() cfs_cpt_current(the_lnet.ln_cpt_table, 1) 113 114static inline int 115lnet_cpt_of_cookie(__u64 cookie) 116{ 117 unsigned int cpt = (cookie >> LNET_COOKIE_TYPE_BITS) & LNET_CPT_MASK; 118 119 /* LNET_CPT_NUMBER doesn't have to be power2, which means we can 120 * get illegal cpt from it's invalid cookie */ 121 return cpt < LNET_CPT_NUMBER ? cpt : cpt % LNET_CPT_NUMBER; 122} 123 124static inline void 125lnet_res_lock(int cpt) 126{ 127 cfs_percpt_lock(the_lnet.ln_res_lock, cpt); 128} 129 130static inline void 131lnet_res_unlock(int cpt) 132{ 133 cfs_percpt_unlock(the_lnet.ln_res_lock, cpt); 134} 135 136static inline int 137lnet_res_lock_current(void) 138{ 139 int cpt = lnet_cpt_current(); 140 141 lnet_res_lock(cpt); 142 return cpt; 143} 144 145static inline void 146lnet_net_lock(int cpt) 147{ 148 cfs_percpt_lock(the_lnet.ln_net_lock, cpt); 149} 150 151static inline void 152lnet_net_unlock(int cpt) 153{ 154 cfs_percpt_unlock(the_lnet.ln_net_lock, cpt); 155} 156 157static inline int 158lnet_net_lock_current(void) 159{ 160 int cpt = lnet_cpt_current(); 161 162 lnet_net_lock(cpt); 163 return cpt; 164} 165 166#define LNET_LOCK() lnet_net_lock(LNET_LOCK_EX) 167#define LNET_UNLOCK() lnet_net_unlock(LNET_LOCK_EX) 168 169#define lnet_ptl_lock(ptl) spin_lock(&(ptl)->ptl_lock) 170#define lnet_ptl_unlock(ptl) spin_unlock(&(ptl)->ptl_lock) 171#define lnet_eq_wait_lock() spin_lock(&the_lnet.ln_eq_wait_lock) 172#define lnet_eq_wait_unlock() spin_unlock(&the_lnet.ln_eq_wait_lock) 173#define lnet_ni_lock(ni) spin_lock(&(ni)->ni_lock) 174#define lnet_ni_unlock(ni) spin_unlock(&(ni)->ni_lock) 175#define LNET_MUTEX_LOCK(m) mutex_lock(m) 176#define LNET_MUTEX_UNLOCK(m) mutex_unlock(m) 177 178#define MAX_PORTALS 64 179 180/* these are only used by code with LNET_USE_LIB_FREELIST, but we still 181 * exported them to !LNET_USE_LIB_FREELIST for easy implementation */ 182#define LNET_FL_MAX_MES 2048 183#define LNET_FL_MAX_MDS 2048 184#define LNET_FL_MAX_EQS 512 185#define LNET_FL_MAX_MSGS 2048 /* Outstanding messages */ 186 187#ifdef LNET_USE_LIB_FREELIST 188 189int lnet_freelist_init(lnet_freelist_t *fl, int n, int size); 190void lnet_freelist_fini(lnet_freelist_t *fl); 191 192static inline void * 193lnet_freelist_alloc(lnet_freelist_t *fl) 194{ 195 /* ALWAYS called with liblock held */ 196 lnet_freeobj_t *o; 197 198 if (list_empty(&fl->fl_list)) 199 return NULL; 200 201 o = list_entry(fl->fl_list.next, lnet_freeobj_t, fo_list); 202 list_del(&o->fo_list); 203 return (void *)&o->fo_contents; 204} 205 206static inline void 207lnet_freelist_free(lnet_freelist_t *fl, void *obj) 208{ 209 /* ALWAYS called with liblock held */ 210 lnet_freeobj_t *o = list_entry(obj, lnet_freeobj_t, fo_contents); 211 212 list_add(&o->fo_list, &fl->fl_list); 213} 214 215static inline lnet_eq_t * 216lnet_eq_alloc(void) 217{ 218 /* NEVER called with resource lock held */ 219 struct lnet_res_container *rec = &the_lnet.ln_eq_container; 220 lnet_eq_t *eq; 221 222 LASSERT(LNET_CPT_NUMBER == 1); 223 224 lnet_res_lock(0); 225 eq = (lnet_eq_t *)lnet_freelist_alloc(&rec->rec_freelist); 226 lnet_res_unlock(0); 227 228 return eq; 229} 230 231static inline void 232lnet_eq_free_locked(lnet_eq_t *eq) 233{ 234 /* ALWAYS called with resource lock held */ 235 struct lnet_res_container *rec = &the_lnet.ln_eq_container; 236 237 LASSERT(LNET_CPT_NUMBER == 1); 238 lnet_freelist_free(&rec->rec_freelist, eq); 239} 240 241static inline void 242lnet_eq_free(lnet_eq_t *eq) 243{ 244 lnet_res_lock(0); 245 lnet_eq_free_locked(eq); 246 lnet_res_unlock(0); 247} 248 249static inline lnet_libmd_t * 250lnet_md_alloc(lnet_md_t *umd) 251{ 252 /* NEVER called with resource lock held */ 253 struct lnet_res_container *rec = the_lnet.ln_md_containers[0]; 254 lnet_libmd_t *md; 255 256 LASSERT(LNET_CPT_NUMBER == 1); 257 258 lnet_res_lock(0); 259 md = (lnet_libmd_t *)lnet_freelist_alloc(&rec->rec_freelist); 260 lnet_res_unlock(0); 261 262 if (md != NULL) 263 INIT_LIST_HEAD(&md->md_list); 264 265 return md; 266} 267 268static inline void 269lnet_md_free_locked(lnet_libmd_t *md) 270{ 271 /* ALWAYS called with resource lock held */ 272 struct lnet_res_container *rec = the_lnet.ln_md_containers[0]; 273 274 LASSERT(LNET_CPT_NUMBER == 1); 275 lnet_freelist_free(&rec->rec_freelist, md); 276} 277 278static inline void 279lnet_md_free(lnet_libmd_t *md) 280{ 281 lnet_res_lock(0); 282 lnet_md_free_locked(md); 283 lnet_res_unlock(0); 284} 285 286static inline lnet_me_t * 287lnet_me_alloc(void) 288{ 289 /* NEVER called with resource lock held */ 290 struct lnet_res_container *rec = the_lnet.ln_me_containers[0]; 291 lnet_me_t *me; 292 293 LASSERT(LNET_CPT_NUMBER == 1); 294 295 lnet_res_lock(0); 296 me = (lnet_me_t *)lnet_freelist_alloc(&rec->rec_freelist); 297 lnet_res_unlock(0); 298 299 return me; 300} 301 302static inline void 303lnet_me_free_locked(lnet_me_t *me) 304{ 305 /* ALWAYS called with resource lock held */ 306 struct lnet_res_container *rec = the_lnet.ln_me_containers[0]; 307 308 LASSERT(LNET_CPT_NUMBER == 1); 309 lnet_freelist_free(&rec->rec_freelist, me); 310} 311 312static inline void 313lnet_me_free(lnet_me_t *me) 314{ 315 lnet_res_lock(0); 316 lnet_me_free_locked(me); 317 lnet_res_unlock(0); 318} 319 320static inline lnet_msg_t * 321lnet_msg_alloc(void) 322{ 323 /* NEVER called with network lock held */ 324 struct lnet_msg_container *msc = the_lnet.ln_msg_containers[0]; 325 lnet_msg_t *msg; 326 327 LASSERT(LNET_CPT_NUMBER == 1); 328 329 lnet_net_lock(0); 330 msg = (lnet_msg_t *)lnet_freelist_alloc(&msc->msc_freelist); 331 lnet_net_unlock(0); 332 333 if (msg != NULL) { 334 /* NULL pointers, clear flags etc */ 335 memset(msg, 0, sizeof(*msg)); 336 } 337 return msg; 338} 339 340static inline void 341lnet_msg_free_locked(lnet_msg_t *msg) 342{ 343 /* ALWAYS called with network lock held */ 344 struct lnet_msg_container *msc = the_lnet.ln_msg_containers[0]; 345 346 LASSERT(LNET_CPT_NUMBER == 1); 347 LASSERT(!msg->msg_onactivelist); 348 lnet_freelist_free(&msc->msc_freelist, msg); 349} 350 351static inline void 352lnet_msg_free(lnet_msg_t *msg) 353{ 354 lnet_net_lock(0); 355 lnet_msg_free_locked(msg); 356 lnet_net_unlock(0); 357} 358 359#else /* !LNET_USE_LIB_FREELIST */ 360 361static inline lnet_eq_t * 362lnet_eq_alloc(void) 363{ 364 /* NEVER called with liblock held */ 365 lnet_eq_t *eq; 366 367 LIBCFS_ALLOC(eq, sizeof(*eq)); 368 return eq; 369} 370 371static inline void 372lnet_eq_free(lnet_eq_t *eq) 373{ 374 /* ALWAYS called with resource lock held */ 375 LIBCFS_FREE(eq, sizeof(*eq)); 376} 377 378static inline lnet_libmd_t * 379lnet_md_alloc(lnet_md_t *umd) 380{ 381 /* NEVER called with liblock held */ 382 lnet_libmd_t *md; 383 unsigned int size; 384 unsigned int niov; 385 386 if ((umd->options & LNET_MD_KIOV) != 0) { 387 niov = umd->length; 388 size = offsetof(lnet_libmd_t, md_iov.kiov[niov]); 389 } else { 390 niov = ((umd->options & LNET_MD_IOVEC) != 0) ? 391 umd->length : 1; 392 size = offsetof(lnet_libmd_t, md_iov.iov[niov]); 393 } 394 395 LIBCFS_ALLOC(md, size); 396 397 if (md != NULL) { 398 /* Set here in case of early free */ 399 md->md_options = umd->options; 400 md->md_niov = niov; 401 INIT_LIST_HEAD(&md->md_list); 402 } 403 404 return md; 405} 406 407static inline void 408lnet_md_free(lnet_libmd_t *md) 409{ 410 /* ALWAYS called with resource lock held */ 411 unsigned int size; 412 413 if ((md->md_options & LNET_MD_KIOV) != 0) 414 size = offsetof(lnet_libmd_t, md_iov.kiov[md->md_niov]); 415 else 416 size = offsetof(lnet_libmd_t, md_iov.iov[md->md_niov]); 417 418 LIBCFS_FREE(md, size); 419} 420 421static inline lnet_me_t * 422lnet_me_alloc(void) 423{ 424 /* NEVER called with liblock held */ 425 lnet_me_t *me; 426 427 LIBCFS_ALLOC(me, sizeof(*me)); 428 return me; 429} 430 431static inline void 432lnet_me_free(lnet_me_t *me) 433{ 434 /* ALWAYS called with resource lock held */ 435 LIBCFS_FREE(me, sizeof(*me)); 436} 437 438static inline lnet_msg_t * 439lnet_msg_alloc(void) 440{ 441 /* NEVER called with liblock held */ 442 lnet_msg_t *msg; 443 444 LIBCFS_ALLOC(msg, sizeof(*msg)); 445 446 /* no need to zero, LIBCFS_ALLOC does for us */ 447 return msg; 448} 449 450static inline void 451lnet_msg_free(lnet_msg_t *msg) 452{ 453 /* ALWAYS called with network lock held */ 454 LASSERT(!msg->msg_onactivelist); 455 LIBCFS_FREE(msg, sizeof(*msg)); 456} 457 458#define lnet_eq_free_locked(eq) lnet_eq_free(eq) 459#define lnet_md_free_locked(md) lnet_md_free(md) 460#define lnet_me_free_locked(me) lnet_me_free(me) 461#define lnet_msg_free_locked(msg) lnet_msg_free(msg) 462 463#endif /* LNET_USE_LIB_FREELIST */ 464 465lnet_libhandle_t *lnet_res_lh_lookup(struct lnet_res_container *rec, 466 __u64 cookie); 467void lnet_res_lh_initialize(struct lnet_res_container *rec, 468 lnet_libhandle_t *lh); 469static inline void 470lnet_res_lh_invalidate(lnet_libhandle_t *lh) 471{ 472 /* ALWAYS called with resource lock held */ 473 /* NB: cookie is still useful, don't reset it */ 474 list_del(&lh->lh_hash_chain); 475} 476 477static inline void 478lnet_eq2handle(lnet_handle_eq_t *handle, lnet_eq_t *eq) 479{ 480 if (eq == NULL) { 481 LNetInvalidateHandle(handle); 482 return; 483 } 484 485 handle->cookie = eq->eq_lh.lh_cookie; 486} 487 488static inline lnet_eq_t * 489lnet_handle2eq(lnet_handle_eq_t *handle) 490{ 491 /* ALWAYS called with resource lock held */ 492 lnet_libhandle_t *lh; 493 494 lh = lnet_res_lh_lookup(&the_lnet.ln_eq_container, handle->cookie); 495 if (lh == NULL) 496 return NULL; 497 498 return lh_entry(lh, lnet_eq_t, eq_lh); 499} 500 501static inline void 502lnet_md2handle(lnet_handle_md_t *handle, lnet_libmd_t *md) 503{ 504 handle->cookie = md->md_lh.lh_cookie; 505} 506 507static inline lnet_libmd_t * 508lnet_handle2md(lnet_handle_md_t *handle) 509{ 510 /* ALWAYS called with resource lock held */ 511 lnet_libhandle_t *lh; 512 int cpt; 513 514 cpt = lnet_cpt_of_cookie(handle->cookie); 515 lh = lnet_res_lh_lookup(the_lnet.ln_md_containers[cpt], 516 handle->cookie); 517 if (lh == NULL) 518 return NULL; 519 520 return lh_entry(lh, lnet_libmd_t, md_lh); 521} 522 523static inline lnet_libmd_t * 524lnet_wire_handle2md(lnet_handle_wire_t *wh) 525{ 526 /* ALWAYS called with resource lock held */ 527 lnet_libhandle_t *lh; 528 int cpt; 529 530 if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie) 531 return NULL; 532 533 cpt = lnet_cpt_of_cookie(wh->wh_object_cookie); 534 lh = lnet_res_lh_lookup(the_lnet.ln_md_containers[cpt], 535 wh->wh_object_cookie); 536 if (lh == NULL) 537 return NULL; 538 539 return lh_entry(lh, lnet_libmd_t, md_lh); 540} 541 542static inline void 543lnet_me2handle(lnet_handle_me_t *handle, lnet_me_t *me) 544{ 545 handle->cookie = me->me_lh.lh_cookie; 546} 547 548static inline lnet_me_t * 549lnet_handle2me(lnet_handle_me_t *handle) 550{ 551 /* ALWAYS called with resource lock held */ 552 lnet_libhandle_t *lh; 553 int cpt; 554 555 cpt = lnet_cpt_of_cookie(handle->cookie); 556 lh = lnet_res_lh_lookup(the_lnet.ln_me_containers[cpt], 557 handle->cookie); 558 if (lh == NULL) 559 return NULL; 560 561 return lh_entry(lh, lnet_me_t, me_lh); 562} 563 564static inline void 565lnet_peer_addref_locked(lnet_peer_t *lp) 566{ 567 LASSERT(lp->lp_refcount > 0); 568 lp->lp_refcount++; 569} 570 571void lnet_destroy_peer_locked(lnet_peer_t *lp); 572 573static inline void 574lnet_peer_decref_locked(lnet_peer_t *lp) 575{ 576 LASSERT(lp->lp_refcount > 0); 577 lp->lp_refcount--; 578 if (lp->lp_refcount == 0) 579 lnet_destroy_peer_locked(lp); 580} 581 582static inline int 583lnet_isrouter(lnet_peer_t *lp) 584{ 585 return lp->lp_rtr_refcount != 0; 586} 587 588static inline void 589lnet_ni_addref_locked(lnet_ni_t *ni, int cpt) 590{ 591 LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER); 592 LASSERT(*ni->ni_refs[cpt] >= 0); 593 594 (*ni->ni_refs[cpt])++; 595} 596 597static inline void 598lnet_ni_addref(lnet_ni_t *ni) 599{ 600 lnet_net_lock(0); 601 lnet_ni_addref_locked(ni, 0); 602 lnet_net_unlock(0); 603} 604 605static inline void 606lnet_ni_decref_locked(lnet_ni_t *ni, int cpt) 607{ 608 LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER); 609 LASSERT(*ni->ni_refs[cpt] > 0); 610 611 (*ni->ni_refs[cpt])--; 612} 613 614static inline void 615lnet_ni_decref(lnet_ni_t *ni) 616{ 617 lnet_net_lock(0); 618 lnet_ni_decref_locked(ni, 0); 619 lnet_net_unlock(0); 620} 621 622void lnet_ni_free(lnet_ni_t *ni); 623 624static inline int 625lnet_nid2peerhash(lnet_nid_t nid) 626{ 627 return hash_long(nid, LNET_PEER_HASH_BITS); 628} 629 630static inline struct list_head * 631lnet_net2rnethash(__u32 net) 632{ 633 return &the_lnet.ln_remote_nets_hash[(LNET_NETNUM(net) + 634 LNET_NETTYP(net)) & 635 ((1U << the_lnet.ln_remote_nets_hbits) - 1)]; 636} 637 638extern lnd_t the_lolnd; 639 640int lnet_cpt_of_nid_locked(lnet_nid_t nid); 641int lnet_cpt_of_nid(lnet_nid_t nid); 642lnet_ni_t *lnet_nid2ni_locked(lnet_nid_t nid, int cpt); 643lnet_ni_t *lnet_net2ni_locked(__u32 net, int cpt); 644lnet_ni_t *lnet_net2ni(__u32 net); 645 646int lnet_notify(lnet_ni_t *ni, lnet_nid_t peer, int alive, unsigned long when); 647void lnet_notify_locked(lnet_peer_t *lp, int notifylnd, int alive, 648 unsigned long when); 649int lnet_add_route(__u32 net, unsigned int hops, lnet_nid_t gateway_nid, 650 unsigned int priority); 651int lnet_check_routes(void); 652int lnet_del_route(__u32 net, lnet_nid_t gw_nid); 653void lnet_destroy_routes(void); 654int lnet_get_route(int idx, __u32 *net, __u32 *hops, 655 lnet_nid_t *gateway, __u32 *alive, __u32 *priority); 656void lnet_proc_init(void); 657void lnet_proc_fini(void); 658int lnet_rtrpools_alloc(int im_a_router); 659void lnet_rtrpools_free(void); 660lnet_remotenet_t *lnet_find_net_locked(__u32 net); 661 662int lnet_islocalnid(lnet_nid_t nid); 663int lnet_islocalnet(__u32 net); 664 665void lnet_msg_attach_md(lnet_msg_t *msg, lnet_libmd_t *md, 666 unsigned int offset, unsigned int mlen); 667void lnet_msg_detach_md(lnet_msg_t *msg, int status); 668void lnet_build_unlink_event(lnet_libmd_t *md, lnet_event_t *ev); 669void lnet_build_msg_event(lnet_msg_t *msg, lnet_event_kind_t ev_type); 670void lnet_msg_commit(lnet_msg_t *msg, int cpt); 671void lnet_msg_decommit(lnet_msg_t *msg, int cpt, int status); 672 673void lnet_eq_enqueue_event(lnet_eq_t *eq, lnet_event_t *ev); 674void lnet_prep_send(lnet_msg_t *msg, int type, lnet_process_id_t target, 675 unsigned int offset, unsigned int len); 676int lnet_send(lnet_nid_t nid, lnet_msg_t *msg, lnet_nid_t rtr_nid); 677void lnet_return_tx_credits_locked(lnet_msg_t *msg); 678void lnet_return_rx_credits_locked(lnet_msg_t *msg); 679 680/* portals functions */ 681/* portals attributes */ 682static inline int 683lnet_ptl_is_lazy(lnet_portal_t *ptl) 684{ 685 return !!(ptl->ptl_options & LNET_PTL_LAZY); 686} 687 688static inline int 689lnet_ptl_is_unique(lnet_portal_t *ptl) 690{ 691 return !!(ptl->ptl_options & LNET_PTL_MATCH_UNIQUE); 692} 693 694static inline int 695lnet_ptl_is_wildcard(lnet_portal_t *ptl) 696{ 697 return !!(ptl->ptl_options & LNET_PTL_MATCH_WILDCARD); 698} 699 700static inline void 701lnet_ptl_setopt(lnet_portal_t *ptl, int opt) 702{ 703 ptl->ptl_options |= opt; 704} 705 706static inline void 707lnet_ptl_unsetopt(lnet_portal_t *ptl, int opt) 708{ 709 ptl->ptl_options &= ~opt; 710} 711 712/* match-table functions */ 713struct list_head *lnet_mt_match_head(struct lnet_match_table *mtable, 714 lnet_process_id_t id, __u64 mbits); 715struct lnet_match_table *lnet_mt_of_attach(unsigned int index, 716 lnet_process_id_t id, __u64 mbits, 717 __u64 ignore_bits, 718 lnet_ins_pos_t pos); 719int lnet_mt_match_md(struct lnet_match_table *mtable, 720 struct lnet_match_info *info, struct lnet_msg *msg); 721 722/* portals match/attach functions */ 723void lnet_ptl_attach_md(lnet_me_t *me, lnet_libmd_t *md, 724 struct list_head *matches, struct list_head *drops); 725void lnet_ptl_detach_md(lnet_me_t *me, lnet_libmd_t *md); 726int lnet_ptl_match_md(struct lnet_match_info *info, struct lnet_msg *msg); 727 728/* initialized and finalize portals */ 729int lnet_portals_create(void); 730void lnet_portals_destroy(void); 731 732/* message functions */ 733int lnet_parse(lnet_ni_t *ni, lnet_hdr_t *hdr, 734 lnet_nid_t fromnid, void *private, int rdma_req); 735void lnet_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed, 736 unsigned int offset, unsigned int mlen, unsigned int rlen); 737lnet_msg_t *lnet_create_reply_msg(lnet_ni_t *ni, lnet_msg_t *get_msg); 738void lnet_set_reply_msg_len(lnet_ni_t *ni, lnet_msg_t *msg, unsigned int len); 739void lnet_finalize(lnet_ni_t *ni, lnet_msg_t *msg, int rc); 740void lnet_drop_delayed_msg_list(struct list_head *head, char *reason); 741void lnet_recv_delayed_msg_list(struct list_head *head); 742 743int lnet_msg_container_setup(struct lnet_msg_container *container, int cpt); 744void lnet_msg_container_cleanup(struct lnet_msg_container *container); 745void lnet_msg_containers_destroy(void); 746int lnet_msg_containers_create(void); 747 748char *lnet_msgtyp2str(int type); 749void lnet_print_hdr(lnet_hdr_t *hdr); 750int lnet_fail_nid(lnet_nid_t nid, unsigned int threshold); 751 752void lnet_counters_get(lnet_counters_t *counters); 753void lnet_counters_reset(void); 754 755unsigned int lnet_iov_nob(unsigned int niov, struct iovec *iov); 756int lnet_extract_iov(int dst_niov, struct iovec *dst, 757 int src_niov, struct iovec *src, 758 unsigned int offset, unsigned int len); 759 760unsigned int lnet_kiov_nob(unsigned int niov, lnet_kiov_t *iov); 761int lnet_extract_kiov(int dst_niov, lnet_kiov_t *dst, 762 int src_niov, lnet_kiov_t *src, 763 unsigned int offset, unsigned int len); 764 765void lnet_copy_iov2iov(unsigned int ndiov, struct iovec *diov, 766 unsigned int doffset, 767 unsigned int nsiov, struct iovec *siov, 768 unsigned int soffset, unsigned int nob); 769void lnet_copy_kiov2iov(unsigned int niov, struct iovec *iov, 770 unsigned int iovoffset, 771 unsigned int nkiov, lnet_kiov_t *kiov, 772 unsigned int kiovoffset, unsigned int nob); 773void lnet_copy_iov2kiov(unsigned int nkiov, lnet_kiov_t *kiov, 774 unsigned int kiovoffset, 775 unsigned int niov, struct iovec *iov, 776 unsigned int iovoffset, unsigned int nob); 777void lnet_copy_kiov2kiov(unsigned int ndkiov, lnet_kiov_t *dkiov, 778 unsigned int doffset, 779 unsigned int nskiov, lnet_kiov_t *skiov, 780 unsigned int soffset, unsigned int nob); 781 782static inline void 783lnet_copy_iov2flat(int dlen, void *dest, unsigned int doffset, 784 unsigned int nsiov, struct iovec *siov, unsigned int soffset, 785 unsigned int nob) 786{ 787 struct iovec diov = {/*.iov_base = */ dest, /*.iov_len = */ dlen}; 788 789 lnet_copy_iov2iov(1, &diov, doffset, 790 nsiov, siov, soffset, nob); 791} 792 793static inline void 794lnet_copy_kiov2flat(int dlen, void *dest, unsigned int doffset, 795 unsigned int nsiov, lnet_kiov_t *skiov, 796 unsigned int soffset, unsigned int nob) 797{ 798 struct iovec diov = {/* .iov_base = */ dest, /* .iov_len = */ dlen}; 799 800 lnet_copy_kiov2iov(1, &diov, doffset, 801 nsiov, skiov, soffset, nob); 802} 803 804static inline void 805lnet_copy_flat2iov(unsigned int ndiov, struct iovec *diov, unsigned int doffset, 806 int slen, void *src, unsigned int soffset, unsigned int nob) 807{ 808 struct iovec siov = {/*.iov_base = */ src, /*.iov_len = */slen}; 809 810 lnet_copy_iov2iov(ndiov, diov, doffset, 811 1, &siov, soffset, nob); 812} 813 814static inline void 815lnet_copy_flat2kiov(unsigned int ndiov, lnet_kiov_t *dkiov, 816 unsigned int doffset, int slen, void *src, 817 unsigned int soffset, unsigned int nob) 818{ 819 struct iovec siov = {/* .iov_base = */ src, /* .iov_len = */ slen}; 820 821 lnet_copy_iov2kiov(ndiov, dkiov, doffset, 822 1, &siov, soffset, nob); 823} 824 825void lnet_me_unlink(lnet_me_t *me); 826 827void lnet_md_unlink(lnet_libmd_t *md); 828void lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd); 829 830void lnet_register_lnd(lnd_t *lnd); 831void lnet_unregister_lnd(lnd_t *lnd); 832int lnet_set_ip_niaddr(lnet_ni_t *ni); 833 834int lnet_connect(struct socket **sockp, lnet_nid_t peer_nid, 835 __u32 local_ip, __u32 peer_ip, int peer_port); 836void lnet_connect_console_error(int rc, lnet_nid_t peer_nid, 837 __u32 peer_ip, int port); 838int lnet_count_acceptor_nis(void); 839int lnet_acceptor_timeout(void); 840int lnet_acceptor_port(void); 841 842int lnet_count_acceptor_nis(void); 843int lnet_acceptor_port(void); 844 845int lnet_acceptor_start(void); 846void lnet_acceptor_stop(void); 847 848void lnet_get_tunables(void); 849int lnet_peers_start_down(void); 850int lnet_peer_buffer_credits(lnet_ni_t *ni); 851 852int lnet_router_checker_start(void); 853void lnet_router_checker_stop(void); 854void lnet_swap_pinginfo(lnet_ping_info_t *info); 855 856int lnet_ping_target_init(void); 857void lnet_ping_target_fini(void); 858int lnet_ping(lnet_process_id_t id, int timeout_ms, 859 lnet_process_id_t *ids, int n_ids); 860 861int lnet_parse_ip2nets(char **networksp, char *ip2nets); 862int lnet_parse_routes(char *route_str, int *im_a_router); 863int lnet_parse_networks(struct list_head *nilist, char *networks); 864 865int lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid, int cpt); 866lnet_peer_t *lnet_find_peer_locked(struct lnet_peer_table *ptable, 867 lnet_nid_t nid); 868void lnet_peer_tables_cleanup(void); 869void lnet_peer_tables_destroy(void); 870int lnet_peer_tables_create(void); 871void lnet_debug_peer(lnet_nid_t nid); 872 873#endif 874