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" |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 42 | |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 43 | extern lnet_t the_lnet; /* THE network */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 44 | |
John L. Hammond | d9c9061 | 2015-06-03 16:43:20 -0400 | [diff] [blame] | 45 | #if (BITS_PER_LONG == 32) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 46 | /* 2 CPTs, allowing more CPTs might make us under memory pressure */ |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 47 | #define LNET_CPT_MAX_BITS 1 |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 48 | |
John L. Hammond | d9c9061 | 2015-06-03 16:43:20 -0400 | [diff] [blame] | 49 | #else /* 64-bit system */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 50 | /* |
| 51 | * 256 CPTs for thousands of CPUs, allowing more CPTs might make us |
| 52 | * under risk of consuming all lh_cookie. |
| 53 | */ |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 54 | #define LNET_CPT_MAX_BITS 8 |
John L. Hammond | d9c9061 | 2015-06-03 16:43:20 -0400 | [diff] [blame] | 55 | #endif /* BITS_PER_LONG == 32 */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 56 | |
| 57 | /* max allowed CPT number */ |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 58 | #define LNET_CPT_MAX (1 << LNET_CPT_MAX_BITS) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 59 | |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 60 | #define LNET_CPT_NUMBER (the_lnet.ln_cpt_number) |
| 61 | #define LNET_CPT_BITS (the_lnet.ln_cpt_bits) |
| 62 | #define LNET_CPT_MASK ((1ULL << LNET_CPT_BITS) - 1) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 63 | |
| 64 | /** exclusive lock */ |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 65 | #define LNET_LOCK_EX CFS_PERCPT_LOCK_EX |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 66 | |
Chris Horn | 4ee23a8 | 2016-02-15 10:25:46 -0500 | [diff] [blame^] | 67 | static inline int lnet_is_route_alive(lnet_route_t *route) |
| 68 | { |
| 69 | /* gateway is down */ |
| 70 | if (!route->lr_gateway->lp_alive) |
| 71 | return 0; |
| 72 | /* no NI status, assume it's alive */ |
| 73 | if ((route->lr_gateway->lp_ping_feats & |
| 74 | LNET_PING_FEAT_NI_STATUS) == 0) |
| 75 | return 1; |
| 76 | /* has NI status, check # down NIs */ |
| 77 | return route->lr_downis == 0; |
| 78 | } |
| 79 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 80 | 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] | 81 | { |
| 82 | return (wh->wh_interface_cookie == LNET_WIRE_HANDLE_COOKIE_NONE && |
| 83 | wh->wh_object_cookie == LNET_WIRE_HANDLE_COOKIE_NONE); |
| 84 | } |
| 85 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 86 | static inline int lnet_md_exhausted(lnet_libmd_t *md) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 87 | { |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 88 | return (!md->md_threshold || |
| 89 | ((md->md_options & LNET_MD_MAX_SIZE) && |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 90 | md->md_offset + md->md_max_size > md->md_length)); |
| 91 | } |
| 92 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 93 | static inline int lnet_md_unlinkable(lnet_libmd_t *md) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 94 | { |
James Simmons | 4420cfd | 2016-02-12 12:06:00 -0500 | [diff] [blame] | 95 | /* |
| 96 | * Should unlink md when its refcount is 0 and either: |
Aybuke Ozdemir | 2b06b70 | 2014-09-23 01:53:24 +0300 | [diff] [blame] | 97 | * - md has been flagged for deletion (by auto unlink or |
| 98 | * LNetM[DE]Unlink, in the latter case md may not be exhausted). |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 99 | * - auto unlink is on and md is exhausted. |
| 100 | */ |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 101 | if (md->md_refcount) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 102 | return 0; |
| 103 | |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 104 | if (md->md_flags & LNET_MD_FLAG_ZOMBIE) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 105 | return 1; |
| 106 | |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 107 | return ((md->md_flags & LNET_MD_FLAG_AUTO_UNLINK) && |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 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 | |
| 114 | static inline int |
| 115 | lnet_cpt_of_cookie(__u64 cookie) |
| 116 | { |
| 117 | unsigned int cpt = (cookie >> LNET_COOKIE_TYPE_BITS) & LNET_CPT_MASK; |
| 118 | |
James Simmons | 4420cfd | 2016-02-12 12:06:00 -0500 | [diff] [blame] | 119 | /* |
| 120 | * LNET_CPT_NUMBER doesn't have to be power2, which means we can |
| 121 | * get illegal cpt from it's invalid cookie |
| 122 | */ |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 123 | return cpt < LNET_CPT_NUMBER ? cpt : cpt % LNET_CPT_NUMBER; |
| 124 | } |
| 125 | |
| 126 | static inline void |
| 127 | lnet_res_lock(int cpt) |
| 128 | { |
| 129 | cfs_percpt_lock(the_lnet.ln_res_lock, cpt); |
| 130 | } |
| 131 | |
| 132 | static inline void |
| 133 | lnet_res_unlock(int cpt) |
| 134 | { |
| 135 | cfs_percpt_unlock(the_lnet.ln_res_lock, cpt); |
| 136 | } |
| 137 | |
| 138 | static inline int |
| 139 | lnet_res_lock_current(void) |
| 140 | { |
| 141 | int cpt = lnet_cpt_current(); |
| 142 | |
| 143 | lnet_res_lock(cpt); |
| 144 | return cpt; |
| 145 | } |
| 146 | |
| 147 | static inline void |
| 148 | lnet_net_lock(int cpt) |
| 149 | { |
| 150 | cfs_percpt_lock(the_lnet.ln_net_lock, cpt); |
| 151 | } |
| 152 | |
| 153 | static inline void |
| 154 | lnet_net_unlock(int cpt) |
| 155 | { |
| 156 | cfs_percpt_unlock(the_lnet.ln_net_lock, cpt); |
| 157 | } |
| 158 | |
| 159 | static inline int |
| 160 | lnet_net_lock_current(void) |
| 161 | { |
| 162 | int cpt = lnet_cpt_current(); |
| 163 | |
| 164 | lnet_net_lock(cpt); |
| 165 | return cpt; |
| 166 | } |
| 167 | |
| 168 | #define LNET_LOCK() lnet_net_lock(LNET_LOCK_EX) |
| 169 | #define LNET_UNLOCK() lnet_net_unlock(LNET_LOCK_EX) |
| 170 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 171 | #define lnet_ptl_lock(ptl) spin_lock(&(ptl)->ptl_lock) |
| 172 | #define lnet_ptl_unlock(ptl) spin_unlock(&(ptl)->ptl_lock) |
| 173 | #define lnet_eq_wait_lock() spin_lock(&the_lnet.ln_eq_wait_lock) |
| 174 | #define lnet_eq_wait_unlock() spin_unlock(&the_lnet.ln_eq_wait_lock) |
| 175 | #define lnet_ni_lock(ni) spin_lock(&(ni)->ni_lock) |
| 176 | #define lnet_ni_unlock(ni) spin_unlock(&(ni)->ni_lock) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 177 | |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 178 | #define MAX_PORTALS 64 |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 179 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 180 | static inline lnet_eq_t * |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 181 | lnet_eq_alloc(void) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 182 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 183 | lnet_eq_t *eq; |
| 184 | |
| 185 | LIBCFS_ALLOC(eq, sizeof(*eq)); |
Lisa Nguyen | 0281639 | 2013-10-21 21:52:03 -0700 | [diff] [blame] | 186 | return eq; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 187 | } |
| 188 | |
| 189 | static inline void |
| 190 | lnet_eq_free(lnet_eq_t *eq) |
| 191 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 192 | LIBCFS_FREE(eq, sizeof(*eq)); |
| 193 | } |
| 194 | |
| 195 | static inline lnet_libmd_t * |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 196 | lnet_md_alloc(lnet_md_t *umd) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 197 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 198 | lnet_libmd_t *md; |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 199 | unsigned int size; |
| 200 | unsigned int niov; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 201 | |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 202 | if (umd->options & LNET_MD_KIOV) { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 203 | niov = umd->length; |
| 204 | size = offsetof(lnet_libmd_t, md_iov.kiov[niov]); |
| 205 | } else { |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 206 | niov = umd->options & LNET_MD_IOVEC ? umd->length : 1; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 207 | size = offsetof(lnet_libmd_t, md_iov.iov[niov]); |
| 208 | } |
| 209 | |
| 210 | LIBCFS_ALLOC(md, size); |
| 211 | |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 212 | if (md) { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 213 | /* Set here in case of early free */ |
| 214 | md->md_options = umd->options; |
| 215 | md->md_niov = niov; |
| 216 | INIT_LIST_HEAD(&md->md_list); |
| 217 | } |
| 218 | |
Lisa Nguyen | 0281639 | 2013-10-21 21:52:03 -0700 | [diff] [blame] | 219 | return md; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 220 | } |
| 221 | |
| 222 | static inline void |
| 223 | lnet_md_free(lnet_libmd_t *md) |
| 224 | { |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 225 | unsigned int size; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 226 | |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 227 | if (md->md_options & LNET_MD_KIOV) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 228 | size = offsetof(lnet_libmd_t, md_iov.kiov[md->md_niov]); |
| 229 | else |
| 230 | size = offsetof(lnet_libmd_t, md_iov.iov[md->md_niov]); |
| 231 | |
| 232 | LIBCFS_FREE(md, size); |
| 233 | } |
| 234 | |
| 235 | static inline lnet_me_t * |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 236 | lnet_me_alloc(void) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 237 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 238 | lnet_me_t *me; |
| 239 | |
| 240 | LIBCFS_ALLOC(me, sizeof(*me)); |
Lisa Nguyen | 0281639 | 2013-10-21 21:52:03 -0700 | [diff] [blame] | 241 | return me; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | static inline void |
| 245 | lnet_me_free(lnet_me_t *me) |
| 246 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 247 | LIBCFS_FREE(me, sizeof(*me)); |
| 248 | } |
| 249 | |
| 250 | static inline lnet_msg_t * |
| 251 | lnet_msg_alloc(void) |
| 252 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 253 | lnet_msg_t *msg; |
| 254 | |
| 255 | LIBCFS_ALLOC(msg, sizeof(*msg)); |
| 256 | |
| 257 | /* no need to zero, LIBCFS_ALLOC does for us */ |
Lisa Nguyen | 0281639 | 2013-10-21 21:52:03 -0700 | [diff] [blame] | 258 | return msg; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | static inline void |
| 262 | lnet_msg_free(lnet_msg_t *msg) |
| 263 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 264 | LASSERT(!msg->msg_onactivelist); |
| 265 | LIBCFS_FREE(msg, sizeof(*msg)); |
| 266 | } |
| 267 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 268 | lnet_libhandle_t *lnet_res_lh_lookup(struct lnet_res_container *rec, |
| 269 | __u64 cookie); |
| 270 | void lnet_res_lh_initialize(struct lnet_res_container *rec, |
| 271 | lnet_libhandle_t *lh); |
| 272 | static inline void |
| 273 | lnet_res_lh_invalidate(lnet_libhandle_t *lh) |
| 274 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 275 | /* NB: cookie is still useful, don't reset it */ |
| 276 | list_del(&lh->lh_hash_chain); |
| 277 | } |
| 278 | |
| 279 | static inline void |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 280 | lnet_eq2handle(lnet_handle_eq_t *handle, lnet_eq_t *eq) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 281 | { |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 282 | if (!eq) { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 283 | LNetInvalidateHandle(handle); |
| 284 | return; |
| 285 | } |
| 286 | |
| 287 | handle->cookie = eq->eq_lh.lh_cookie; |
| 288 | } |
| 289 | |
| 290 | static inline lnet_eq_t * |
| 291 | lnet_handle2eq(lnet_handle_eq_t *handle) |
| 292 | { |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 293 | lnet_libhandle_t *lh; |
| 294 | |
| 295 | lh = lnet_res_lh_lookup(&the_lnet.ln_eq_container, handle->cookie); |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 296 | if (!lh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 297 | return NULL; |
| 298 | |
| 299 | return lh_entry(lh, lnet_eq_t, eq_lh); |
| 300 | } |
| 301 | |
| 302 | static inline void |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 303 | lnet_md2handle(lnet_handle_md_t *handle, lnet_libmd_t *md) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 304 | { |
| 305 | handle->cookie = md->md_lh.lh_cookie; |
| 306 | } |
| 307 | |
| 308 | static inline lnet_libmd_t * |
| 309 | lnet_handle2md(lnet_handle_md_t *handle) |
| 310 | { |
| 311 | /* ALWAYS called with resource lock held */ |
| 312 | lnet_libhandle_t *lh; |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 313 | int cpt; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 314 | |
| 315 | cpt = lnet_cpt_of_cookie(handle->cookie); |
| 316 | lh = lnet_res_lh_lookup(the_lnet.ln_md_containers[cpt], |
| 317 | handle->cookie); |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 318 | if (!lh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 319 | return NULL; |
| 320 | |
| 321 | return lh_entry(lh, lnet_libmd_t, md_lh); |
| 322 | } |
| 323 | |
| 324 | static inline lnet_libmd_t * |
| 325 | lnet_wire_handle2md(lnet_handle_wire_t *wh) |
| 326 | { |
| 327 | /* ALWAYS called with resource lock held */ |
| 328 | lnet_libhandle_t *lh; |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 329 | int cpt; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 330 | |
| 331 | if (wh->wh_interface_cookie != the_lnet.ln_interface_cookie) |
| 332 | return NULL; |
| 333 | |
| 334 | cpt = lnet_cpt_of_cookie(wh->wh_object_cookie); |
| 335 | lh = lnet_res_lh_lookup(the_lnet.ln_md_containers[cpt], |
| 336 | wh->wh_object_cookie); |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 337 | if (!lh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 338 | return NULL; |
| 339 | |
| 340 | return lh_entry(lh, lnet_libmd_t, md_lh); |
| 341 | } |
| 342 | |
| 343 | static inline void |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 344 | lnet_me2handle(lnet_handle_me_t *handle, lnet_me_t *me) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 345 | { |
| 346 | handle->cookie = me->me_lh.lh_cookie; |
| 347 | } |
| 348 | |
| 349 | static inline lnet_me_t * |
| 350 | lnet_handle2me(lnet_handle_me_t *handle) |
| 351 | { |
| 352 | /* ALWAYS called with resource lock held */ |
| 353 | lnet_libhandle_t *lh; |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 354 | int cpt; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 355 | |
| 356 | cpt = lnet_cpt_of_cookie(handle->cookie); |
| 357 | lh = lnet_res_lh_lookup(the_lnet.ln_me_containers[cpt], |
| 358 | handle->cookie); |
James Simmons | 06ace26 | 2016-02-12 12:06:08 -0500 | [diff] [blame] | 359 | if (!lh) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 360 | return NULL; |
| 361 | |
| 362 | return lh_entry(lh, lnet_me_t, me_lh); |
| 363 | } |
| 364 | |
| 365 | static inline void |
| 366 | lnet_peer_addref_locked(lnet_peer_t *lp) |
| 367 | { |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 368 | LASSERT(lp->lp_refcount > 0); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 369 | lp->lp_refcount++; |
| 370 | } |
| 371 | |
Greg Kroah-Hartman | 0ee98a9 | 2014-07-11 18:44:57 -0700 | [diff] [blame] | 372 | void lnet_destroy_peer_locked(lnet_peer_t *lp); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 373 | |
| 374 | static inline void |
| 375 | lnet_peer_decref_locked(lnet_peer_t *lp) |
| 376 | { |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 377 | LASSERT(lp->lp_refcount > 0); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 378 | lp->lp_refcount--; |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 379 | if (!lp->lp_refcount) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 380 | lnet_destroy_peer_locked(lp); |
| 381 | } |
| 382 | |
| 383 | static inline int |
| 384 | lnet_isrouter(lnet_peer_t *lp) |
| 385 | { |
James Simmons | 5fd8833 | 2016-02-12 12:06:09 -0500 | [diff] [blame] | 386 | return lp->lp_rtr_refcount ? 1 : 0; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 387 | } |
| 388 | |
| 389 | static inline void |
| 390 | lnet_ni_addref_locked(lnet_ni_t *ni, int cpt) |
| 391 | { |
| 392 | LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER); |
| 393 | LASSERT(*ni->ni_refs[cpt] >= 0); |
| 394 | |
| 395 | (*ni->ni_refs[cpt])++; |
| 396 | } |
| 397 | |
| 398 | static inline void |
| 399 | lnet_ni_addref(lnet_ni_t *ni) |
| 400 | { |
| 401 | lnet_net_lock(0); |
| 402 | lnet_ni_addref_locked(ni, 0); |
| 403 | lnet_net_unlock(0); |
| 404 | } |
| 405 | |
| 406 | static inline void |
| 407 | lnet_ni_decref_locked(lnet_ni_t *ni, int cpt) |
| 408 | { |
| 409 | LASSERT(cpt >= 0 && cpt < LNET_CPT_NUMBER); |
| 410 | LASSERT(*ni->ni_refs[cpt] > 0); |
| 411 | |
| 412 | (*ni->ni_refs[cpt])--; |
| 413 | } |
| 414 | |
| 415 | static inline void |
| 416 | lnet_ni_decref(lnet_ni_t *ni) |
| 417 | { |
| 418 | lnet_net_lock(0); |
| 419 | lnet_ni_decref_locked(ni, 0); |
| 420 | lnet_net_unlock(0); |
| 421 | } |
| 422 | |
| 423 | void lnet_ni_free(lnet_ni_t *ni); |
| 424 | |
| 425 | static inline int |
| 426 | lnet_nid2peerhash(lnet_nid_t nid) |
| 427 | { |
Peng Tao | 72c0824 | 2014-02-12 19:21:39 +0800 | [diff] [blame] | 428 | return hash_long(nid, LNET_PEER_HASH_BITS); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 429 | } |
| 430 | |
| 431 | static inline struct list_head * |
| 432 | lnet_net2rnethash(__u32 net) |
| 433 | { |
| 434 | return &the_lnet.ln_remote_nets_hash[(LNET_NETNUM(net) + |
| 435 | LNET_NETTYP(net)) & |
| 436 | ((1U << the_lnet.ln_remote_nets_hbits) - 1)]; |
| 437 | } |
| 438 | |
| 439 | extern lnd_t the_lolnd; |
Liang Zhen | af3fa7c | 2015-02-01 21:52:06 -0500 | [diff] [blame] | 440 | extern int avoid_asym_router_failure; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 441 | |
Greg Kroah-Hartman | 0ee98a9 | 2014-07-11 18:44:57 -0700 | [diff] [blame] | 442 | int lnet_cpt_of_nid_locked(lnet_nid_t nid); |
| 443 | int lnet_cpt_of_nid(lnet_nid_t nid); |
| 444 | lnet_ni_t *lnet_nid2ni_locked(lnet_nid_t nid, int cpt); |
| 445 | lnet_ni_t *lnet_net2ni_locked(__u32 net, int cpt); |
| 446 | lnet_ni_t *lnet_net2ni(__u32 net); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 447 | |
James Simmons | a9cf72b | 2015-06-11 15:18:13 -0400 | [diff] [blame] | 448 | int lnet_init(void); |
| 449 | void lnet_fini(void); |
| 450 | |
Greg Kroah-Hartman | a649ad1 | 2014-07-12 00:27:46 -0700 | [diff] [blame] | 451 | 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] | 452 | void lnet_notify_locked(lnet_peer_t *lp, int notifylnd, int alive, |
| 453 | unsigned long when); |
Doug Oucharek | e75fb87 | 2013-12-09 22:56:54 +0800 | [diff] [blame] | 454 | int lnet_add_route(__u32 net, unsigned int hops, lnet_nid_t gateway_nid, |
| 455 | unsigned int priority); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 456 | int lnet_check_routes(void); |
| 457 | int lnet_del_route(__u32 net, lnet_nid_t gw_nid); |
| 458 | void lnet_destroy_routes(void); |
| 459 | int lnet_get_route(int idx, __u32 *net, __u32 *hops, |
Doug Oucharek | e75fb87 | 2013-12-09 22:56:54 +0800 | [diff] [blame] | 460 | lnet_nid_t *gateway, __u32 *alive, __u32 *priority); |
Oleg Drokin | b03f395 | 2015-09-14 18:41:17 -0400 | [diff] [blame] | 461 | void lnet_router_debugfs_init(void); |
| 462 | void lnet_router_debugfs_fini(void); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 463 | int lnet_rtrpools_alloc(int im_a_router); |
| 464 | void lnet_rtrpools_free(void); |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 465 | lnet_remotenet_t *lnet_find_net_locked(__u32 net); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 466 | |
| 467 | int lnet_islocalnid(lnet_nid_t nid); |
| 468 | int lnet_islocalnet(__u32 net); |
| 469 | |
| 470 | void lnet_msg_attach_md(lnet_msg_t *msg, lnet_libmd_t *md, |
| 471 | unsigned int offset, unsigned int mlen); |
| 472 | void lnet_msg_detach_md(lnet_msg_t *msg, int status); |
| 473 | void lnet_build_unlink_event(lnet_libmd_t *md, lnet_event_t *ev); |
| 474 | void lnet_build_msg_event(lnet_msg_t *msg, lnet_event_kind_t ev_type); |
| 475 | void lnet_msg_commit(lnet_msg_t *msg, int cpt); |
| 476 | void lnet_msg_decommit(lnet_msg_t *msg, int cpt, int status); |
| 477 | |
| 478 | void lnet_eq_enqueue_event(lnet_eq_t *eq, lnet_event_t *ev); |
| 479 | void lnet_prep_send(lnet_msg_t *msg, int type, lnet_process_id_t target, |
| 480 | unsigned int offset, unsigned int len); |
| 481 | int lnet_send(lnet_nid_t nid, lnet_msg_t *msg, lnet_nid_t rtr_nid); |
| 482 | void lnet_return_tx_credits_locked(lnet_msg_t *msg); |
| 483 | void lnet_return_rx_credits_locked(lnet_msg_t *msg); |
| 484 | |
| 485 | /* portals functions */ |
| 486 | /* portals attributes */ |
| 487 | static inline int |
| 488 | lnet_ptl_is_lazy(lnet_portal_t *ptl) |
| 489 | { |
| 490 | return !!(ptl->ptl_options & LNET_PTL_LAZY); |
| 491 | } |
| 492 | |
| 493 | static inline int |
| 494 | lnet_ptl_is_unique(lnet_portal_t *ptl) |
| 495 | { |
| 496 | return !!(ptl->ptl_options & LNET_PTL_MATCH_UNIQUE); |
| 497 | } |
| 498 | |
| 499 | static inline int |
| 500 | lnet_ptl_is_wildcard(lnet_portal_t *ptl) |
| 501 | { |
| 502 | return !!(ptl->ptl_options & LNET_PTL_MATCH_WILDCARD); |
| 503 | } |
| 504 | |
| 505 | static inline void |
| 506 | lnet_ptl_setopt(lnet_portal_t *ptl, int opt) |
| 507 | { |
| 508 | ptl->ptl_options |= opt; |
| 509 | } |
| 510 | |
| 511 | static inline void |
| 512 | lnet_ptl_unsetopt(lnet_portal_t *ptl, int opt) |
| 513 | { |
| 514 | ptl->ptl_options &= ~opt; |
| 515 | } |
| 516 | |
| 517 | /* match-table functions */ |
| 518 | 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] | 519 | lnet_process_id_t id, __u64 mbits); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 520 | struct lnet_match_table *lnet_mt_of_attach(unsigned int index, |
| 521 | lnet_process_id_t id, __u64 mbits, |
| 522 | __u64 ignore_bits, |
| 523 | lnet_ins_pos_t pos); |
| 524 | int lnet_mt_match_md(struct lnet_match_table *mtable, |
| 525 | struct lnet_match_info *info, struct lnet_msg *msg); |
| 526 | |
| 527 | /* portals match/attach functions */ |
| 528 | void lnet_ptl_attach_md(lnet_me_t *me, lnet_libmd_t *md, |
| 529 | struct list_head *matches, struct list_head *drops); |
| 530 | void lnet_ptl_detach_md(lnet_me_t *me, lnet_libmd_t *md); |
| 531 | int lnet_ptl_match_md(struct lnet_match_info *info, struct lnet_msg *msg); |
| 532 | |
| 533 | /* initialized and finalize portals */ |
| 534 | int lnet_portals_create(void); |
| 535 | void lnet_portals_destroy(void); |
| 536 | |
| 537 | /* message functions */ |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 538 | int lnet_parse(lnet_ni_t *ni, lnet_hdr_t *hdr, |
Greg Kroah-Hartman | 09bce33 | 2014-07-11 18:44:39 -0700 | [diff] [blame] | 539 | lnet_nid_t fromnid, void *private, int rdma_req); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 540 | void lnet_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed, |
| 541 | unsigned int offset, unsigned int mlen, unsigned int rlen); |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 542 | 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] | 543 | 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] | 544 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 545 | 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] | 546 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 547 | void lnet_drop_delayed_msg_list(struct list_head *head, char *reason); |
| 548 | void lnet_recv_delayed_msg_list(struct list_head *head); |
| 549 | |
| 550 | int lnet_msg_container_setup(struct lnet_msg_container *container, int cpt); |
| 551 | void lnet_msg_container_cleanup(struct lnet_msg_container *container); |
| 552 | void lnet_msg_containers_destroy(void); |
| 553 | int lnet_msg_containers_create(void); |
| 554 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 555 | char *lnet_msgtyp2str(int type); |
Lisa Nguyen | ac0a287 | 2013-10-21 21:52:29 -0700 | [diff] [blame] | 556 | void lnet_print_hdr(lnet_hdr_t *hdr); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 557 | int lnet_fail_nid(lnet_nid_t nid, unsigned int threshold); |
| 558 | |
| 559 | void lnet_counters_get(lnet_counters_t *counters); |
| 560 | void lnet_counters_reset(void); |
| 561 | |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 562 | unsigned int lnet_iov_nob(unsigned int niov, struct kvec *iov); |
| 563 | int lnet_extract_iov(int dst_niov, struct kvec *dst, |
| 564 | int src_niov, struct kvec *src, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 565 | unsigned int offset, unsigned int len); |
| 566 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 567 | unsigned int lnet_kiov_nob(unsigned int niov, lnet_kiov_t *iov); |
| 568 | int lnet_extract_kiov(int dst_niov, lnet_kiov_t *dst, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 569 | int src_niov, lnet_kiov_t *src, |
| 570 | unsigned int offset, unsigned int len); |
| 571 | |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 572 | void lnet_copy_iov2iov(unsigned int ndiov, struct kvec *diov, |
Greg Kroah-Hartman | 09bce33 | 2014-07-11 18:44:39 -0700 | [diff] [blame] | 573 | unsigned int doffset, |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 574 | unsigned int nsiov, struct kvec *siov, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 575 | unsigned int soffset, unsigned int nob); |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 576 | void lnet_copy_kiov2iov(unsigned int niov, struct kvec *iov, |
Greg Kroah-Hartman | 09bce33 | 2014-07-11 18:44:39 -0700 | [diff] [blame] | 577 | unsigned int iovoffset, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 578 | unsigned int nkiov, lnet_kiov_t *kiov, |
| 579 | unsigned int kiovoffset, unsigned int nob); |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 580 | void lnet_copy_iov2kiov(unsigned int nkiov, lnet_kiov_t *kiov, |
Greg Kroah-Hartman | 09bce33 | 2014-07-11 18:44:39 -0700 | [diff] [blame] | 581 | unsigned int kiovoffset, |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 582 | unsigned int niov, struct kvec *iov, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 583 | unsigned int iovoffset, unsigned int nob); |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 584 | void lnet_copy_kiov2kiov(unsigned int ndkiov, lnet_kiov_t *dkiov, |
Greg Kroah-Hartman | 09bce33 | 2014-07-11 18:44:39 -0700 | [diff] [blame] | 585 | unsigned int doffset, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 586 | unsigned int nskiov, lnet_kiov_t *skiov, |
| 587 | unsigned int soffset, unsigned int nob); |
| 588 | |
| 589 | static inline void |
| 590 | lnet_copy_iov2flat(int dlen, void *dest, unsigned int doffset, |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 591 | unsigned int nsiov, struct kvec *siov, unsigned int soffset, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 592 | unsigned int nob) |
| 593 | { |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 594 | struct kvec diov = {/*.iov_base = */ dest, /*.iov_len = */ dlen}; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 595 | |
| 596 | lnet_copy_iov2iov(1, &diov, doffset, |
| 597 | nsiov, siov, soffset, nob); |
| 598 | } |
| 599 | |
| 600 | static inline void |
| 601 | lnet_copy_kiov2flat(int dlen, void *dest, unsigned int doffset, |
Aybuke Ozdemir | 2b06b70 | 2014-09-23 01:53:24 +0300 | [diff] [blame] | 602 | unsigned int nsiov, lnet_kiov_t *skiov, |
| 603 | unsigned int soffset, unsigned int nob) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 604 | { |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 605 | struct kvec diov = {/* .iov_base = */ dest, /* .iov_len = */ dlen}; |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 606 | |
| 607 | lnet_copy_kiov2iov(1, &diov, doffset, |
| 608 | nsiov, skiov, soffset, nob); |
| 609 | } |
| 610 | |
| 611 | static inline void |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 612 | lnet_copy_flat2iov(unsigned int ndiov, struct kvec *diov, unsigned int doffset, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 613 | int slen, void *src, unsigned int soffset, unsigned int nob) |
| 614 | { |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 615 | struct kvec siov = {/*.iov_base = */ src, /*.iov_len = */slen}; |
Greg Kroah-Hartman | 681fc80 | 2014-07-11 22:40:51 -0700 | [diff] [blame] | 616 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 617 | lnet_copy_iov2iov(ndiov, diov, doffset, |
| 618 | 1, &siov, soffset, nob); |
| 619 | } |
| 620 | |
| 621 | static inline void |
Aybuke Ozdemir | 2b06b70 | 2014-09-23 01:53:24 +0300 | [diff] [blame] | 622 | lnet_copy_flat2kiov(unsigned int ndiov, lnet_kiov_t *dkiov, |
| 623 | unsigned int doffset, int slen, void *src, |
| 624 | unsigned int soffset, unsigned int nob) |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 625 | { |
Al Viro | f351bad | 2014-12-02 17:15:37 +0000 | [diff] [blame] | 626 | struct kvec siov = {/* .iov_base = */ src, /* .iov_len = */ slen}; |
Greg Kroah-Hartman | 681fc80 | 2014-07-11 22:40:51 -0700 | [diff] [blame] | 627 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 628 | lnet_copy_iov2kiov(ndiov, dkiov, doffset, |
| 629 | 1, &siov, soffset, nob); |
| 630 | } |
| 631 | |
| 632 | void lnet_me_unlink(lnet_me_t *me); |
| 633 | |
| 634 | void lnet_md_unlink(lnet_libmd_t *md); |
| 635 | void lnet_md_deconstruct(lnet_libmd_t *lmd, lnet_md_t *umd); |
| 636 | |
| 637 | void lnet_register_lnd(lnd_t *lnd); |
| 638 | void lnet_unregister_lnd(lnd_t *lnd); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 639 | |
Greg Kroah-Hartman | e327dc8 | 2014-07-11 23:42:52 -0700 | [diff] [blame] | 640 | int lnet_connect(struct socket **sockp, lnet_nid_t peer_nid, |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 641 | __u32 local_ip, __u32 peer_ip, int peer_port); |
| 642 | void lnet_connect_console_error(int rc, lnet_nid_t peer_nid, |
| 643 | __u32 peer_ip, int port); |
| 644 | int lnet_count_acceptor_nis(void); |
| 645 | int lnet_acceptor_timeout(void); |
| 646 | int lnet_acceptor_port(void); |
| 647 | |
| 648 | int lnet_count_acceptor_nis(void); |
| 649 | int lnet_acceptor_port(void); |
| 650 | |
| 651 | int lnet_acceptor_start(void); |
| 652 | void lnet_acceptor_stop(void); |
| 653 | |
James Simmons | 1ad6a73 | 2015-06-08 22:27:10 -0400 | [diff] [blame] | 654 | int lnet_ipif_query(char *name, int *up, __u32 *ip, __u32 *mask); |
| 655 | int lnet_ipif_enumerate(char ***names); |
| 656 | void lnet_ipif_free_enumeration(char **names, int n); |
| 657 | int lnet_sock_setbuf(struct socket *socket, int txbufsize, int rxbufsize); |
| 658 | int lnet_sock_getbuf(struct socket *socket, int *txbufsize, int *rxbufsize); |
| 659 | int lnet_sock_getaddr(struct socket *socket, bool remote, __u32 *ip, int *port); |
| 660 | int lnet_sock_write(struct socket *sock, void *buffer, int nob, int timeout); |
| 661 | int lnet_sock_read(struct socket *sock, void *buffer, int nob, int timeout); |
| 662 | |
| 663 | int lnet_sock_listen(struct socket **sockp, __u32 ip, int port, int backlog); |
| 664 | int lnet_sock_accept(struct socket **newsockp, struct socket *sock); |
| 665 | int lnet_sock_connect(struct socket **sockp, int *fatal, |
| 666 | __u32 local_ip, int local_port, |
| 667 | __u32 peer_ip, int peer_port); |
| 668 | void libcfs_sock_release(struct socket *sock); |
| 669 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 670 | int lnet_peers_start_down(void); |
| 671 | int lnet_peer_buffer_credits(lnet_ni_t *ni); |
| 672 | |
| 673 | int lnet_router_checker_start(void); |
| 674 | void lnet_router_checker_stop(void); |
Liang Zhen | af3fa7c | 2015-02-01 21:52:06 -0500 | [diff] [blame] | 675 | void lnet_router_ni_update_locked(lnet_peer_t *gw, __u32 net); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 676 | void lnet_swap_pinginfo(lnet_ping_info_t *info); |
| 677 | |
| 678 | int lnet_ping_target_init(void); |
| 679 | void lnet_ping_target_fini(void); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 680 | |
Lisa Nguyen | 62fbc9f | 2013-10-21 21:51:37 -0700 | [diff] [blame] | 681 | int lnet_parse_ip2nets(char **networksp, char *ip2nets); |
| 682 | int lnet_parse_routes(char *route_str, int *im_a_router); |
| 683 | int lnet_parse_networks(struct list_head *nilist, char *networks); |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 684 | |
| 685 | int lnet_nid2peer_locked(lnet_peer_t **lpp, lnet_nid_t nid, int cpt); |
| 686 | lnet_peer_t *lnet_find_peer_locked(struct lnet_peer_table *ptable, |
| 687 | lnet_nid_t nid); |
| 688 | void lnet_peer_tables_cleanup(void); |
| 689 | void lnet_peer_tables_destroy(void); |
| 690 | int lnet_peer_tables_create(void); |
| 691 | void lnet_debug_peer(lnet_nid_t nid); |
| 692 | |
James Simmons | 188acc6 | 2015-06-11 15:18:14 -0400 | [diff] [blame] | 693 | static inline void |
| 694 | lnet_peer_set_alive(lnet_peer_t *lp) |
Liang Zhen | af3fa7c | 2015-02-01 21:52:06 -0500 | [diff] [blame] | 695 | { |
James Simmons | d3d3d37 | 2016-02-12 12:06:05 -0500 | [diff] [blame] | 696 | lp->lp_last_query = jiffies; |
| 697 | lp->lp_last_alive = jiffies; |
Liang Zhen | af3fa7c | 2015-02-01 21:52:06 -0500 | [diff] [blame] | 698 | if (!lp->lp_alive) |
| 699 | lnet_notify_locked(lp, 0, 1, lp->lp_last_alive); |
| 700 | } |
| 701 | |
Peng Tao | d7e09d0 | 2013-05-02 16:46:55 +0800 | [diff] [blame] | 702 | #endif |