Whamcloud - gitweb
0d3fc995f0b49cdef093ac4d94464b648a1bc5ec
[fs/lustre-release.git] / lnet / include / lnet / lib-lnet.h
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2012, 2016, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lnet/include/lnet/lib-lnet.h
33  *
34  * Top level include for library side routines
35  */
36
37 #ifndef __LNET_LIB_LNET_H__
38 #define __LNET_LIB_LNET_H__
39
40 #ifndef __KERNEL__
41 # error This include is only for kernel use.
42 #endif
43
44 #include <libcfs/libcfs.h>
45 #include <lnet/api.h>
46 #include <lnet/lnet.h>
47 #include <lnet/lib-types.h>
48
49 extern lnet_t  the_lnet;                        /* THE network */
50
51 #if (BITS_PER_LONG == 32)
52 /* 2 CPTs, allowing more CPTs might make us under memory pressure */
53 # define LNET_CPT_MAX_BITS     1
54
55 #else /* 64-bit system */
56 /*
57  * 256 CPTs for thousands of CPUs, allowing more CPTs might make us
58  * under risk of consuming all lh_cookie.
59  */
60 # define LNET_CPT_MAX_BITS     8
61 #endif /* BITS_PER_LONG == 32 */
62
63 /* max allowed CPT number */
64 #define LNET_CPT_MAX            (1 << LNET_CPT_MAX_BITS)
65
66 #define LNET_CPT_NUMBER         (the_lnet.ln_cpt_number)
67 #define LNET_CPT_BITS           (the_lnet.ln_cpt_bits)
68 #define LNET_CPT_MASK           ((1ULL << LNET_CPT_BITS) - 1)
69
70 /** exclusive lock */
71 #define LNET_LOCK_EX            CFS_PERCPT_LOCK_EX
72
73 static inline int lnet_is_route_alive(lnet_route_t *route)
74 {
75         if (!route->lr_gateway->lpni_alive)
76                 return 0; /* gateway is down */
77         if ((route->lr_gateway->lpni_ping_feats &
78              LNET_PING_FEAT_NI_STATUS) == 0)
79                 return 1; /* no NI status, assume it's alive */
80         /* has NI status, check # down NIs */
81         return route->lr_downis == 0;
82 }
83
84 static inline int lnet_is_wire_handle_none(struct lnet_handle_wire *wh)
85 {
86         return (wh->wh_interface_cookie == LNET_WIRE_HANDLE_COOKIE_NONE &&
87                 wh->wh_object_cookie == LNET_WIRE_HANDLE_COOKIE_NONE);
88 }
89
90 static inline int lnet_md_exhausted (lnet_libmd_t *md)
91 {
92         return (md->md_threshold == 0 ||
93                 ((md->md_options & LNET_MD_MAX_SIZE) != 0 &&
94                  md->md_offset + md->md_max_size > md->md_length));
95 }
96
97 static inline int lnet_md_unlinkable (lnet_libmd_t *md)
98 {
99         /* Should unlink md when its refcount is 0 and either:
100          *  - md has been flagged for deletion (by auto unlink or LNetM[DE]Unlink,
101          *    in the latter case md may not be exhausted).
102          *  - auto unlink is on and md is exhausted.
103          */
104         if (md->md_refcount != 0)
105                 return 0;
106
107         if ((md->md_flags & LNET_MD_FLAG_ZOMBIE) != 0)
108                 return 1;
109
110         return ((md->md_flags & LNET_MD_FLAG_AUTO_UNLINK) != 0 &&
111                 lnet_md_exhausted(md));
112 }
113
114 #define lnet_cpt_table()        (the_lnet.ln_cpt_table)
115 #define lnet_cpt_current()      cfs_cpt_current(the_lnet.ln_cpt_table, 1)
116
117 static inline int
118 lnet_cpt_of_cookie(__u64 cookie)
119 {
120         unsigned int cpt = (cookie >> LNET_COOKIE_TYPE_BITS) & LNET_CPT_MASK;
121
122         /* LNET_CPT_NUMBER doesn't have to be power2, which means we can
123          * get illegal cpt from it's invalid cookie */
124         return cpt < LNET_CPT_NUMBER ? cpt : cpt % LNET_CPT_NUMBER;
125 }
126
127 static inline void
128 lnet_res_lock(int cpt)
129 {
130         cfs_percpt_lock(the_lnet.ln_res_lock, cpt);
131 }
132
133 static inline void
134 lnet_res_unlock(int cpt)
135 {
136         cfs_percpt_unlock(the_lnet.ln_res_lock, cpt);
137 }
138
139 static inline int
140 lnet_res_lock_current(void)
141 {
142         int cpt = lnet_cpt_current();
143
144         lnet_res_lock(cpt);
145         return cpt;
146 }
147
148 static inline void
149 lnet_net_lock(int cpt)
150 {
151         cfs_percpt_lock(the_lnet.ln_net_lock, cpt);
152 }
153
154 static inline void
155 lnet_net_unlock(int cpt)
156 {
157         cfs_percpt_unlock(the_lnet.ln_net_lock, cpt);
158 }
159
160 static inline int
161 lnet_net_lock_current(void)
162 {
163         int cpt = lnet_cpt_current();
164
165         lnet_net_lock(cpt);
166         return cpt;
167 }
168
169 #define LNET_LOCK()             lnet_net_lock(LNET_LOCK_EX)
170 #define LNET_UNLOCK()           lnet_net_unlock(LNET_LOCK_EX)
171
172 #define lnet_ptl_lock(ptl)      spin_lock(&(ptl)->ptl_lock)
173 #define lnet_ptl_unlock(ptl)    spin_unlock(&(ptl)->ptl_lock)
174 #define lnet_eq_wait_lock()     spin_lock(&the_lnet.ln_eq_wait_lock)
175 #define lnet_eq_wait_unlock()   spin_unlock(&the_lnet.ln_eq_wait_lock)
176 #define lnet_ni_lock(ni)        spin_lock(&(ni)->ni_lock)
177 #define lnet_ni_unlock(ni)      spin_unlock(&(ni)->ni_lock)
178
179 #define MAX_PORTALS     64
180
181 #define LNET_SMALL_MD_SIZE   offsetof(lnet_libmd_t, md_iov.iov[1])
182 extern struct kmem_cache *lnet_mes_cachep;       /* MEs kmem_cache */
183 extern struct kmem_cache *lnet_small_mds_cachep; /* <= LNET_SMALL_MD_SIZE bytes
184                                                   * MDs kmem_cache */
185
186 static inline lnet_eq_t *
187 lnet_eq_alloc (void)
188 {
189         lnet_eq_t *eq;
190
191         LIBCFS_ALLOC(eq, sizeof(*eq));
192         return (eq);
193 }
194
195 static inline void
196 lnet_eq_free(lnet_eq_t *eq)
197 {
198         LIBCFS_FREE(eq, sizeof(*eq));
199 }
200
201 static inline lnet_libmd_t *
202 lnet_md_alloc (lnet_md_t *umd)
203 {
204         lnet_libmd_t *md;
205         unsigned int  size;
206         unsigned int  niov;
207
208         if ((umd->options & LNET_MD_KIOV) != 0) {
209                 niov = umd->length;
210                 size = offsetof(lnet_libmd_t, md_iov.kiov[niov]);
211         } else {
212                 niov = ((umd->options & LNET_MD_IOVEC) != 0) ?
213                        umd->length : 1;
214                 size = offsetof(lnet_libmd_t, md_iov.iov[niov]);
215         }
216
217         if (size <= LNET_SMALL_MD_SIZE) {
218                 md = kmem_cache_alloc(lnet_small_mds_cachep,
219                                       GFP_NOFS | __GFP_ZERO);
220                 if (md) {
221                         CDEBUG(D_MALLOC, "slab-alloced 'md' of size %u at "
222                                "%p.\n", size, md);
223                 } else {
224                         CDEBUG(D_MALLOC, "failed to allocate 'md' of size %u\n",
225                                size);
226                         return NULL;
227                 }
228         } else {
229                 LIBCFS_ALLOC(md, size);
230         }
231
232         if (md != NULL) {
233                 /* Set here in case of early free */
234                 md->md_options = umd->options;
235                 md->md_niov = niov;
236                 INIT_LIST_HEAD(&md->md_list);
237         }
238
239         return md;
240 }
241
242 static inline void
243 lnet_md_free(lnet_libmd_t *md)
244 {
245         unsigned int  size;
246
247         if ((md->md_options & LNET_MD_KIOV) != 0)
248                 size = offsetof(lnet_libmd_t, md_iov.kiov[md->md_niov]);
249         else
250                 size = offsetof(lnet_libmd_t, md_iov.iov[md->md_niov]);
251
252         if (size <= LNET_SMALL_MD_SIZE) {
253                 CDEBUG(D_MALLOC, "slab-freed 'md' at %p.\n", md);
254                 kmem_cache_free(lnet_small_mds_cachep, md);
255         } else {
256                 LIBCFS_FREE(md, size);
257         }
258 }
259
260 static inline lnet_me_t *
261 lnet_me_alloc (void)
262 {
263         lnet_me_t *me;
264
265         me = kmem_cache_alloc(lnet_mes_cachep, GFP_NOFS | __GFP_ZERO);
266
267         if (me)
268                 CDEBUG(D_MALLOC, "slab-alloced 'me' at %p.\n", me);
269         else
270                 CDEBUG(D_MALLOC, "failed to allocate 'me'\n");
271
272         return me;
273 }
274
275 static inline void
276 lnet_me_free(lnet_me_t *me)
277 {
278         CDEBUG(D_MALLOC, "slab-freed 'me' at %p.\n", me);
279         kmem_cache_free(lnet_mes_cachep, me);
280 }
281
282 lnet_libhandle_t *lnet_res_lh_lookup(struct lnet_res_container *rec,
283                                      __u64 cookie);
284 void lnet_res_lh_initialize(struct lnet_res_container *rec,
285                             lnet_libhandle_t *lh);
286 static inline void
287 lnet_res_lh_invalidate(lnet_libhandle_t *lh)
288 {
289         /* ALWAYS called with resource lock held */
290         /* NB: cookie is still useful, don't reset it */
291         list_del(&lh->lh_hash_chain);
292 }
293
294 static inline void
295 lnet_eq2handle (lnet_handle_eq_t *handle, lnet_eq_t *eq)
296 {
297         if (eq == NULL) {
298                 LNetInvalidateHandle(handle);
299                 return;
300         }
301
302         handle->cookie = eq->eq_lh.lh_cookie;
303 }
304
305 static inline lnet_eq_t *
306 lnet_handle2eq(lnet_handle_eq_t *handle)
307 {
308         /* ALWAYS called with resource lock held */
309         lnet_libhandle_t *lh;
310
311         lh = lnet_res_lh_lookup(&the_lnet.ln_eq_container, handle->cookie);
312         if (lh == NULL)
313                 return NULL;
314
315         return lh_entry(lh, lnet_eq_t, eq_lh);
316 }
317
318 static inline void
319 lnet_md2handle (lnet_handle_md_t *handle, lnet_libmd_t *md)
320 {
321         handle->cookie = md->md_lh.lh_cookie;
322 }
323
324 static inline lnet_libmd_t *
325 lnet_handle2md(lnet_handle_md_t *handle)
326 {
327         /* ALWAYS called with resource lock held */
328         lnet_libhandle_t *lh;
329         int              cpt;
330
331         cpt = lnet_cpt_of_cookie(handle->cookie);
332         lh = lnet_res_lh_lookup(the_lnet.ln_md_containers[cpt],
333                                 handle->cookie);
334         if (lh == NULL)
335                 return NULL;
336
337         return lh_entry(lh, lnet_libmd_t, md_lh);
338 }
339
340 static inline lnet_libmd_t *
341 lnet_wire_handle2md(struct lnet_handle_wire *wh)
342 {
343         /* ALWAYS called with resource lock held */
344         lnet_libhandle_t *lh;
345         int              cpt;
346
347         if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie)
348                 return NULL;
349
350         cpt = lnet_cpt_of_cookie(wh->wh_object_cookie);
351         lh = lnet_res_lh_lookup(the_lnet.ln_md_containers[cpt],
352                                 wh->wh_object_cookie);
353         if (lh == NULL)
354                 return NULL;
355
356         return lh_entry(lh, lnet_libmd_t, md_lh);
357 }
358
359 static inline void
360 lnet_me2handle (lnet_handle_me_t *handle, lnet_me_t *me)
361 {
362         handle->cookie = me->me_lh.lh_cookie;
363 }
364
365 static inline lnet_me_t *
366 lnet_handle2me(lnet_handle_me_t *handle)
367 {
368         /* ALWAYS called with resource lock held */
369         lnet_libhandle_t *lh;
370         int              cpt;
371
372         cpt = lnet_cpt_of_cookie(handle->cookie);
373         lh = lnet_res_lh_lookup(the_lnet.ln_me_containers[cpt],
374                                 handle->cookie);
375         if (lh == NULL)
376                 return NULL;
377
378         return lh_entry(lh, lnet_me_t, me_lh);
379 }
380
381 static inline void
382 lnet_peer_ni_addref_locked(struct lnet_peer_ni *lp)
383 {
384         LASSERT (atomic_read(&lp->lpni_refcount) > 0);
385         atomic_inc(&lp->lpni_refcount);
386 }
387
388 extern void lnet_destroy_peer_ni_locked(struct lnet_peer_ni *lp);
389
390 static inline void
391 lnet_peer_ni_decref_locked(struct lnet_peer_ni *lp)
392 {
393         LASSERT (atomic_read(&lp->lpni_refcount) > 0);
394         atomic_dec(&lp->lpni_refcount);
395         if (atomic_read(&lp->lpni_refcount) == 0)
396                 lnet_destroy_peer_ni_locked(lp);
397 }
398
399 static inline int
400 lnet_isrouter(struct lnet_peer_ni *lp)
401 {
402         return lp->lpni_rtr_refcount != 0;
403 }
404
405 static inline void
406 lnet_ni_addref_locked(lnet_ni_t *ni, int cpt)
407 {
408         LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER);
409         LASSERT(*ni->ni_refs[cpt] >= 0);
410
411         (*ni->ni_refs[cpt])++;
412 }
413
414 static inline void
415 lnet_ni_addref(lnet_ni_t *ni)
416 {
417         lnet_net_lock(0);
418         lnet_ni_addref_locked(ni, 0);
419         lnet_net_unlock(0);
420 }
421
422 static inline void
423 lnet_ni_decref_locked(lnet_ni_t *ni, int cpt)
424 {
425         LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER);
426         LASSERT(*ni->ni_refs[cpt] > 0);
427
428         (*ni->ni_refs[cpt])--;
429 }
430
431 static inline void
432 lnet_ni_decref(lnet_ni_t *ni)
433 {
434         lnet_net_lock(0);
435         lnet_ni_decref_locked(ni, 0);
436         lnet_net_unlock(0);
437 }
438
439 static inline lnet_msg_t *
440 lnet_msg_alloc(void)
441 {
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
450 static inline void
451 lnet_msg_free(lnet_msg_t *msg)
452 {
453         LASSERT(!msg->msg_onactivelist);
454
455         /* Make sure we have no references to an NI. */
456         if (msg->msg_txni)
457                 lnet_ni_decref_locked(msg->msg_txni, msg->msg_tx_cpt);
458         if (msg->msg_rxni)
459                 lnet_ni_decref_locked(msg->msg_rxni, msg->msg_rx_cpt);
460
461         LIBCFS_FREE(msg, sizeof(*msg));
462 }
463
464 void lnet_ni_free(struct lnet_ni *ni);
465 void lnet_net_free(struct lnet_net *net);
466
467 struct lnet_net *
468 lnet_net_alloc(__u32 net_type, struct list_head *netlist);
469
470 struct lnet_ni *
471 lnet_ni_alloc(struct lnet_net *net, struct cfs_expr_list *el,
472               char *iface);
473
474 static inline int
475 lnet_nid2peerhash(lnet_nid_t nid)
476 {
477         return hash_long(nid, LNET_PEER_HASH_BITS);
478 }
479
480 static inline struct list_head *
481 lnet_net2rnethash(__u32 net)
482 {
483         return &the_lnet.ln_remote_nets_hash[(LNET_NETNUM(net) +
484                 LNET_NETTYP(net)) &
485                 ((1U << the_lnet.ln_remote_nets_hbits) - 1)];
486 }
487
488 extern lnd_t the_lolnd;
489 extern int avoid_asym_router_failure;
490
491 extern unsigned int lnet_nid_cpt_hash(lnet_nid_t nid, unsigned int number);
492 extern int lnet_cpt_of_nid_locked(lnet_nid_t nid, struct lnet_ni *ni);
493 extern int lnet_cpt_of_nid(lnet_nid_t nid, struct lnet_ni *ni);
494 extern lnet_ni_t *lnet_nid2ni_locked(lnet_nid_t nid, int cpt);
495 extern lnet_ni_t *lnet_nid2ni_addref(lnet_nid_t nid);
496 extern lnet_ni_t *lnet_net2ni_locked(__u32 net, int cpt);
497 extern lnet_ni_t *lnet_net2ni(__u32 net);
498 bool lnet_is_ni_healthy_locked(struct lnet_ni *ni);
499
500 int lnet_lib_init(void);
501 void lnet_lib_exit(void);
502
503 extern int portal_rotor;
504
505 int lnet_notify(lnet_ni_t *ni, lnet_nid_t peer, int alive, cfs_time_t when);
506 void lnet_notify_locked(struct lnet_peer_ni *lp, int notifylnd, int alive,
507                         cfs_time_t when);
508 int lnet_add_route(__u32 net, __u32 hops, lnet_nid_t gateway_nid,
509                    unsigned int priority);
510 int lnet_check_routes(void);
511 int lnet_del_route(__u32 net, lnet_nid_t gw_nid);
512 void lnet_destroy_routes(void);
513 int lnet_get_route(int idx, __u32 *net, __u32 *hops,
514                    lnet_nid_t *gateway, __u32 *alive, __u32 *priority);
515 int lnet_get_rtr_pool_cfg(int idx, struct lnet_ioctl_pool_cfg *pool_cfg);
516 struct lnet_ni *lnet_get_next_ni_locked(struct lnet_net *mynet,
517                                         struct lnet_ni *prev);
518 struct lnet_ni *lnet_get_ni_idx_locked(int idx);
519
520 struct libcfs_ioctl_handler {
521         struct list_head item;
522         int (*handle_ioctl)(unsigned int cmd, struct libcfs_ioctl_hdr *hdr);
523 };
524
525 #define DECLARE_IOCTL_HANDLER(ident, func)                      \
526         static struct libcfs_ioctl_handler ident = {            \
527                 /* .item = */ LIST_HEAD_INIT(ident.item),       \
528                 /* .handle_ioctl = */ func                      \
529         }
530
531 extern int libcfs_register_ioctl(struct libcfs_ioctl_handler *hand);
532 extern int libcfs_deregister_ioctl(struct libcfs_ioctl_handler *hand);
533 extern int libcfs_ioctl_getdata(struct libcfs_ioctl_hdr **hdr_pp,
534                                 struct libcfs_ioctl_hdr __user *uparam);
535
536 void lnet_proc_init(void);
537 void lnet_proc_fini(void);
538 int  lnet_rtrpools_alloc(int im_a_router);
539 void lnet_destroy_rtrbuf(lnet_rtrbuf_t *rb, int npages);
540 int  lnet_rtrpools_adjust(int tiny, int small, int large);
541 int lnet_rtrpools_enable(void);
542 void lnet_rtrpools_disable(void);
543 void lnet_rtrpools_free(int keep_pools);
544 lnet_remotenet_t *lnet_find_rnet_locked(__u32 net);
545 int lnet_dyn_add_ni(lnet_pid_t requested_pid,
546                     struct lnet_ioctl_config_data *conf);
547 int lnet_dyn_del_ni(__u32 net);
548 int lnet_clear_lazy_portal(struct lnet_ni *ni, int portal, char *reason);
549 struct lnet_net *lnet_get_net_locked(__u32 net_id);
550
551 int lnet_islocalnid(lnet_nid_t nid);
552 int lnet_islocalnet(__u32 net);
553
554 void lnet_msg_attach_md(lnet_msg_t *msg, lnet_libmd_t *md,
555                         unsigned int offset, unsigned int mlen);
556 void lnet_msg_detach_md(lnet_msg_t *msg, int status);
557 void lnet_build_unlink_event(lnet_libmd_t *md, lnet_event_t *ev);
558 void lnet_build_msg_event(lnet_msg_t *msg, lnet_event_kind_t ev_type);
559 void lnet_msg_commit(lnet_msg_t *msg, int cpt);
560 void lnet_msg_decommit(lnet_msg_t *msg, int cpt, int status);
561
562 void lnet_eq_enqueue_event(lnet_eq_t *eq, lnet_event_t *ev);
563 void lnet_prep_send(lnet_msg_t *msg, int type, lnet_process_id_t target,
564                     unsigned int offset, unsigned int len);
565 int lnet_send(lnet_nid_t nid, lnet_msg_t *msg, lnet_nid_t rtr_nid);
566 void lnet_return_tx_credits_locked(lnet_msg_t *msg);
567 void lnet_return_rx_credits_locked(lnet_msg_t *msg);
568 void lnet_schedule_blocked_locked(lnet_rtrbufpool_t *rbp);
569 void lnet_drop_routed_msgs_locked(struct list_head *list, int cpt);
570
571 /* portals functions */
572 /* portals attributes */
573 static inline int
574 lnet_ptl_is_lazy(lnet_portal_t *ptl)
575 {
576         return !!(ptl->ptl_options & LNET_PTL_LAZY);
577 }
578
579 static inline int
580 lnet_ptl_is_unique(lnet_portal_t *ptl)
581 {
582         return !!(ptl->ptl_options & LNET_PTL_MATCH_UNIQUE);
583 }
584
585 static inline int
586 lnet_ptl_is_wildcard(lnet_portal_t *ptl)
587 {
588         return !!(ptl->ptl_options & LNET_PTL_MATCH_WILDCARD);
589 }
590
591 static inline void
592 lnet_ptl_setopt(lnet_portal_t *ptl, int opt)
593 {
594         ptl->ptl_options |= opt;
595 }
596
597 static inline void
598 lnet_ptl_unsetopt(lnet_portal_t *ptl, int opt)
599 {
600         ptl->ptl_options &= ~opt;
601 }
602
603 /* match-table functions */
604 struct list_head *lnet_mt_match_head(struct lnet_match_table *mtable,
605                                lnet_process_id_t id, __u64 mbits);
606 struct lnet_match_table *lnet_mt_of_attach(unsigned int index,
607                                            lnet_process_id_t id, __u64 mbits,
608                                            __u64 ignore_bits,
609                                            lnet_ins_pos_t pos);
610 int lnet_mt_match_md(struct lnet_match_table *mtable,
611                      struct lnet_match_info *info, struct lnet_msg *msg);
612
613 /* portals match/attach functions */
614 void lnet_ptl_attach_md(lnet_me_t *me, lnet_libmd_t *md,
615                         struct list_head *matches, struct list_head *drops);
616 void lnet_ptl_detach_md(lnet_me_t *me, lnet_libmd_t *md);
617 int lnet_ptl_match_md(struct lnet_match_info *info, struct lnet_msg *msg);
618
619 /* initialized and finalize portals */
620 int lnet_portals_create(void);
621 void lnet_portals_destroy(void);
622
623 /* message functions */
624 int lnet_parse (lnet_ni_t *ni, lnet_hdr_t *hdr,
625                 lnet_nid_t fromnid, void *private, int rdma_req);
626 int lnet_parse_local(lnet_ni_t *ni, lnet_msg_t *msg);
627 int lnet_parse_forward_locked(lnet_ni_t *ni, lnet_msg_t *msg);
628
629 void lnet_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
630                unsigned int offset, unsigned int mlen, unsigned int rlen);
631 void lnet_ni_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg,
632                   int delayed, unsigned int offset,
633                   unsigned int mlen, unsigned int rlen);
634
635 lnet_msg_t *lnet_create_reply_msg (lnet_ni_t *ni, lnet_msg_t *get_msg);
636 void lnet_set_reply_msg_len(lnet_ni_t *ni, lnet_msg_t *msg, unsigned int len);
637
638 void lnet_finalize(lnet_ni_t *ni, lnet_msg_t *msg, int rc);
639
640 void lnet_drop_message(lnet_ni_t *ni, int cpt, void *private,
641                        unsigned int nob);
642 void lnet_drop_delayed_msg_list(struct list_head *head, char *reason);
643 void lnet_recv_delayed_msg_list(struct list_head *head);
644
645 int lnet_msg_container_setup(struct lnet_msg_container *container, int cpt);
646 void lnet_msg_container_cleanup(struct lnet_msg_container *container);
647 void lnet_msg_containers_destroy(void);
648 int lnet_msg_containers_create(void);
649
650 char *lnet_msgtyp2str (int type);
651 void lnet_print_hdr (lnet_hdr_t * hdr);
652 int lnet_fail_nid(lnet_nid_t nid, unsigned int threshold);
653
654 /** \addtogroup lnet_fault_simulation @{ */
655
656 int lnet_fault_ctl(int cmd, struct libcfs_ioctl_data *data);
657 int lnet_fault_init(void);
658 void lnet_fault_fini(void);
659
660 bool lnet_drop_rule_match(lnet_hdr_t *hdr);
661
662 int lnet_delay_rule_add(struct lnet_fault_attr *attr);
663 int lnet_delay_rule_del(lnet_nid_t src, lnet_nid_t dst, bool shutdown);
664 int lnet_delay_rule_list(int pos, struct lnet_fault_attr *attr,
665                          struct lnet_fault_stat *stat);
666 void lnet_delay_rule_reset(void);
667 void lnet_delay_rule_check(void);
668 bool lnet_delay_rule_match_locked(lnet_hdr_t *hdr, struct lnet_msg *msg);
669
670 /** @} lnet_fault_simulation */
671
672 void lnet_counters_get(lnet_counters_t *counters);
673 void lnet_counters_reset(void);
674
675 unsigned int lnet_iov_nob(unsigned int niov, struct kvec *iov);
676 int lnet_extract_iov(int dst_niov, struct kvec *dst,
677                       int src_niov, struct kvec *src,
678                       unsigned int offset, unsigned int len);
679
680 unsigned int lnet_kiov_nob (unsigned int niov, lnet_kiov_t *iov);
681 int lnet_extract_kiov(int dst_niov, lnet_kiov_t *dst,
682                      int src_niov, lnet_kiov_t *src,
683                      unsigned int offset, unsigned int len);
684
685 void lnet_copy_iov2iov(unsigned int ndiov, struct kvec *diov,
686                        unsigned int doffset,
687                        unsigned int nsiov, struct kvec *siov,
688                        unsigned int soffset, unsigned int nob);
689 void lnet_copy_kiov2iov(unsigned int niov, struct kvec *iov,
690                         unsigned int iovoffset,
691                         unsigned int nkiov, lnet_kiov_t *kiov,
692                         unsigned int kiovoffset, unsigned int nob);
693 void lnet_copy_iov2kiov(unsigned int nkiov, lnet_kiov_t *kiov,
694                         unsigned int kiovoffset,
695                         unsigned int niov, struct kvec *iov,
696                         unsigned int iovoffset, unsigned int nob);
697 void lnet_copy_kiov2kiov(unsigned int ndkiov, lnet_kiov_t *dkiov,
698                          unsigned int doffset,
699                          unsigned int nskiov, lnet_kiov_t *skiov,
700                          unsigned int soffset, unsigned int nob);
701
702 static inline void
703 lnet_copy_iov2flat(int dlen, void *dest, unsigned int doffset,
704                    unsigned int nsiov, struct kvec *siov, unsigned int soffset,
705                    unsigned int nob)
706 {
707         struct kvec diov = {/*.iov_base = */ dest, /*.iov_len = */ dlen};
708
709         lnet_copy_iov2iov(1, &diov, doffset,
710                           nsiov, siov, soffset, nob);
711 }
712
713 static inline void
714 lnet_copy_kiov2flat(int dlen, void *dest, unsigned int doffset,
715                     unsigned int nsiov, lnet_kiov_t *skiov,
716                     unsigned int soffset, unsigned int nob)
717 {
718         struct kvec diov = {/* .iov_base = */ dest, /* .iov_len = */ dlen};
719
720         lnet_copy_kiov2iov(1, &diov, doffset,
721                            nsiov, skiov, soffset, nob);
722 }
723
724 static inline void
725 lnet_copy_flat2iov(unsigned int ndiov, struct kvec *diov, unsigned int doffset,
726                    int slen, void *src, unsigned int soffset,
727                    unsigned int nob)
728 {
729         struct kvec siov = {/*.iov_base = */ src, /*.iov_len = */slen};
730         lnet_copy_iov2iov(ndiov, diov, doffset,
731                           1, &siov, soffset, nob);
732 }
733
734 static inline void
735 lnet_copy_flat2kiov(unsigned int ndiov, lnet_kiov_t *dkiov,
736                     unsigned int doffset, int slen, void *src,
737                     unsigned int soffset, unsigned int nob)
738 {
739         struct kvec siov = {/* .iov_base = */ src, /* .iov_len = */ slen};
740         lnet_copy_iov2kiov(ndiov, dkiov, doffset,
741                            1, &siov, soffset, nob);
742 }
743
744 void lnet_me_unlink(lnet_me_t *me);
745
746 void lnet_md_unlink(lnet_libmd_t *md);
747 void lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd);
748
749 void lnet_register_lnd(lnd_t *lnd);
750 void lnet_unregister_lnd(lnd_t *lnd);
751
752 int lnet_connect(struct socket **sockp, lnet_nid_t peer_nid,
753                  __u32 local_ip, __u32 peer_ip, int peer_port);
754 void lnet_connect_console_error(int rc, lnet_nid_t peer_nid,
755                                 __u32 peer_ip, int port);
756 int lnet_count_acceptor_nets(void);
757 int lnet_acceptor_timeout(void);
758 int lnet_acceptor_port(void);
759 int lnet_acceptor_start(void);
760 void lnet_acceptor_stop(void);
761
762 int lnet_ipif_query(char *name, int *up, __u32 *ip, __u32 *mask);
763 int lnet_ipif_enumerate(char ***names);
764 void lnet_ipif_free_enumeration(char **names, int n);
765 int lnet_sock_setbuf(struct socket *socket, int txbufsize, int rxbufsize);
766 int lnet_sock_getbuf(struct socket *socket, int *txbufsize, int *rxbufsize);
767 int lnet_sock_getaddr(struct socket *socket, bool remote, __u32 *ip, int *port);
768 int lnet_sock_write(struct socket *sock, void *buffer, int nob, int timeout);
769 int lnet_sock_read(struct socket *sock, void *buffer, int nob, int timeout);
770
771 int lnet_sock_listen(struct socket **sockp, __u32 ip, int port, int backlog);
772 int lnet_sock_accept(struct socket **newsockp, struct socket *sock);
773 int lnet_sock_connect(struct socket **sockp, int *fatal,
774                         __u32 local_ip, int local_port,
775                         __u32 peer_ip, int peer_port);
776
777 int lnet_peers_start_down(void);
778 int lnet_peer_buffer_credits(struct lnet_net *net);
779
780 int lnet_router_checker_start(void);
781 void lnet_router_checker_stop(void);
782 void lnet_router_ni_update_locked(struct lnet_peer_ni *gw, __u32 net);
783 void lnet_swap_pinginfo(struct lnet_ping_info *info);
784
785 int lnet_parse_ip2nets(char **networksp, char *ip2nets);
786 int lnet_parse_routes(char *route_str, int *im_a_router);
787 int lnet_parse_networks(struct list_head *nilist, char *networks,
788                         bool use_tcp_bonding);
789 bool lnet_net_unique(__u32 net_id, struct list_head *nilist,
790                      struct lnet_net **net);
791 bool lnet_ni_unique_net(struct list_head *nilist, char *iface);
792
793 int lnet_nid2peerni_locked(struct lnet_peer_ni **lpp, lnet_nid_t nid, int cpt);
794 struct lnet_peer_ni *lnet_find_peer_ni_locked(lnet_nid_t nid, int cpt);
795 void lnet_peer_tables_cleanup(lnet_ni_t *ni);
796 void lnet_peer_tables_destroy(void);
797 int lnet_peer_tables_create(void);
798 void lnet_debug_peer(lnet_nid_t nid);
799 int lnet_get_peer_info(__u32 peer_index, __u64 *nid,
800                        char alivness[LNET_MAX_STR_LEN],
801                        __u32 *cpt_iter, __u32 *refcount,
802                        __u32 *ni_peer_tx_credits, __u32 *peer_tx_credits,
803                        __u32 *peer_rtr_credits, __u32 *peer_min_rtr_credtis,
804                        __u32 *peer_tx_qnob);
805
806 static inline void
807 lnet_peer_set_alive(struct lnet_peer_ni *lp)
808 {
809         lp->lpni_last_alive = lp->lpni_last_query = cfs_time_current();
810         if (!lp->lpni_alive)
811                 lnet_notify_locked(lp, 0, 1, lp->lpni_last_alive);
812 }
813
814 #endif