4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
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.
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).
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
23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Use is subject to license terms.
26 * Copyright (c) 2012, 2015, Intel Corporation.
29 * This file is part of Lustre, http://www.lustre.org/
30 * Lustre is a trademark of Seagate, Inc.
32 * lnet/include/lnet/lib-lnet.h
35 #ifndef __LNET_LIB_LNET_H__
36 #define __LNET_LIB_LNET_H__
38 #include "../libcfs/libcfs.h"
41 #include "lib-types.h"
44 extern lnet_t the_lnet
; /* THE network */
46 #if (BITS_PER_LONG == 32)
47 /* 2 CPTs, allowing more CPTs might make us under memory pressure */
48 #define LNET_CPT_MAX_BITS 1
50 #else /* 64-bit system */
52 * 256 CPTs for thousands of CPUs, allowing more CPTs might make us
53 * under risk of consuming all lh_cookie.
55 #define LNET_CPT_MAX_BITS 8
56 #endif /* BITS_PER_LONG == 32 */
58 /* max allowed CPT number */
59 #define LNET_CPT_MAX (1 << LNET_CPT_MAX_BITS)
61 #define LNET_CPT_NUMBER (the_lnet.ln_cpt_number)
62 #define LNET_CPT_BITS (the_lnet.ln_cpt_bits)
63 #define LNET_CPT_MASK ((1ULL << LNET_CPT_BITS) - 1)
66 #define LNET_LOCK_EX CFS_PERCPT_LOCK_EX
68 static inline int lnet_is_route_alive(lnet_route_t
*route
)
71 if (!route
->lr_gateway
->lp_alive
)
73 /* no NI status, assume it's alive */
74 if ((route
->lr_gateway
->lp_ping_feats
&
75 LNET_PING_FEAT_NI_STATUS
) == 0)
77 /* has NI status, check # down NIs */
78 return route
->lr_downis
== 0;
81 static inline int lnet_is_wire_handle_none(lnet_handle_wire_t
*wh
)
83 return (wh
->wh_interface_cookie
== LNET_WIRE_HANDLE_COOKIE_NONE
&&
84 wh
->wh_object_cookie
== LNET_WIRE_HANDLE_COOKIE_NONE
);
87 static inline int lnet_md_exhausted(lnet_libmd_t
*md
)
89 return (!md
->md_threshold
||
90 ((md
->md_options
& LNET_MD_MAX_SIZE
) &&
91 md
->md_offset
+ md
->md_max_size
> md
->md_length
));
94 static inline int lnet_md_unlinkable(lnet_libmd_t
*md
)
97 * Should unlink md when its refcount is 0 and either:
98 * - md has been flagged for deletion (by auto unlink or
99 * LNetM[DE]Unlink, in the latter case md may not be exhausted).
100 * - auto unlink is on and md is exhausted.
105 if (md
->md_flags
& LNET_MD_FLAG_ZOMBIE
)
108 return ((md
->md_flags
& LNET_MD_FLAG_AUTO_UNLINK
) &&
109 lnet_md_exhausted(md
));
112 #define lnet_cpt_table() (the_lnet.ln_cpt_table)
113 #define lnet_cpt_current() cfs_cpt_current(the_lnet.ln_cpt_table, 1)
116 lnet_cpt_of_cookie(__u64 cookie
)
118 unsigned int cpt
= (cookie
>> LNET_COOKIE_TYPE_BITS
) & LNET_CPT_MASK
;
121 * LNET_CPT_NUMBER doesn't have to be power2, which means we can
122 * get illegal cpt from it's invalid cookie
124 return cpt
< LNET_CPT_NUMBER
? cpt
: cpt
% LNET_CPT_NUMBER
;
128 lnet_res_lock(int cpt
)
130 cfs_percpt_lock(the_lnet
.ln_res_lock
, cpt
);
134 lnet_res_unlock(int cpt
)
136 cfs_percpt_unlock(the_lnet
.ln_res_lock
, cpt
);
140 lnet_res_lock_current(void)
142 int cpt
= lnet_cpt_current();
149 lnet_net_lock(int cpt
)
151 cfs_percpt_lock(the_lnet
.ln_net_lock
, cpt
);
155 lnet_net_unlock(int cpt
)
157 cfs_percpt_unlock(the_lnet
.ln_net_lock
, cpt
);
161 lnet_net_lock_current(void)
163 int cpt
= lnet_cpt_current();
169 #define LNET_LOCK() lnet_net_lock(LNET_LOCK_EX)
170 #define LNET_UNLOCK() lnet_net_unlock(LNET_LOCK_EX)
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)
179 #define MAX_PORTALS 64
181 static inline lnet_eq_t
*
186 LIBCFS_ALLOC(eq
, sizeof(*eq
));
191 lnet_eq_free(lnet_eq_t
*eq
)
193 LIBCFS_FREE(eq
, sizeof(*eq
));
196 static inline lnet_libmd_t
*
197 lnet_md_alloc(lnet_md_t
*umd
)
203 if (umd
->options
& LNET_MD_KIOV
) {
205 size
= offsetof(lnet_libmd_t
, md_iov
.kiov
[niov
]);
207 niov
= umd
->options
& LNET_MD_IOVEC
? umd
->length
: 1;
208 size
= offsetof(lnet_libmd_t
, md_iov
.iov
[niov
]);
211 LIBCFS_ALLOC(md
, size
);
214 /* Set here in case of early free */
215 md
->md_options
= umd
->options
;
217 INIT_LIST_HEAD(&md
->md_list
);
224 lnet_md_free(lnet_libmd_t
*md
)
228 if (md
->md_options
& LNET_MD_KIOV
)
229 size
= offsetof(lnet_libmd_t
, md_iov
.kiov
[md
->md_niov
]);
231 size
= offsetof(lnet_libmd_t
, md_iov
.iov
[md
->md_niov
]);
233 LIBCFS_FREE(md
, size
);
236 static inline lnet_me_t
*
241 LIBCFS_ALLOC(me
, sizeof(*me
));
246 lnet_me_free(lnet_me_t
*me
)
248 LIBCFS_FREE(me
, sizeof(*me
));
251 static inline lnet_msg_t
*
256 LIBCFS_ALLOC(msg
, sizeof(*msg
));
258 /* no need to zero, LIBCFS_ALLOC does for us */
263 lnet_msg_free(lnet_msg_t
*msg
)
265 LASSERT(!msg
->msg_onactivelist
);
266 LIBCFS_FREE(msg
, sizeof(*msg
));
269 lnet_libhandle_t
*lnet_res_lh_lookup(struct lnet_res_container
*rec
,
271 void lnet_res_lh_initialize(struct lnet_res_container
*rec
,
272 lnet_libhandle_t
*lh
);
274 lnet_res_lh_invalidate(lnet_libhandle_t
*lh
)
276 /* NB: cookie is still useful, don't reset it */
277 list_del(&lh
->lh_hash_chain
);
281 lnet_eq2handle(lnet_handle_eq_t
*handle
, lnet_eq_t
*eq
)
284 LNetInvalidateHandle(handle
);
288 handle
->cookie
= eq
->eq_lh
.lh_cookie
;
291 static inline lnet_eq_t
*
292 lnet_handle2eq(lnet_handle_eq_t
*handle
)
294 lnet_libhandle_t
*lh
;
296 lh
= lnet_res_lh_lookup(&the_lnet
.ln_eq_container
, handle
->cookie
);
300 return lh_entry(lh
, lnet_eq_t
, eq_lh
);
304 lnet_md2handle(lnet_handle_md_t
*handle
, lnet_libmd_t
*md
)
306 handle
->cookie
= md
->md_lh
.lh_cookie
;
309 static inline lnet_libmd_t
*
310 lnet_handle2md(lnet_handle_md_t
*handle
)
312 /* ALWAYS called with resource lock held */
313 lnet_libhandle_t
*lh
;
316 cpt
= lnet_cpt_of_cookie(handle
->cookie
);
317 lh
= lnet_res_lh_lookup(the_lnet
.ln_md_containers
[cpt
],
322 return lh_entry(lh
, lnet_libmd_t
, md_lh
);
325 static inline lnet_libmd_t
*
326 lnet_wire_handle2md(lnet_handle_wire_t
*wh
)
328 /* ALWAYS called with resource lock held */
329 lnet_libhandle_t
*lh
;
332 if (wh
->wh_interface_cookie
!= the_lnet
.ln_interface_cookie
)
335 cpt
= lnet_cpt_of_cookie(wh
->wh_object_cookie
);
336 lh
= lnet_res_lh_lookup(the_lnet
.ln_md_containers
[cpt
],
337 wh
->wh_object_cookie
);
341 return lh_entry(lh
, lnet_libmd_t
, md_lh
);
345 lnet_me2handle(lnet_handle_me_t
*handle
, lnet_me_t
*me
)
347 handle
->cookie
= me
->me_lh
.lh_cookie
;
350 static inline lnet_me_t
*
351 lnet_handle2me(lnet_handle_me_t
*handle
)
353 /* ALWAYS called with resource lock held */
354 lnet_libhandle_t
*lh
;
357 cpt
= lnet_cpt_of_cookie(handle
->cookie
);
358 lh
= lnet_res_lh_lookup(the_lnet
.ln_me_containers
[cpt
],
363 return lh_entry(lh
, lnet_me_t
, me_lh
);
367 lnet_peer_addref_locked(lnet_peer_t
*lp
)
369 LASSERT(lp
->lp_refcount
> 0);
373 void lnet_destroy_peer_locked(lnet_peer_t
*lp
);
376 lnet_peer_decref_locked(lnet_peer_t
*lp
)
378 LASSERT(lp
->lp_refcount
> 0);
380 if (!lp
->lp_refcount
)
381 lnet_destroy_peer_locked(lp
);
385 lnet_isrouter(lnet_peer_t
*lp
)
387 return lp
->lp_rtr_refcount
? 1 : 0;
391 lnet_ni_addref_locked(lnet_ni_t
*ni
, int cpt
)
393 LASSERT(cpt
>= 0 && cpt
< LNET_CPT_NUMBER
);
394 LASSERT(*ni
->ni_refs
[cpt
] >= 0);
396 (*ni
->ni_refs
[cpt
])++;
400 lnet_ni_addref(lnet_ni_t
*ni
)
403 lnet_ni_addref_locked(ni
, 0);
408 lnet_ni_decref_locked(lnet_ni_t
*ni
, int cpt
)
410 LASSERT(cpt
>= 0 && cpt
< LNET_CPT_NUMBER
);
411 LASSERT(*ni
->ni_refs
[cpt
] > 0);
413 (*ni
->ni_refs
[cpt
])--;
417 lnet_ni_decref(lnet_ni_t
*ni
)
420 lnet_ni_decref_locked(ni
, 0);
424 void lnet_ni_free(lnet_ni_t
*ni
);
426 lnet_ni_alloc(__u32 net
, struct cfs_expr_list
*el
, struct list_head
*nilist
);
429 lnet_nid2peerhash(lnet_nid_t nid
)
431 return hash_long(nid
, LNET_PEER_HASH_BITS
);
434 static inline struct list_head
*
435 lnet_net2rnethash(__u32 net
)
437 return &the_lnet
.ln_remote_nets_hash
[(LNET_NETNUM(net
) +
439 ((1U << the_lnet
.ln_remote_nets_hbits
) - 1)];
442 extern lnd_t the_lolnd
;
443 extern int avoid_asym_router_failure
;
445 int lnet_cpt_of_nid_locked(lnet_nid_t nid
);
446 int lnet_cpt_of_nid(lnet_nid_t nid
);
447 lnet_ni_t
*lnet_nid2ni_locked(lnet_nid_t nid
, int cpt
);
448 lnet_ni_t
*lnet_net2ni_locked(__u32 net
, int cpt
);
449 lnet_ni_t
*lnet_net2ni(__u32 net
);
451 extern int portal_rotor
;
453 int lnet_lib_init(void);
454 void lnet_lib_exit(void);
456 int lnet_notify(lnet_ni_t
*ni
, lnet_nid_t peer
, int alive
, unsigned long when
);
457 void lnet_notify_locked(lnet_peer_t
*lp
, int notifylnd
, int alive
,
459 int lnet_add_route(__u32 net
, __u32 hops
, lnet_nid_t gateway_nid
,
460 unsigned int priority
);
461 int lnet_check_routes(void);
462 int lnet_del_route(__u32 net
, lnet_nid_t gw_nid
);
463 void lnet_destroy_routes(void);
464 int lnet_get_route(int idx
, __u32
*net
, __u32
*hops
,
465 lnet_nid_t
*gateway
, __u32
*alive
, __u32
*priority
);
466 int lnet_get_rtr_pool_cfg(int idx
, struct lnet_ioctl_pool_cfg
*pool_cfg
);
468 void lnet_router_debugfs_init(void);
469 void lnet_router_debugfs_fini(void);
470 int lnet_rtrpools_alloc(int im_a_router
);
471 void lnet_destroy_rtrbuf(lnet_rtrbuf_t
*rb
, int npages
);
472 int lnet_rtrpools_adjust(int tiny
, int small
, int large
);
473 int lnet_rtrpools_enable(void);
474 void lnet_rtrpools_disable(void);
475 void lnet_rtrpools_free(int keep_pools
);
476 lnet_remotenet_t
*lnet_find_net_locked(__u32 net
);
477 int lnet_dyn_add_ni(lnet_pid_t requested_pid
,
478 struct lnet_ioctl_config_data
*conf
);
479 int lnet_dyn_del_ni(__u32 net
);
480 int lnet_clear_lazy_portal(struct lnet_ni
*ni
, int portal
, char *reason
);
482 int lnet_islocalnid(lnet_nid_t nid
);
483 int lnet_islocalnet(__u32 net
);
485 void lnet_msg_attach_md(lnet_msg_t
*msg
, lnet_libmd_t
*md
,
486 unsigned int offset
, unsigned int mlen
);
487 void lnet_msg_detach_md(lnet_msg_t
*msg
, int status
);
488 void lnet_build_unlink_event(lnet_libmd_t
*md
, lnet_event_t
*ev
);
489 void lnet_build_msg_event(lnet_msg_t
*msg
, lnet_event_kind_t ev_type
);
490 void lnet_msg_commit(lnet_msg_t
*msg
, int cpt
);
491 void lnet_msg_decommit(lnet_msg_t
*msg
, int cpt
, int status
);
493 void lnet_eq_enqueue_event(lnet_eq_t
*eq
, lnet_event_t
*ev
);
494 void lnet_prep_send(lnet_msg_t
*msg
, int type
, lnet_process_id_t target
,
495 unsigned int offset
, unsigned int len
);
496 int lnet_send(lnet_nid_t nid
, lnet_msg_t
*msg
, lnet_nid_t rtr_nid
);
497 void lnet_return_tx_credits_locked(lnet_msg_t
*msg
);
498 void lnet_return_rx_credits_locked(lnet_msg_t
*msg
);
499 void lnet_schedule_blocked_locked(lnet_rtrbufpool_t
*rbp
);
500 void lnet_drop_routed_msgs_locked(struct list_head
*list
, int cpt
);
502 /* portals functions */
503 /* portals attributes */
505 lnet_ptl_is_lazy(lnet_portal_t
*ptl
)
507 return !!(ptl
->ptl_options
& LNET_PTL_LAZY
);
511 lnet_ptl_is_unique(lnet_portal_t
*ptl
)
513 return !!(ptl
->ptl_options
& LNET_PTL_MATCH_UNIQUE
);
517 lnet_ptl_is_wildcard(lnet_portal_t
*ptl
)
519 return !!(ptl
->ptl_options
& LNET_PTL_MATCH_WILDCARD
);
523 lnet_ptl_setopt(lnet_portal_t
*ptl
, int opt
)
525 ptl
->ptl_options
|= opt
;
529 lnet_ptl_unsetopt(lnet_portal_t
*ptl
, int opt
)
531 ptl
->ptl_options
&= ~opt
;
534 /* match-table functions */
535 struct list_head
*lnet_mt_match_head(struct lnet_match_table
*mtable
,
536 lnet_process_id_t id
, __u64 mbits
);
537 struct lnet_match_table
*lnet_mt_of_attach(unsigned int index
,
538 lnet_process_id_t id
, __u64 mbits
,
541 int lnet_mt_match_md(struct lnet_match_table
*mtable
,
542 struct lnet_match_info
*info
, struct lnet_msg
*msg
);
544 /* portals match/attach functions */
545 void lnet_ptl_attach_md(lnet_me_t
*me
, lnet_libmd_t
*md
,
546 struct list_head
*matches
, struct list_head
*drops
);
547 void lnet_ptl_detach_md(lnet_me_t
*me
, lnet_libmd_t
*md
);
548 int lnet_ptl_match_md(struct lnet_match_info
*info
, struct lnet_msg
*msg
);
550 /* initialized and finalize portals */
551 int lnet_portals_create(void);
552 void lnet_portals_destroy(void);
554 /* message functions */
555 int lnet_parse(lnet_ni_t
*ni
, lnet_hdr_t
*hdr
,
556 lnet_nid_t fromnid
, void *private, int rdma_req
);
557 int lnet_parse_local(lnet_ni_t
*ni
, lnet_msg_t
*msg
);
558 int lnet_parse_forward_locked(lnet_ni_t
*ni
, lnet_msg_t
*msg
);
560 void lnet_recv(lnet_ni_t
*ni
, void *private, lnet_msg_t
*msg
, int delayed
,
561 unsigned int offset
, unsigned int mlen
, unsigned int rlen
);
562 void lnet_ni_recv(lnet_ni_t
*ni
, void *private, lnet_msg_t
*msg
,
563 int delayed
, unsigned int offset
,
564 unsigned int mlen
, unsigned int rlen
);
566 lnet_msg_t
*lnet_create_reply_msg(lnet_ni_t
*ni
, lnet_msg_t
*get_msg
);
567 void lnet_set_reply_msg_len(lnet_ni_t
*ni
, lnet_msg_t
*msg
, unsigned int len
);
569 void lnet_finalize(lnet_ni_t
*ni
, lnet_msg_t
*msg
, int rc
);
571 void lnet_drop_message(lnet_ni_t
*ni
, int cpt
, void *private,
573 void lnet_drop_delayed_msg_list(struct list_head
*head
, char *reason
);
574 void lnet_recv_delayed_msg_list(struct list_head
*head
);
576 int lnet_msg_container_setup(struct lnet_msg_container
*container
, int cpt
);
577 void lnet_msg_container_cleanup(struct lnet_msg_container
*container
);
578 void lnet_msg_containers_destroy(void);
579 int lnet_msg_containers_create(void);
581 char *lnet_msgtyp2str(int type
);
582 void lnet_print_hdr(lnet_hdr_t
*hdr
);
583 int lnet_fail_nid(lnet_nid_t nid
, unsigned int threshold
);
585 /** \addtogroup lnet_fault_simulation @{ */
587 int lnet_fault_ctl(int cmd
, struct libcfs_ioctl_data
*data
);
588 int lnet_fault_init(void);
589 void lnet_fault_fini(void);
591 bool lnet_drop_rule_match(lnet_hdr_t
*hdr
);
593 int lnet_delay_rule_add(struct lnet_fault_attr
*attr
);
594 int lnet_delay_rule_del(lnet_nid_t src
, lnet_nid_t dst
, bool shutdown
);
595 int lnet_delay_rule_list(int pos
, struct lnet_fault_attr
*attr
,
596 struct lnet_fault_stat
*stat
);
597 void lnet_delay_rule_reset(void);
598 void lnet_delay_rule_check(void);
599 bool lnet_delay_rule_match_locked(lnet_hdr_t
*hdr
, struct lnet_msg
*msg
);
601 /** @} lnet_fault_simulation */
603 void lnet_counters_get(lnet_counters_t
*counters
);
604 void lnet_counters_reset(void);
606 unsigned int lnet_iov_nob(unsigned int niov
, struct kvec
*iov
);
607 int lnet_extract_iov(int dst_niov
, struct kvec
*dst
,
608 int src_niov
, const struct kvec
*src
,
609 unsigned int offset
, unsigned int len
);
611 unsigned int lnet_kiov_nob(unsigned int niov
, lnet_kiov_t
*iov
);
612 int lnet_extract_kiov(int dst_niov
, lnet_kiov_t
*dst
,
613 int src_niov
, const lnet_kiov_t
*src
,
614 unsigned int offset
, unsigned int len
);
616 void lnet_copy_iov2iter(struct iov_iter
*to
,
617 unsigned int nsiov
, const struct kvec
*siov
,
618 unsigned int soffset
, unsigned int nob
);
619 void lnet_copy_kiov2iter(struct iov_iter
*to
,
620 unsigned int nkiov
, const lnet_kiov_t
*kiov
,
621 unsigned int kiovoffset
, unsigned int nob
);
623 void lnet_me_unlink(lnet_me_t
*me
);
625 void lnet_md_unlink(lnet_libmd_t
*md
);
626 void lnet_md_deconstruct(lnet_libmd_t
*lmd
, lnet_md_t
*umd
);
628 void lnet_register_lnd(lnd_t
*lnd
);
629 void lnet_unregister_lnd(lnd_t
*lnd
);
631 int lnet_connect(struct socket
**sockp
, lnet_nid_t peer_nid
,
632 __u32 local_ip
, __u32 peer_ip
, int peer_port
);
633 void lnet_connect_console_error(int rc
, lnet_nid_t peer_nid
,
634 __u32 peer_ip
, int port
);
635 int lnet_count_acceptor_nis(void);
636 int lnet_acceptor_timeout(void);
637 int lnet_acceptor_port(void);
639 int lnet_count_acceptor_nis(void);
640 int lnet_acceptor_port(void);
642 int lnet_acceptor_start(void);
643 void lnet_acceptor_stop(void);
645 int lnet_ipif_query(char *name
, int *up
, __u32
*ip
, __u32
*mask
);
646 int lnet_ipif_enumerate(char ***names
);
647 void lnet_ipif_free_enumeration(char **names
, int n
);
648 int lnet_sock_setbuf(struct socket
*socket
, int txbufsize
, int rxbufsize
);
649 int lnet_sock_getbuf(struct socket
*socket
, int *txbufsize
, int *rxbufsize
);
650 int lnet_sock_getaddr(struct socket
*socket
, bool remote
, __u32
*ip
, int *port
);
651 int lnet_sock_write(struct socket
*sock
, void *buffer
, int nob
, int timeout
);
652 int lnet_sock_read(struct socket
*sock
, void *buffer
, int nob
, int timeout
);
654 int lnet_sock_listen(struct socket
**sockp
, __u32 ip
, int port
, int backlog
);
655 int lnet_sock_accept(struct socket
**newsockp
, struct socket
*sock
);
656 int lnet_sock_connect(struct socket
**sockp
, int *fatal
,
657 __u32 local_ip
, int local_port
,
658 __u32 peer_ip
, int peer_port
);
659 void libcfs_sock_release(struct socket
*sock
);
661 int lnet_peers_start_down(void);
662 int lnet_peer_buffer_credits(lnet_ni_t
*ni
);
664 int lnet_router_checker_start(void);
665 void lnet_router_checker_stop(void);
666 void lnet_router_ni_update_locked(lnet_peer_t
*gw
, __u32 net
);
667 void lnet_swap_pinginfo(lnet_ping_info_t
*info
);
669 int lnet_parse_ip2nets(char **networksp
, char *ip2nets
);
670 int lnet_parse_routes(char *route_str
, int *im_a_router
);
671 int lnet_parse_networks(struct list_head
*nilist
, char *networks
);
672 int lnet_net_unique(__u32 net
, struct list_head
*nilist
);
674 int lnet_nid2peer_locked(lnet_peer_t
**lpp
, lnet_nid_t nid
, int cpt
);
675 lnet_peer_t
*lnet_find_peer_locked(struct lnet_peer_table
*ptable
,
677 void lnet_peer_tables_cleanup(lnet_ni_t
*ni
);
678 void lnet_peer_tables_destroy(void);
679 int lnet_peer_tables_create(void);
680 void lnet_debug_peer(lnet_nid_t nid
);
681 int lnet_get_peer_info(__u32 peer_index
, __u64
*nid
,
682 char alivness
[LNET_MAX_STR_LEN
],
683 __u32
*cpt_iter
, __u32
*refcount
,
684 __u32
*ni_peer_tx_credits
, __u32
*peer_tx_credits
,
685 __u32
*peer_rtr_credits
, __u32
*peer_min_rtr_credtis
,
686 __u32
*peer_tx_qnob
);
689 lnet_peer_set_alive(lnet_peer_t
*lp
)
691 lp
->lp_last_query
= jiffies
;
692 lp
->lp_last_alive
= jiffies
;
694 lnet_notify_locked(lp
, 0, 1, lp
->lp_last_alive
);