Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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 |
James Simmons | 4f3ca89 | 2015-06-11 15:18:15 -0400 | [diff] [blame] | 18 | * http://www.gnu.org/licenses/gpl-2.0.html |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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 | * |
Andreas Dilger | 1dc563a | 2015-11-08 18:09:37 -0500 | [diff] [blame] | 26 | * Copyright (c) 2012, 2015, Intel Corporation. |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 27 | */ |
| 28 | /* |
| 29 | * This file is part of Lustre, http://www.lustre.org/ |
James Simmons | 4f3ca89 | 2015-06-11 15:18:15 -0400 | [diff] [blame] | 30 | * Lustre is a trademark of Seagate, Inc. |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 31 | * |
| 32 | * lnet/include/lnet/lib-lnet.h |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 33 | */ |
| 34 | |
| 35 | #ifndef __LNET_LIB_LNET_H__ |
| 36 | #define __LNET_LIB_LNET_H__ |
| 37 | |
Greg Kroah-Hartman | 9fdaf8c | 2014-07-11 20:51:16 -0700 | [diff] [blame] | 38 | #include "../libcfs/libcfs.h" |
James Simmons | bbf00c3 | 2015-06-11 15:18:11 -0400 | [diff] [blame] | 39 | #include "api.h" |
Greg Kroah-Hartman | 9fdaf8c | 2014-07-11 20:51:16 -0700 | [diff] [blame] | 40 | #include "lnet.h" |
| 41 | #include "lib-types.h" |
Amir Shehata | edeb5d8 | 2016-02-22 17:29:05 -0500 | [diff] [blame] | 42 | #include "lib-dlc.h" |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 43 | |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 44 | extern lnet_t the_lnet; /* THE network */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 45 | |
John L. Hammond | d9c9061 | 2015-06-03 16:43:20 -0400 | [diff] [blame] | 46 | #if (BITS_PER_LONG == 32) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 47 | /* 2 CPTs, allowing more CPTs might make us under memory pressure */ |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 48 | #define LNET_CPT_MAX_BITS 1 |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 49 | |
John L. Hammond | d9c9061 | 2015-06-03 16:43:20 -0400 | [diff] [blame] | 50 | #else /* 64-bit system */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 51 | /* |
| 52 | * 256 CPTs for thousands of CPUs, allowing more CPTs might make us |
| 53 | * under risk of consuming all lh_cookie. |
| 54 | */ |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 55 | #define LNET_CPT_MAX_BITS 8 |
John L. Hammond | d9c9061 | 2015-06-03 16:43:20 -0400 | [diff] [blame] | 56 | #endif /* BITS_PER_LONG == 32 */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 57 | |
| 58 | /* max allowed CPT number */ |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 59 | #define LNET_CPT_MAX (1 << LNET_CPT_MAX_BITS) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 60 | |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 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) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 64 | |
| 65 | /** exclusive lock */ |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 66 | #define LNET_LOCK_EX CFS_PERCPT_LOCK_EX |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 67 | |
Chris Horn | 4ee23a8 | 2016-02-15 10:25:46 -0500 | [diff] [blame] | 68 | static inline int lnet_is_route_alive(lnet_route_t *route) |
| 69 | { |
| 70 | /* gateway is down */ |
| 71 | if (!route->lr_gateway->lp_alive) |
| 72 | return 0; |
| 73 | /* no NI status, assume it's alive */ |
| 74 | if ((route->lr_gateway->lp_ping_feats & |
| 75 | LNET_PING_FEAT_NI_STATUS) == 0) |
| 76 | return 1; |
| 77 | /* has NI status, check # down NIs */ |
| 78 | return route->lr_downis == 0; |
| 79 | } |
| 80 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 81 | static inline int lnet_is_wire_handle_none(lnet_handle_wire_t *wh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 82 | { |
| 83 | return (wh->wh_interface_cookie == LNET_WIRE_HANDLE_COOKIE_NONE && |
| 84 | wh->wh_object_cookie == LNET_WIRE_HANDLE_COOKIE_NONE); |
| 85 | } |
| 86 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 87 | static inline int lnet_md_exhausted(lnet_libmd_t *md) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 88 | { |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 89 | return (!md->md_threshold || |
| 90 | ((md->md_options & LNET_MD_MAX_SIZE) && |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 91 | md->md_offset + md->md_max_size > md->md_length)); |
| 92 | } |
| 93 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 94 | static inline int lnet_md_unlinkable(lnet_libmd_t *md) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 95 | { |
James Simmons | 4420cfd | 2016-02-12 12:06:00 -0500 | [diff] [blame] | 96 | /* |
| 97 | * Should unlink md when its refcount is 0 and either: |
Aybuke Ozdemir | 2b06b70 | 2014-09-23 01:53:24 +0300 | [diff] [blame] | 98 | * - md has been flagged for deletion (by auto unlink or |
| 99 | * LNetM[DE]Unlink, in the latter case md may not be exhausted). |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 100 | * - auto unlink is on and md is exhausted. |
| 101 | */ |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 102 | if (md->md_refcount) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 103 | return 0; |
| 104 | |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 105 | if (md->md_flags & LNET_MD_FLAG_ZOMBIE) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 106 | return 1; |
| 107 | |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 108 | return ((md->md_flags & LNET_MD_FLAG_AUTO_UNLINK) && |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 109 | lnet_md_exhausted(md)); |
| 110 | } |
| 111 | |
| 112 | #define lnet_cpt_table() (the_lnet.ln_cpt_table) |
| 113 | #define lnet_cpt_current() cfs_cpt_current(the_lnet.ln_cpt_table, 1) |
| 114 | |
| 115 | static inline int |
| 116 | lnet_cpt_of_cookie(__u64 cookie) |
| 117 | { |
| 118 | unsigned int cpt = (cookie >> LNET_COOKIE_TYPE_BITS) & LNET_CPT_MASK; |
| 119 | |
James Simmons | 4420cfd | 2016-02-12 12:06:00 -0500 | [diff] [blame] | 120 | /* |
| 121 | * LNET_CPT_NUMBER doesn't have to be power2, which means we can |
| 122 | * get illegal cpt from it's invalid cookie |
| 123 | */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 178 | |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 179 | #define MAX_PORTALS 64 |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 180 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 181 | static inline lnet_eq_t * |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 182 | lnet_eq_alloc(void) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 183 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 184 | lnet_eq_t *eq; |
| 185 | |
| 186 | LIBCFS_ALLOC(eq, sizeof(*eq)); |
Lisa Nguyen | 0281639 | 2013-10-21 21:52:03 -0700 | [diff] [blame] | 187 | return eq; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 188 | } |
| 189 | |
| 190 | static inline void |
| 191 | lnet_eq_free(lnet_eq_t *eq) |
| 192 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 193 | LIBCFS_FREE(eq, sizeof(*eq)); |
| 194 | } |
| 195 | |
| 196 | static inline lnet_libmd_t * |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 197 | lnet_md_alloc(lnet_md_t *umd) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 198 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 199 | lnet_libmd_t *md; |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 200 | unsigned int size; |
| 201 | unsigned int niov; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 202 | |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 203 | if (umd->options & LNET_MD_KIOV) { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 204 | niov = umd->length; |
| 205 | size = offsetof(lnet_libmd_t, md_iov.kiov[niov]); |
| 206 | } else { |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 207 | niov = umd->options & LNET_MD_IOVEC ? umd->length : 1; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 208 | size = offsetof(lnet_libmd_t, md_iov.iov[niov]); |
| 209 | } |
| 210 | |
| 211 | LIBCFS_ALLOC(md, size); |
| 212 | |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 213 | if (md) { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 214 | /* Set here in case of early free */ |
| 215 | md->md_options = umd->options; |
| 216 | md->md_niov = niov; |
| 217 | INIT_LIST_HEAD(&md->md_list); |
| 218 | } |
| 219 | |
Lisa Nguyen | 0281639 | 2013-10-21 21:52:03 -0700 | [diff] [blame] | 220 | return md; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 221 | } |
| 222 | |
| 223 | static inline void |
| 224 | lnet_md_free(lnet_libmd_t *md) |
| 225 | { |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 226 | unsigned int size; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 227 | |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 228 | if (md->md_options & LNET_MD_KIOV) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 229 | size = offsetof(lnet_libmd_t, md_iov.kiov[md->md_niov]); |
| 230 | else |
| 231 | size = offsetof(lnet_libmd_t, md_iov.iov[md->md_niov]); |
| 232 | |
| 233 | LIBCFS_FREE(md, size); |
| 234 | } |
| 235 | |
| 236 | static inline lnet_me_t * |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 237 | lnet_me_alloc(void) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 238 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 239 | lnet_me_t *me; |
| 240 | |
| 241 | LIBCFS_ALLOC(me, sizeof(*me)); |
Lisa Nguyen | 0281639 | 2013-10-21 21:52:03 -0700 | [diff] [blame] | 242 | return me; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 243 | } |
| 244 | |
| 245 | static inline void |
| 246 | lnet_me_free(lnet_me_t *me) |
| 247 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 248 | LIBCFS_FREE(me, sizeof(*me)); |
| 249 | } |
| 250 | |
| 251 | static inline lnet_msg_t * |
| 252 | lnet_msg_alloc(void) |
| 253 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 254 | lnet_msg_t *msg; |
| 255 | |
| 256 | LIBCFS_ALLOC(msg, sizeof(*msg)); |
| 257 | |
| 258 | /* no need to zero, LIBCFS_ALLOC does for us */ |
Lisa Nguyen | 0281639 | 2013-10-21 21:52:03 -0700 | [diff] [blame] | 259 | return msg; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 260 | } |
| 261 | |
| 262 | static inline void |
| 263 | lnet_msg_free(lnet_msg_t *msg) |
| 264 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 265 | LASSERT(!msg->msg_onactivelist); |
| 266 | LIBCFS_FREE(msg, sizeof(*msg)); |
| 267 | } |
| 268 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 269 | lnet_libhandle_t *lnet_res_lh_lookup(struct lnet_res_container *rec, |
| 270 | __u64 cookie); |
| 271 | void lnet_res_lh_initialize(struct lnet_res_container *rec, |
| 272 | lnet_libhandle_t *lh); |
| 273 | static inline void |
| 274 | lnet_res_lh_invalidate(lnet_libhandle_t *lh) |
| 275 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 276 | /* NB: cookie is still useful, don't reset it */ |
| 277 | list_del(&lh->lh_hash_chain); |
| 278 | } |
| 279 | |
| 280 | static inline void |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 281 | lnet_eq2handle(lnet_handle_eq_t *handle, lnet_eq_t *eq) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 282 | { |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 283 | if (!eq) { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 284 | LNetInvalidateHandle(handle); |
| 285 | return; |
| 286 | } |
| 287 | |
| 288 | handle->cookie = eq->eq_lh.lh_cookie; |
| 289 | } |
| 290 | |
| 291 | static inline lnet_eq_t * |
| 292 | lnet_handle2eq(lnet_handle_eq_t *handle) |
| 293 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 294 | lnet_libhandle_t *lh; |
| 295 | |
| 296 | lh = lnet_res_lh_lookup(&the_lnet.ln_eq_container, handle->cookie); |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 297 | if (!lh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 298 | return NULL; |
| 299 | |
| 300 | return lh_entry(lh, lnet_eq_t, eq_lh); |
| 301 | } |
| 302 | |
| 303 | static inline void |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 304 | lnet_md2handle(lnet_handle_md_t *handle, lnet_libmd_t *md) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 305 | { |
| 306 | handle->cookie = md->md_lh.lh_cookie; |
| 307 | } |
| 308 | |
| 309 | static inline lnet_libmd_t * |
| 310 | lnet_handle2md(lnet_handle_md_t *handle) |
| 311 | { |
| 312 | /* ALWAYS called with resource lock held */ |
| 313 | lnet_libhandle_t *lh; |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 314 | int cpt; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 315 | |
| 316 | cpt = lnet_cpt_of_cookie(handle->cookie); |
| 317 | lh = lnet_res_lh_lookup(the_lnet.ln_md_containers[cpt], |
| 318 | handle->cookie); |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 319 | if (!lh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 320 | return NULL; |
| 321 | |
| 322 | return lh_entry(lh, lnet_libmd_t, md_lh); |
| 323 | } |
| 324 | |
| 325 | static inline lnet_libmd_t * |
| 326 | lnet_wire_handle2md(lnet_handle_wire_t *wh) |
| 327 | { |
| 328 | /* ALWAYS called with resource lock held */ |
| 329 | lnet_libhandle_t *lh; |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 330 | int cpt; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 331 | |
| 332 | if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie) |
| 333 | return NULL; |
| 334 | |
| 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); |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 338 | if (!lh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 339 | return NULL; |
| 340 | |
| 341 | return lh_entry(lh, lnet_libmd_t, md_lh); |
| 342 | } |
| 343 | |
| 344 | static inline void |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 345 | lnet_me2handle(lnet_handle_me_t *handle, lnet_me_t *me) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 346 | { |
| 347 | handle->cookie = me->me_lh.lh_cookie; |
| 348 | } |
| 349 | |
| 350 | static inline lnet_me_t * |
| 351 | lnet_handle2me(lnet_handle_me_t *handle) |
| 352 | { |
| 353 | /* ALWAYS called with resource lock held */ |
| 354 | lnet_libhandle_t *lh; |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 355 | int cpt; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 356 | |
| 357 | cpt = lnet_cpt_of_cookie(handle->cookie); |
| 358 | lh = lnet_res_lh_lookup(the_lnet.ln_me_containers[cpt], |
| 359 | handle->cookie); |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 360 | if (!lh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 361 | return NULL; |
| 362 | |
| 363 | return lh_entry(lh, lnet_me_t, me_lh); |
| 364 | } |
| 365 | |
| 366 | static inline void |
| 367 | lnet_peer_addref_locked(lnet_peer_t *lp) |
| 368 | { |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 369 | LASSERT(lp->lp_refcount > 0); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 370 | lp->lp_refcount++; |
| 371 | } |
| 372 | |
Greg Kroah-Hartman | 0ee98a9 | 2014-07-11 18:44:57 -0700 | [diff] [blame] | 373 | void lnet_destroy_peer_locked(lnet_peer_t *lp); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 374 | |
| 375 | static inline void |
| 376 | lnet_peer_decref_locked(lnet_peer_t *lp) |
| 377 | { |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 378 | LASSERT(lp->lp_refcount > 0); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 379 | lp->lp_refcount--; |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 380 | if (!lp->lp_refcount) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 381 | lnet_destroy_peer_locked(lp); |
| 382 | } |
| 383 | |
| 384 | static inline int |
| 385 | lnet_isrouter(lnet_peer_t *lp) |
| 386 | { |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 387 | return lp->lp_rtr_refcount ? 1 : 0; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | static inline void |
| 391 | lnet_ni_addref_locked(lnet_ni_t *ni, int cpt) |
| 392 | { |
| 393 | LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER); |
| 394 | LASSERT(*ni->ni_refs[cpt] >= 0); |
| 395 | |
| 396 | (*ni->ni_refs[cpt])++; |
| 397 | } |
| 398 | |
| 399 | static inline void |
| 400 | lnet_ni_addref(lnet_ni_t *ni) |
| 401 | { |
| 402 | lnet_net_lock(0); |
| 403 | lnet_ni_addref_locked(ni, 0); |
| 404 | lnet_net_unlock(0); |
| 405 | } |
| 406 | |
| 407 | static inline void |
| 408 | lnet_ni_decref_locked(lnet_ni_t *ni, int cpt) |
| 409 | { |
| 410 | LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER); |
| 411 | LASSERT(*ni->ni_refs[cpt] > 0); |
| 412 | |
| 413 | (*ni->ni_refs[cpt])--; |
| 414 | } |
| 415 | |
| 416 | static inline void |
| 417 | lnet_ni_decref(lnet_ni_t *ni) |
| 418 | { |
| 419 | lnet_net_lock(0); |
| 420 | lnet_ni_decref_locked(ni, 0); |
| 421 | lnet_net_unlock(0); |
| 422 | } |
| 423 | |
| 424 | void lnet_ni_free(lnet_ni_t *ni); |
Amir Shehata | 9c26b89 | 2016-02-22 17:29:08 -0500 | [diff] [blame] | 425 | lnet_ni_t * |
| 426 | lnet_ni_alloc(__u32 net, struct cfs_expr_list *el, struct list_head *nilist); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 427 | |
| 428 | static inline int |
| 429 | lnet_nid2peerhash(lnet_nid_t nid) |
| 430 | { |
Peng Tao | 72c0824 | 2014-02-12 19:21:39 +0800 | [diff] [blame] | 431 | return hash_long(nid, LNET_PEER_HASH_BITS); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 432 | } |
| 433 | |
| 434 | static inline struct list_head * |
| 435 | lnet_net2rnethash(__u32 net) |
| 436 | { |
| 437 | return &the_lnet.ln_remote_nets_hash[(LNET_NETNUM(net) + |
| 438 | LNET_NETTYP(net)) & |
| 439 | ((1U << the_lnet.ln_remote_nets_hbits) - 1)]; |
| 440 | } |
| 441 | |
| 442 | extern lnd_t the_lolnd; |
Liang Zhen | af3fa7c | 2015-02-01 21:52:06 -0500 | [diff] [blame] | 443 | extern int avoid_asym_router_failure; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 444 | |
Greg Kroah-Hartman | 0ee98a9 | 2014-07-11 18:44:57 -0700 | [diff] [blame] | 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); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 450 | |
Frank Zago | 505510f | 2016-02-22 17:29:10 -0500 | [diff] [blame] | 451 | extern int portal_rotor; |
| 452 | |
Andreas Dilger | e0f9411 | 2016-02-26 11:36:05 -0500 | [diff] [blame] | 453 | int lnet_lib_init(void); |
| 454 | void lnet_lib_exit(void); |
James Simmons | a9cf72b | 2015-06-11 15:18:13 -0400 | [diff] [blame] | 455 | |
Greg Kroah-Hartman | a649ad1 | 2014-07-12 00:27:46 -0700 | [diff] [blame] | 456 | int lnet_notify(lnet_ni_t *ni, lnet_nid_t peer, int alive, unsigned long when); |
Aybuke Ozdemir | 2b06b70 | 2014-09-23 01:53:24 +0300 | [diff] [blame] | 457 | void lnet_notify_locked(lnet_peer_t *lp, int notifylnd, int alive, |
| 458 | unsigned long when); |
Amir Shehata | b9bbb61 | 2016-03-02 17:01:46 -0500 | [diff] [blame] | 459 | int lnet_add_route(__u32 net, __u32 hops, lnet_nid_t gateway_nid, |
Doug Oucharek | e75fb87 | 2013-12-09 22:56:54 +0800 | [diff] [blame] | 460 | unsigned int priority); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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, |
Doug Oucharek | e75fb87 | 2013-12-09 22:56:54 +0800 | [diff] [blame] | 465 | lnet_nid_t *gateway, __u32 *alive, __u32 *priority); |
Amir Shehata | edeb5d8 | 2016-02-22 17:29:05 -0500 | [diff] [blame] | 466 | int lnet_get_rtr_pool_cfg(int idx, struct lnet_ioctl_pool_cfg *pool_cfg); |
| 467 | |
Oleg Drokin | b03f395 | 2015-09-14 18:41:17 -0400 | [diff] [blame] | 468 | void lnet_router_debugfs_init(void); |
| 469 | void lnet_router_debugfs_fini(void); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 470 | int lnet_rtrpools_alloc(int im_a_router); |
Amir Shehata | 86ef625 | 2016-02-15 10:25:53 -0500 | [diff] [blame] | 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); |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 476 | lnet_remotenet_t *lnet_find_net_locked(__u32 net); |
Amir Shehata | d76d938 | 2016-05-06 21:30:22 -0400 | [diff] [blame] | 477 | int lnet_dyn_add_ni(lnet_pid_t requested_pid, |
| 478 | struct lnet_ioctl_config_data *conf); |
Amir Shehata | edeb5d8 | 2016-02-22 17:29:05 -0500 | [diff] [blame] | 479 | int lnet_dyn_del_ni(__u32 net); |
Amir Shehata | 1a9be84 | 2016-02-22 17:29:19 -0500 | [diff] [blame] | 480 | int lnet_clear_lazy_portal(struct lnet_ni *ni, int portal, char *reason); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 481 | |
| 482 | int lnet_islocalnid(lnet_nid_t nid); |
| 483 | int lnet_islocalnet(__u32 net); |
| 484 | |
| 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); |
| 492 | |
| 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); |
Amir Shehata | 86ef625 | 2016-02-15 10:25:53 -0500 | [diff] [blame] | 499 | void lnet_schedule_blocked_locked(lnet_rtrbufpool_t *rbp); |
| 500 | void lnet_drop_routed_msgs_locked(struct list_head *list, int cpt); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 501 | |
| 502 | /* portals functions */ |
| 503 | /* portals attributes */ |
| 504 | static inline int |
| 505 | lnet_ptl_is_lazy(lnet_portal_t *ptl) |
| 506 | { |
| 507 | return !!(ptl->ptl_options & LNET_PTL_LAZY); |
| 508 | } |
| 509 | |
| 510 | static inline int |
| 511 | lnet_ptl_is_unique(lnet_portal_t *ptl) |
| 512 | { |
| 513 | return !!(ptl->ptl_options & LNET_PTL_MATCH_UNIQUE); |
| 514 | } |
| 515 | |
| 516 | static inline int |
| 517 | lnet_ptl_is_wildcard(lnet_portal_t *ptl) |
| 518 | { |
| 519 | return !!(ptl->ptl_options & LNET_PTL_MATCH_WILDCARD); |
| 520 | } |
| 521 | |
| 522 | static inline void |
| 523 | lnet_ptl_setopt(lnet_portal_t *ptl, int opt) |
| 524 | { |
| 525 | ptl->ptl_options |= opt; |
| 526 | } |
| 527 | |
| 528 | static inline void |
| 529 | lnet_ptl_unsetopt(lnet_portal_t *ptl, int opt) |
| 530 | { |
| 531 | ptl->ptl_options &= ~opt; |
| 532 | } |
| 533 | |
| 534 | /* match-table functions */ |
| 535 | struct list_head *lnet_mt_match_head(struct lnet_match_table *mtable, |
Greg Kroah-Hartman | 09bce33 | 2014-07-11 18:44:39 -0700 | [diff] [blame] | 536 | lnet_process_id_t id, __u64 mbits); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 537 | struct lnet_match_table *lnet_mt_of_attach(unsigned int index, |
| 538 | lnet_process_id_t id, __u64 mbits, |
| 539 | __u64 ignore_bits, |
| 540 | lnet_ins_pos_t pos); |
| 541 | int lnet_mt_match_md(struct lnet_match_table *mtable, |
| 542 | struct lnet_match_info *info, struct lnet_msg *msg); |
| 543 | |
| 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); |
| 549 | |
| 550 | /* initialized and finalize portals */ |
| 551 | int lnet_portals_create(void); |
| 552 | void lnet_portals_destroy(void); |
| 553 | |
| 554 | /* message functions */ |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 555 | int lnet_parse(lnet_ni_t *ni, lnet_hdr_t *hdr, |
Greg Kroah-Hartman | 09bce33 | 2014-07-11 18:44:39 -0700 | [diff] [blame] | 556 | lnet_nid_t fromnid, void *private, int rdma_req); |
Liang Zhen | b7acfc9 | 2016-03-07 18:10:17 -0500 | [diff] [blame] | 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); |
| 559 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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); |
Liang Zhen | b7acfc9 | 2016-03-07 18:10:17 -0500 | [diff] [blame] | 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); |
| 565 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 566 | lnet_msg_t *lnet_create_reply_msg(lnet_ni_t *ni, lnet_msg_t *get_msg); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 567 | void lnet_set_reply_msg_len(lnet_ni_t *ni, lnet_msg_t *msg, unsigned int len); |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 568 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 569 | void lnet_finalize(lnet_ni_t *ni, lnet_msg_t *msg, int rc); |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 570 | |
Liang Zhen | b7acfc9 | 2016-03-07 18:10:17 -0500 | [diff] [blame] | 571 | void lnet_drop_message(lnet_ni_t *ni, int cpt, void *private, |
| 572 | unsigned int nob); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 573 | void lnet_drop_delayed_msg_list(struct list_head *head, char *reason); |
| 574 | void lnet_recv_delayed_msg_list(struct list_head *head); |
| 575 | |
| 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); |
| 580 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 581 | char *lnet_msgtyp2str(int type); |
Lisa Nguyen | ac0a287 | 2013-10-21 21:52:29 -0700 | [diff] [blame] | 582 | void lnet_print_hdr(lnet_hdr_t *hdr); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 583 | int lnet_fail_nid(lnet_nid_t nid, unsigned int threshold); |
| 584 | |
Liang Zhen | 0fbbced | 2016-03-07 18:10:16 -0500 | [diff] [blame] | 585 | /** \addtogroup lnet_fault_simulation @{ */ |
| 586 | |
| 587 | int lnet_fault_ctl(int cmd, struct libcfs_ioctl_data *data); |
| 588 | int lnet_fault_init(void); |
| 589 | void lnet_fault_fini(void); |
| 590 | |
| 591 | bool lnet_drop_rule_match(lnet_hdr_t *hdr); |
| 592 | |
Liang Zhen | b7acfc9 | 2016-03-07 18:10:17 -0500 | [diff] [blame] | 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); |
| 600 | |
Liang Zhen | 0fbbced | 2016-03-07 18:10:16 -0500 | [diff] [blame] | 601 | /** @} lnet_fault_simulation */ |
| 602 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 603 | void lnet_counters_get(lnet_counters_t *counters); |
| 604 | void lnet_counters_reset(void); |
| 605 | |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 606 | unsigned int lnet_iov_nob(unsigned int niov, struct kvec *iov); |
| 607 | int lnet_extract_iov(int dst_niov, struct kvec *dst, |
Al Viro | 03766dc | 2016-08-20 17:34:22 -0400 | [diff] [blame] | 608 | int src_niov, const struct kvec *src, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 609 | unsigned int offset, unsigned int len); |
| 610 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 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, |
Al Viro | 03766dc | 2016-08-20 17:34:22 -0400 | [diff] [blame] | 613 | int src_niov, const lnet_kiov_t *src, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 614 | unsigned int offset, unsigned int len); |
| 615 | |
Al Viro | 4cae780 | 2016-08-20 17:34:24 -0400 | [diff] [blame] | 616 | void lnet_copy_iov2iter(struct iov_iter *to, |
Al Viro | 03766dc | 2016-08-20 17:34:22 -0400 | [diff] [blame] | 617 | unsigned int nsiov, const struct kvec *siov, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 618 | unsigned int soffset, unsigned int nob); |
Al Viro | 4cae780 | 2016-08-20 17:34:24 -0400 | [diff] [blame] | 619 | void lnet_copy_kiov2iter(struct iov_iter *to, |
Al Viro | 03766dc | 2016-08-20 17:34:22 -0400 | [diff] [blame] | 620 | unsigned int nkiov, const lnet_kiov_t *kiov, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 621 | unsigned int kiovoffset, unsigned int nob); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 622 | |
| 623 | void lnet_me_unlink(lnet_me_t *me); |
| 624 | |
| 625 | void lnet_md_unlink(lnet_libmd_t *md); |
| 626 | void lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd); |
| 627 | |
| 628 | void lnet_register_lnd(lnd_t *lnd); |
| 629 | void lnet_unregister_lnd(lnd_t *lnd); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 630 | |
Greg Kroah-Hartman | e327dc8 | 2014-07-11 23:42:52 -0700 | [diff] [blame] | 631 | int lnet_connect(struct socket **sockp, lnet_nid_t peer_nid, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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); |
| 638 | |
| 639 | int lnet_count_acceptor_nis(void); |
| 640 | int lnet_acceptor_port(void); |
| 641 | |
| 642 | int lnet_acceptor_start(void); |
| 643 | void lnet_acceptor_stop(void); |
| 644 | |
James Simmons | 1ad6a73 | 2015-06-08 22:27:10 -0400 | [diff] [blame] | 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); |
| 653 | |
| 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); |
| 660 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 661 | int lnet_peers_start_down(void); |
| 662 | int lnet_peer_buffer_credits(lnet_ni_t *ni); |
| 663 | |
| 664 | int lnet_router_checker_start(void); |
| 665 | void lnet_router_checker_stop(void); |
Liang Zhen | af3fa7c | 2015-02-01 21:52:06 -0500 | [diff] [blame] | 666 | void lnet_router_ni_update_locked(lnet_peer_t *gw, __u32 net); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 667 | void lnet_swap_pinginfo(lnet_ping_info_t *info); |
| 668 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 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); |
Amir Shehata | 6c9e5a5 | 2016-02-15 10:25:54 -0500 | [diff] [blame] | 672 | int lnet_net_unique(__u32 net, struct list_head *nilist); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 673 | |
| 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, |
| 676 | lnet_nid_t nid); |
Amir Shehata | 21602c7 | 2016-02-15 10:25:52 -0500 | [diff] [blame] | 677 | void lnet_peer_tables_cleanup(lnet_ni_t *ni); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 678 | void lnet_peer_tables_destroy(void); |
| 679 | int lnet_peer_tables_create(void); |
| 680 | void lnet_debug_peer(lnet_nid_t nid); |
Amir Shehata | edeb5d8 | 2016-02-22 17:29:05 -0500 | [diff] [blame] | 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); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 687 | |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 688 | static inline void |
| 689 | lnet_peer_set_alive(lnet_peer_t *lp) |
Liang Zhen | af3fa7c | 2015-02-01 21:52:06 -0500 | [diff] [blame] | 690 | { |
James Simmons | d3d3d37 | 2016-02-12 12:06:05 -0500 | [diff] [blame] | 691 | lp->lp_last_query = jiffies; |
| 692 | lp->lp_last_alive = jiffies; |
Liang Zhen | af3fa7c | 2015-02-01 21:52:06 -0500 | [diff] [blame] | 693 | if (!lp->lp_alive) |
| 694 | lnet_notify_locked(lp, 0, 1, lp->lp_last_alive); |
| 695 | } |
| 696 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 697 | #endif |