]>
Commit | Line | Data |
---|---|---|
00e0f34c | 1 | /* |
1e2b44e7 | 2 | * Copyright (c) 2006, 2018 Oracle and/or its affiliates. All rights reserved. |
00e0f34c AG |
3 | * |
4 | * This software is available to you under a choice of one of two | |
5 | * licenses. You may choose to be licensed under the terms of the GNU | |
6 | * General Public License (GPL) Version 2, available from the file | |
7 | * COPYING in the main directory of this source tree, or the | |
8 | * OpenIB.org BSD license below: | |
9 | * | |
10 | * Redistribution and use in source and binary forms, with or | |
11 | * without modification, are permitted provided that the following | |
12 | * conditions are met: | |
13 | * | |
14 | * - Redistributions of source code must retain the above | |
15 | * copyright notice, this list of conditions and the following | |
16 | * disclaimer. | |
17 | * | |
18 | * - Redistributions in binary form must reproduce the above | |
19 | * copyright notice, this list of conditions and the following | |
20 | * disclaimer in the documentation and/or other materials | |
21 | * provided with the distribution. | |
22 | * | |
23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
24 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
25 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
26 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
27 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
28 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
29 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
30 | * SOFTWARE. | |
31 | * | |
32 | */ | |
33 | #include <linux/kernel.h> | |
34 | #include <linux/list.h> | |
5a0e3ad6 | 35 | #include <linux/slab.h> |
bc3b2d7f | 36 | #include <linux/export.h> |
eee2fa6a KCP |
37 | #include <net/ipv6.h> |
38 | #include <net/inet6_hashtables.h> | |
1e2b44e7 | 39 | #include <net/addrconf.h> |
00e0f34c AG |
40 | |
41 | #include "rds.h" | |
42 | #include "loop.h" | |
00e0f34c AG |
43 | |
44 | #define RDS_CONNECTION_HASH_BITS 12 | |
45 | #define RDS_CONNECTION_HASH_ENTRIES (1 << RDS_CONNECTION_HASH_BITS) | |
46 | #define RDS_CONNECTION_HASH_MASK (RDS_CONNECTION_HASH_ENTRIES - 1) | |
47 | ||
48 | /* converting this to RCU is a chore for another day.. */ | |
49 | static DEFINE_SPINLOCK(rds_conn_lock); | |
50 | static unsigned long rds_conn_count; | |
51 | static struct hlist_head rds_conn_hash[RDS_CONNECTION_HASH_ENTRIES]; | |
52 | static struct kmem_cache *rds_conn_slab; | |
53 | ||
eee2fa6a KCP |
54 | static struct hlist_head *rds_conn_bucket(const struct in6_addr *laddr, |
55 | const struct in6_addr *faddr) | |
00e0f34c | 56 | { |
eee2fa6a | 57 | static u32 rds6_hash_secret __read_mostly; |
1bbdceef HFS |
58 | static u32 rds_hash_secret __read_mostly; |
59 | ||
eee2fa6a | 60 | u32 lhash, fhash, hash; |
1bbdceef HFS |
61 | |
62 | net_get_random_once(&rds_hash_secret, sizeof(rds_hash_secret)); | |
eee2fa6a KCP |
63 | net_get_random_once(&rds6_hash_secret, sizeof(rds6_hash_secret)); |
64 | ||
65 | lhash = (__force u32)laddr->s6_addr32[3]; | |
e65d4d96 | 66 | #if IS_ENABLED(CONFIG_IPV6) |
eee2fa6a | 67 | fhash = __ipv6_addr_jhash(faddr, rds6_hash_secret); |
e65d4d96 KCP |
68 | #else |
69 | fhash = (__force u32)faddr->s6_addr32[3]; | |
70 | #endif | |
71 | hash = __inet_ehashfn(lhash, 0, fhash, 0, rds_hash_secret); | |
1bbdceef | 72 | |
00e0f34c AG |
73 | return &rds_conn_hash[hash & RDS_CONNECTION_HASH_MASK]; |
74 | } | |
75 | ||
76 | #define rds_conn_info_set(var, test, suffix) do { \ | |
77 | if (test) \ | |
78 | var |= RDS_INFO_CONNECTION_FLAG_##suffix; \ | |
79 | } while (0) | |
80 | ||
bcf50ef2 | 81 | /* rcu read lock must be held or the connection spinlock */ |
8f384c01 SV |
82 | static struct rds_connection *rds_conn_lookup(struct net *net, |
83 | struct hlist_head *head, | |
eee2fa6a KCP |
84 | const struct in6_addr *laddr, |
85 | const struct in6_addr *faddr, | |
86 | struct rds_transport *trans, | |
3eb45036 | 87 | u8 tos, int dev_if) |
00e0f34c AG |
88 | { |
89 | struct rds_connection *conn, *ret = NULL; | |
00e0f34c | 90 | |
b67bfe0d | 91 | hlist_for_each_entry_rcu(conn, head, c_hash_node) { |
eee2fa6a KCP |
92 | if (ipv6_addr_equal(&conn->c_faddr, faddr) && |
93 | ipv6_addr_equal(&conn->c_laddr, laddr) && | |
94 | conn->c_trans == trans && | |
3eb45036 | 95 | conn->c_tos == tos && |
eee2fa6a KCP |
96 | net == rds_conn_net(conn) && |
97 | conn->c_dev_if == dev_if) { | |
00e0f34c AG |
98 | ret = conn; |
99 | break; | |
100 | } | |
101 | } | |
eee2fa6a KCP |
102 | rdsdebug("returning conn %p for %pI6c -> %pI6c\n", ret, |
103 | laddr, faddr); | |
00e0f34c AG |
104 | return ret; |
105 | } | |
106 | ||
107 | /* | |
108 | * This is called by transports as they're bringing down a connection. | |
109 | * It clears partial message state so that the transport can start sending | |
110 | * and receiving over this connection again in the future. It is up to | |
111 | * the transport to have serialized this call with its send and recv. | |
112 | */ | |
d769ef81 | 113 | static void rds_conn_path_reset(struct rds_conn_path *cp) |
00e0f34c | 114 | { |
d769ef81 SV |
115 | struct rds_connection *conn = cp->cp_conn; |
116 | ||
eee2fa6a KCP |
117 | rdsdebug("connection %pI6c to %pI6c reset\n", |
118 | &conn->c_laddr, &conn->c_faddr); | |
00e0f34c AG |
119 | |
120 | rds_stats_inc(s_conn_reset); | |
d769ef81 SV |
121 | rds_send_path_reset(cp); |
122 | cp->cp_flags = 0; | |
00e0f34c AG |
123 | |
124 | /* Do not clear next_rx_seq here, else we cannot distinguish | |
125 | * retransmitted packets from new packets, and will hand all | |
126 | * of them to the application. That is not consistent with the | |
127 | * reliability guarantees of RDS. */ | |
128 | } | |
129 | ||
1c5113cf SV |
130 | static void __rds_conn_path_init(struct rds_connection *conn, |
131 | struct rds_conn_path *cp, bool is_outgoing) | |
132 | { | |
133 | spin_lock_init(&cp->cp_lock); | |
134 | cp->cp_next_tx_seq = 1; | |
135 | init_waitqueue_head(&cp->cp_waitq); | |
136 | INIT_LIST_HEAD(&cp->cp_send_queue); | |
137 | INIT_LIST_HEAD(&cp->cp_retrans); | |
138 | ||
139 | cp->cp_conn = conn; | |
140 | atomic_set(&cp->cp_state, RDS_CONN_DOWN); | |
141 | cp->cp_send_gen = 0; | |
1c5113cf | 142 | cp->cp_reconnect_jiffies = 0; |
cdc306a5 | 143 | cp->cp_conn->c_proposed_version = RDS_PROTOCOL_VERSION; |
1c5113cf SV |
144 | INIT_DELAYED_WORK(&cp->cp_send_w, rds_send_worker); |
145 | INIT_DELAYED_WORK(&cp->cp_recv_w, rds_recv_worker); | |
146 | INIT_DELAYED_WORK(&cp->cp_conn_w, rds_connect_worker); | |
147 | INIT_WORK(&cp->cp_down_w, rds_shutdown_worker); | |
148 | mutex_init(&cp->cp_cm_lock); | |
149 | cp->cp_flags = 0; | |
150 | } | |
151 | ||
00e0f34c AG |
152 | /* |
153 | * There is only every one 'conn' for a given pair of addresses in the | |
154 | * system at a time. They contain messages to be retransmitted and so | |
155 | * span the lifetime of the actual underlying transport connections. | |
156 | * | |
157 | * For now they are not garbage collected once they're created. They | |
158 | * are torn down as the module is removed, if ever. | |
159 | */ | |
d5a8ac28 | 160 | static struct rds_connection *__rds_conn_create(struct net *net, |
eee2fa6a KCP |
161 | const struct in6_addr *laddr, |
162 | const struct in6_addr *faddr, | |
163 | struct rds_transport *trans, | |
3eb45036 | 164 | gfp_t gfp, u8 tos, |
eee2fa6a KCP |
165 | int is_outgoing, |
166 | int dev_if) | |
00e0f34c | 167 | { |
cb24405e | 168 | struct rds_connection *conn, *parent = NULL; |
00e0f34c | 169 | struct hlist_head *head = rds_conn_bucket(laddr, faddr); |
5adb5bc6 | 170 | struct rds_transport *loop_trans; |
00e0f34c | 171 | unsigned long flags; |
5916e2c1 | 172 | int ret, i; |
840df162 | 173 | int npaths = (trans->t_mp_capable ? RDS_MPATH_WORKERS : 1); |
00e0f34c | 174 | |
bcf50ef2 | 175 | rcu_read_lock(); |
3eb45036 | 176 | conn = rds_conn_lookup(net, head, laddr, faddr, trans, tos, dev_if); |
eee2fa6a KCP |
177 | if (conn && |
178 | conn->c_loopback && | |
179 | conn->c_trans != &rds_loop_transport && | |
180 | ipv6_addr_equal(laddr, faddr) && | |
181 | !is_outgoing) { | |
00e0f34c AG |
182 | /* This is a looped back IB connection, and we're |
183 | * called by the code handling the incoming connect. | |
184 | * We need a second connection object into which we | |
185 | * can stick the other QP. */ | |
186 | parent = conn; | |
187 | conn = parent->c_passive; | |
188 | } | |
bcf50ef2 | 189 | rcu_read_unlock(); |
00e0f34c AG |
190 | if (conn) |
191 | goto out; | |
192 | ||
05a178ec | 193 | conn = kmem_cache_zalloc(rds_conn_slab, gfp); |
8690bfa1 | 194 | if (!conn) { |
00e0f34c AG |
195 | conn = ERR_PTR(-ENOMEM); |
196 | goto out; | |
197 | } | |
840df162 SV |
198 | conn->c_path = kcalloc(npaths, sizeof(struct rds_conn_path), gfp); |
199 | if (!conn->c_path) { | |
200 | kmem_cache_free(rds_conn_slab, conn); | |
201 | conn = ERR_PTR(-ENOMEM); | |
202 | goto out; | |
203 | } | |
00e0f34c | 204 | |
00e0f34c | 205 | INIT_HLIST_NODE(&conn->c_hash_node); |
eee2fa6a KCP |
206 | conn->c_laddr = *laddr; |
207 | conn->c_isv6 = !ipv6_addr_v4mapped(laddr); | |
208 | conn->c_faddr = *faddr; | |
209 | conn->c_dev_if = dev_if; | |
3eb45036 | 210 | conn->c_tos = tos; |
e65d4d96 KCP |
211 | |
212 | #if IS_ENABLED(CONFIG_IPV6) | |
1e2b44e7 KCP |
213 | /* If the local address is link local, set c_bound_if to be the |
214 | * index used for this connection. Otherwise, set it to 0 as | |
215 | * the socket is not bound to an interface. c_bound_if is used | |
216 | * to look up a socket when a packet is received | |
217 | */ | |
218 | if (ipv6_addr_type(laddr) & IPV6_ADDR_LINKLOCAL) | |
219 | conn->c_bound_if = dev_if; | |
220 | else | |
e65d4d96 | 221 | #endif |
1e2b44e7 | 222 | conn->c_bound_if = 0; |
00e0f34c | 223 | |
1c5113cf | 224 | rds_conn_net_set(conn, net); |
00e0f34c AG |
225 | |
226 | ret = rds_cong_get_maps(conn); | |
227 | if (ret) { | |
840df162 | 228 | kfree(conn->c_path); |
00e0f34c AG |
229 | kmem_cache_free(rds_conn_slab, conn); |
230 | conn = ERR_PTR(ret); | |
231 | goto out; | |
232 | } | |
233 | ||
234 | /* | |
235 | * This is where a connection becomes loopback. If *any* RDS sockets | |
236 | * can bind to the destination address then we'd rather the messages | |
237 | * flow through loopback rather than either transport. | |
238 | */ | |
eee2fa6a | 239 | loop_trans = rds_trans_get_preferred(net, faddr, conn->c_dev_if); |
5adb5bc6 ZB |
240 | if (loop_trans) { |
241 | rds_trans_put(loop_trans); | |
00e0f34c | 242 | conn->c_loopback = 1; |
aced3ce5 RS |
243 | if (trans->t_prefer_loopback) { |
244 | if (likely(is_outgoing)) { | |
245 | /* "outgoing" connection to local address. | |
246 | * Protocol says it wants the connection | |
247 | * handled by the loopback transport. | |
248 | * This is what TCP does. | |
249 | */ | |
250 | trans = &rds_loop_transport; | |
251 | } else { | |
252 | /* No transport currently in use | |
253 | * should end up here, but if it | |
254 | * does, reset/destroy the connection. | |
255 | */ | |
256 | kmem_cache_free(rds_conn_slab, conn); | |
257 | conn = ERR_PTR(-EOPNOTSUPP); | |
258 | goto out; | |
259 | } | |
00e0f34c AG |
260 | } |
261 | } | |
262 | ||
263 | conn->c_trans = trans; | |
264 | ||
5916e2c1 | 265 | init_waitqueue_head(&conn->c_hs_waitq); |
840df162 | 266 | for (i = 0; i < npaths; i++) { |
5916e2c1 SV |
267 | __rds_conn_path_init(conn, &conn->c_path[i], |
268 | is_outgoing); | |
269 | conn->c_path[i].cp_index = i; | |
270 | } | |
ebeeb1ad SV |
271 | rcu_read_lock(); |
272 | if (rds_destroy_pending(conn)) | |
273 | ret = -ENETDOWN; | |
274 | else | |
d4014d8c | 275 | ret = trans->conn_alloc(conn, GFP_ATOMIC); |
00e0f34c | 276 | if (ret) { |
ebeeb1ad | 277 | rcu_read_unlock(); |
840df162 | 278 | kfree(conn->c_path); |
00e0f34c AG |
279 | kmem_cache_free(rds_conn_slab, conn); |
280 | conn = ERR_PTR(ret); | |
281 | goto out; | |
282 | } | |
283 | ||
eee2fa6a KCP |
284 | rdsdebug("allocated conn %p for %pI6c -> %pI6c over %s %s\n", |
285 | conn, laddr, faddr, | |
286 | strnlen(trans->t_name, sizeof(trans->t_name)) ? | |
287 | trans->t_name : "[unknown]", is_outgoing ? "(outgoing)" : ""); | |
00e0f34c | 288 | |
cb24405e AG |
289 | /* |
290 | * Since we ran without holding the conn lock, someone could | |
291 | * have created the same conn (either normal or passive) in the | |
292 | * interim. We check while holding the lock. If we won, we complete | |
293 | * init and return our conn. If we lost, we rollback and return the | |
294 | * other one. | |
295 | */ | |
00e0f34c | 296 | spin_lock_irqsave(&rds_conn_lock, flags); |
cb24405e AG |
297 | if (parent) { |
298 | /* Creating passive conn */ | |
299 | if (parent->c_passive) { | |
1c5113cf | 300 | trans->conn_free(conn->c_path[0].cp_transport_data); |
840df162 | 301 | kfree(conn->c_path); |
cb24405e AG |
302 | kmem_cache_free(rds_conn_slab, conn); |
303 | conn = parent->c_passive; | |
304 | } else { | |
00e0f34c | 305 | parent->c_passive = conn; |
cb24405e AG |
306 | rds_cong_add_conn(conn); |
307 | rds_conn_count++; | |
308 | } | |
00e0f34c | 309 | } else { |
cb24405e AG |
310 | /* Creating normal conn */ |
311 | struct rds_connection *found; | |
312 | ||
eee2fa6a | 313 | found = rds_conn_lookup(net, head, laddr, faddr, trans, |
3eb45036 | 314 | tos, dev_if); |
cb24405e | 315 | if (found) { |
1c5113cf SV |
316 | struct rds_conn_path *cp; |
317 | int i; | |
318 | ||
840df162 | 319 | for (i = 0; i < npaths; i++) { |
1c5113cf | 320 | cp = &conn->c_path[i]; |
02105b2c SV |
321 | /* The ->conn_alloc invocation may have |
322 | * allocated resource for all paths, so all | |
323 | * of them may have to be freed here. | |
324 | */ | |
325 | if (cp->cp_transport_data) | |
326 | trans->conn_free(cp->cp_transport_data); | |
1c5113cf | 327 | } |
840df162 | 328 | kfree(conn->c_path); |
cb24405e AG |
329 | kmem_cache_free(rds_conn_slab, conn); |
330 | conn = found; | |
331 | } else { | |
905dd418 SV |
332 | conn->c_my_gen_num = rds_gen_num; |
333 | conn->c_peer_gen_num = 0; | |
3b20fc38 | 334 | hlist_add_head_rcu(&conn->c_hash_node, head); |
cb24405e AG |
335 | rds_cong_add_conn(conn); |
336 | rds_conn_count++; | |
337 | } | |
00e0f34c | 338 | } |
00e0f34c | 339 | spin_unlock_irqrestore(&rds_conn_lock, flags); |
ebeeb1ad | 340 | rcu_read_unlock(); |
00e0f34c AG |
341 | |
342 | out: | |
343 | return conn; | |
344 | } | |
345 | ||
d5a8ac28 | 346 | struct rds_connection *rds_conn_create(struct net *net, |
eee2fa6a KCP |
347 | const struct in6_addr *laddr, |
348 | const struct in6_addr *faddr, | |
3eb45036 SS |
349 | struct rds_transport *trans, u8 tos, |
350 | gfp_t gfp, int dev_if) | |
00e0f34c | 351 | { |
3eb45036 | 352 | return __rds_conn_create(net, laddr, faddr, trans, gfp, tos, 0, dev_if); |
00e0f34c | 353 | } |
616b757a | 354 | EXPORT_SYMBOL_GPL(rds_conn_create); |
00e0f34c | 355 | |
d5a8ac28 | 356 | struct rds_connection *rds_conn_create_outgoing(struct net *net, |
eee2fa6a KCP |
357 | const struct in6_addr *laddr, |
358 | const struct in6_addr *faddr, | |
359 | struct rds_transport *trans, | |
3eb45036 | 360 | u8 tos, gfp_t gfp, int dev_if) |
00e0f34c | 361 | { |
3eb45036 | 362 | return __rds_conn_create(net, laddr, faddr, trans, gfp, tos, 1, dev_if); |
00e0f34c | 363 | } |
616b757a | 364 | EXPORT_SYMBOL_GPL(rds_conn_create_outgoing); |
00e0f34c | 365 | |
d769ef81 | 366 | void rds_conn_shutdown(struct rds_conn_path *cp) |
2dc39357 | 367 | { |
d769ef81 SV |
368 | struct rds_connection *conn = cp->cp_conn; |
369 | ||
2dc39357 | 370 | /* shut it down unless it's down already */ |
d769ef81 | 371 | if (!rds_conn_path_transition(cp, RDS_CONN_DOWN, RDS_CONN_DOWN)) { |
2dc39357 AG |
372 | /* |
373 | * Quiesce the connection mgmt handlers before we start tearing | |
374 | * things down. We don't hold the mutex for the entire | |
375 | * duration of the shutdown operation, else we may be | |
376 | * deadlocking with the CM handler. Instead, the CM event | |
377 | * handler is supposed to check for state DISCONNECTING | |
378 | */ | |
d769ef81 SV |
379 | mutex_lock(&cp->cp_cm_lock); |
380 | if (!rds_conn_path_transition(cp, RDS_CONN_UP, | |
381 | RDS_CONN_DISCONNECTING) && | |
382 | !rds_conn_path_transition(cp, RDS_CONN_ERROR, | |
383 | RDS_CONN_DISCONNECTING)) { | |
384 | rds_conn_path_error(cp, | |
385 | "shutdown called in state %d\n", | |
386 | atomic_read(&cp->cp_state)); | |
387 | mutex_unlock(&cp->cp_cm_lock); | |
2dc39357 AG |
388 | return; |
389 | } | |
d769ef81 | 390 | mutex_unlock(&cp->cp_cm_lock); |
2dc39357 | 391 | |
d769ef81 SV |
392 | wait_event(cp->cp_waitq, |
393 | !test_bit(RDS_IN_XMIT, &cp->cp_flags)); | |
394 | wait_event(cp->cp_waitq, | |
395 | !test_bit(RDS_RECV_REFILL, &cp->cp_flags)); | |
7e3f2952 | 396 | |
226f7a7d | 397 | conn->c_trans->conn_path_shutdown(cp); |
d769ef81 | 398 | rds_conn_path_reset(cp); |
2dc39357 | 399 | |
d769ef81 | 400 | if (!rds_conn_path_transition(cp, RDS_CONN_DISCONNECTING, |
e97656d0 SV |
401 | RDS_CONN_DOWN) && |
402 | !rds_conn_path_transition(cp, RDS_CONN_ERROR, | |
d769ef81 | 403 | RDS_CONN_DOWN)) { |
2dc39357 AG |
404 | /* This can happen - eg when we're in the middle of tearing |
405 | * down the connection, and someone unloads the rds module. | |
e97656d0 | 406 | * Quite reproducible with loopback connections. |
2dc39357 | 407 | * Mostly harmless. |
e97656d0 SV |
408 | * |
409 | * Note that this also happens with rds-tcp because | |
410 | * we could have triggered rds_conn_path_drop in irq | |
411 | * mode from rds_tcp_state change on the receipt of | |
412 | * a FIN, thus we need to recheck for RDS_CONN_ERROR | |
413 | * here. | |
2dc39357 | 414 | */ |
d769ef81 SV |
415 | rds_conn_path_error(cp, "%s: failed to transition " |
416 | "to state DOWN, current state " | |
417 | "is %d\n", __func__, | |
418 | atomic_read(&cp->cp_state)); | |
2dc39357 AG |
419 | return; |
420 | } | |
421 | } | |
422 | ||
423 | /* Then reconnect if it's still live. | |
424 | * The passive side of an IB loopback connection is never added | |
425 | * to the conn hash, so we never trigger a reconnect on this | |
426 | * conn - the reconnect is always triggered by the active peer. */ | |
d769ef81 | 427 | cancel_delayed_work_sync(&cp->cp_conn_w); |
bcf50ef2 CM |
428 | rcu_read_lock(); |
429 | if (!hlist_unhashed(&conn->c_hash_node)) { | |
430 | rcu_read_unlock(); | |
8315011a | 431 | rds_queue_reconnect(cp); |
bcf50ef2 CM |
432 | } else { |
433 | rcu_read_unlock(); | |
434 | } | |
2dc39357 AG |
435 | } |
436 | ||
3ecc5693 SV |
437 | /* destroy a single rds_conn_path. rds_conn_destroy() iterates over |
438 | * all paths using rds_conn_path_destroy() | |
439 | */ | |
440 | static void rds_conn_path_destroy(struct rds_conn_path *cp) | |
441 | { | |
442 | struct rds_message *rm, *rtmp; | |
443 | ||
02105b2c SV |
444 | if (!cp->cp_transport_data) |
445 | return; | |
446 | ||
3ecc5693 SV |
447 | /* make sure lingering queued work won't try to ref the conn */ |
448 | cancel_delayed_work_sync(&cp->cp_send_w); | |
449 | cancel_delayed_work_sync(&cp->cp_recv_w); | |
450 | ||
aed20a53 SV |
451 | rds_conn_path_drop(cp, true); |
452 | flush_work(&cp->cp_down_w); | |
453 | ||
3ecc5693 SV |
454 | /* tear down queued messages */ |
455 | list_for_each_entry_safe(rm, rtmp, | |
456 | &cp->cp_send_queue, | |
457 | m_conn_item) { | |
458 | list_del_init(&rm->m_conn_item); | |
459 | BUG_ON(!list_empty(&rm->m_sock_item)); | |
460 | rds_message_put(rm); | |
461 | } | |
462 | if (cp->cp_xmit_rm) | |
463 | rds_message_put(cp->cp_xmit_rm); | |
464 | ||
3db6e0d1 SV |
465 | WARN_ON(delayed_work_pending(&cp->cp_send_w)); |
466 | WARN_ON(delayed_work_pending(&cp->cp_recv_w)); | |
467 | WARN_ON(delayed_work_pending(&cp->cp_conn_w)); | |
468 | WARN_ON(work_pending(&cp->cp_down_w)); | |
469 | ||
3ecc5693 SV |
470 | cp->cp_conn->c_trans->conn_free(cp->cp_transport_data); |
471 | } | |
472 | ||
2dc39357 AG |
473 | /* |
474 | * Stop and free a connection. | |
ffcec0e1 ZB |
475 | * |
476 | * This can only be used in very limited circumstances. It assumes that once | |
477 | * the conn has been shutdown that no one else is referencing the connection. | |
478 | * We can only ensure this in the rmmod path in the current code. | |
2dc39357 | 479 | */ |
00e0f34c AG |
480 | void rds_conn_destroy(struct rds_connection *conn) |
481 | { | |
fe8ff6b5 | 482 | unsigned long flags; |
02105b2c SV |
483 | int i; |
484 | struct rds_conn_path *cp; | |
840df162 | 485 | int npaths = (conn->c_trans->t_mp_capable ? RDS_MPATH_WORKERS : 1); |
00e0f34c AG |
486 | |
487 | rdsdebug("freeing conn %p for %pI4 -> " | |
488 | "%pI4\n", conn, &conn->c_laddr, | |
489 | &conn->c_faddr); | |
490 | ||
abf45439 CM |
491 | /* Ensure conn will not be scheduled for reconnect */ |
492 | spin_lock_irq(&rds_conn_lock); | |
bcf50ef2 | 493 | hlist_del_init_rcu(&conn->c_hash_node); |
abf45439 | 494 | spin_unlock_irq(&rds_conn_lock); |
bcf50ef2 CM |
495 | synchronize_rcu(); |
496 | ||
ffcec0e1 | 497 | /* shut the connection down */ |
840df162 | 498 | for (i = 0; i < npaths; i++) { |
02105b2c SV |
499 | cp = &conn->c_path[i]; |
500 | rds_conn_path_destroy(cp); | |
501 | BUG_ON(!list_empty(&cp->cp_retrans)); | |
00e0f34c | 502 | } |
00e0f34c AG |
503 | |
504 | /* | |
505 | * The congestion maps aren't freed up here. They're | |
506 | * freed by rds_cong_exit() after all the connections | |
507 | * have been freed. | |
508 | */ | |
509 | rds_cong_remove_conn(conn); | |
510 | ||
840df162 | 511 | kfree(conn->c_path); |
00e0f34c AG |
512 | kmem_cache_free(rds_conn_slab, conn); |
513 | ||
fe8ff6b5 | 514 | spin_lock_irqsave(&rds_conn_lock, flags); |
00e0f34c | 515 | rds_conn_count--; |
fe8ff6b5 | 516 | spin_unlock_irqrestore(&rds_conn_lock, flags); |
00e0f34c | 517 | } |
616b757a | 518 | EXPORT_SYMBOL_GPL(rds_conn_destroy); |
00e0f34c | 519 | |
1e2b44e7 KCP |
520 | static void __rds_inc_msg_cp(struct rds_incoming *inc, |
521 | struct rds_info_iterator *iter, | |
b7ff8b10 | 522 | void *saddr, void *daddr, int flip, bool isv6) |
1e2b44e7 | 523 | { |
e65d4d96 | 524 | #if IS_ENABLED(CONFIG_IPV6) |
b7ff8b10 KCP |
525 | if (isv6) |
526 | rds6_inc_info_copy(inc, iter, saddr, daddr, flip); | |
527 | else | |
e65d4d96 | 528 | #endif |
b7ff8b10 KCP |
529 | rds_inc_info_copy(inc, iter, *(__be32 *)saddr, |
530 | *(__be32 *)daddr, flip); | |
1e2b44e7 KCP |
531 | } |
532 | ||
533 | static void rds_conn_message_info_cmn(struct socket *sock, unsigned int len, | |
534 | struct rds_info_iterator *iter, | |
535 | struct rds_info_lengths *lens, | |
b7ff8b10 | 536 | int want_send, bool isv6) |
00e0f34c AG |
537 | { |
538 | struct hlist_head *head; | |
00e0f34c AG |
539 | struct list_head *list; |
540 | struct rds_connection *conn; | |
541 | struct rds_message *rm; | |
00e0f34c | 542 | unsigned int total = 0; |
501dcccd | 543 | unsigned long flags; |
00e0f34c | 544 | size_t i; |
992c9ec5 | 545 | int j; |
00e0f34c | 546 | |
b7ff8b10 KCP |
547 | if (isv6) |
548 | len /= sizeof(struct rds6_info_message); | |
549 | else | |
550 | len /= sizeof(struct rds_info_message); | |
00e0f34c | 551 | |
bcf50ef2 | 552 | rcu_read_lock(); |
00e0f34c AG |
553 | |
554 | for (i = 0, head = rds_conn_hash; i < ARRAY_SIZE(rds_conn_hash); | |
555 | i++, head++) { | |
b67bfe0d | 556 | hlist_for_each_entry_rcu(conn, head, c_hash_node) { |
992c9ec5 | 557 | struct rds_conn_path *cp; |
840df162 SV |
558 | int npaths; |
559 | ||
b7ff8b10 KCP |
560 | if (!isv6 && conn->c_isv6) |
561 | continue; | |
562 | ||
840df162 SV |
563 | npaths = (conn->c_trans->t_mp_capable ? |
564 | RDS_MPATH_WORKERS : 1); | |
992c9ec5 | 565 | |
840df162 | 566 | for (j = 0; j < npaths; j++) { |
992c9ec5 SV |
567 | cp = &conn->c_path[j]; |
568 | if (want_send) | |
569 | list = &cp->cp_send_queue; | |
570 | else | |
571 | list = &cp->cp_retrans; | |
572 | ||
573 | spin_lock_irqsave(&cp->cp_lock, flags); | |
574 | ||
575 | /* XXX too lazy to maintain counts.. */ | |
576 | list_for_each_entry(rm, list, m_conn_item) { | |
577 | total++; | |
578 | if (total <= len) | |
1e2b44e7 KCP |
579 | __rds_inc_msg_cp(&rm->m_inc, |
580 | iter, | |
581 | &conn->c_laddr, | |
582 | &conn->c_faddr, | |
b7ff8b10 | 583 | 0, isv6); |
992c9ec5 SV |
584 | } |
585 | ||
586 | spin_unlock_irqrestore(&cp->cp_lock, flags); | |
00e0f34c | 587 | } |
00e0f34c AG |
588 | } |
589 | } | |
bcf50ef2 | 590 | rcu_read_unlock(); |
00e0f34c AG |
591 | |
592 | lens->nr = total; | |
b7ff8b10 KCP |
593 | if (isv6) |
594 | lens->each = sizeof(struct rds6_info_message); | |
595 | else | |
596 | lens->each = sizeof(struct rds_info_message); | |
00e0f34c AG |
597 | } |
598 | ||
1e2b44e7 KCP |
599 | static void rds_conn_message_info(struct socket *sock, unsigned int len, |
600 | struct rds_info_iterator *iter, | |
601 | struct rds_info_lengths *lens, | |
602 | int want_send) | |
603 | { | |
b7ff8b10 KCP |
604 | rds_conn_message_info_cmn(sock, len, iter, lens, want_send, false); |
605 | } | |
606 | ||
e65d4d96 | 607 | #if IS_ENABLED(CONFIG_IPV6) |
b7ff8b10 KCP |
608 | static void rds6_conn_message_info(struct socket *sock, unsigned int len, |
609 | struct rds_info_iterator *iter, | |
610 | struct rds_info_lengths *lens, | |
611 | int want_send) | |
612 | { | |
613 | rds_conn_message_info_cmn(sock, len, iter, lens, want_send, true); | |
1e2b44e7 | 614 | } |
e65d4d96 | 615 | #endif |
1e2b44e7 | 616 | |
00e0f34c AG |
617 | static void rds_conn_message_info_send(struct socket *sock, unsigned int len, |
618 | struct rds_info_iterator *iter, | |
619 | struct rds_info_lengths *lens) | |
620 | { | |
621 | rds_conn_message_info(sock, len, iter, lens, 1); | |
622 | } | |
623 | ||
e65d4d96 | 624 | #if IS_ENABLED(CONFIG_IPV6) |
b7ff8b10 KCP |
625 | static void rds6_conn_message_info_send(struct socket *sock, unsigned int len, |
626 | struct rds_info_iterator *iter, | |
627 | struct rds_info_lengths *lens) | |
628 | { | |
629 | rds6_conn_message_info(sock, len, iter, lens, 1); | |
630 | } | |
e65d4d96 | 631 | #endif |
b7ff8b10 | 632 | |
00e0f34c AG |
633 | static void rds_conn_message_info_retrans(struct socket *sock, |
634 | unsigned int len, | |
635 | struct rds_info_iterator *iter, | |
636 | struct rds_info_lengths *lens) | |
637 | { | |
638 | rds_conn_message_info(sock, len, iter, lens, 0); | |
639 | } | |
640 | ||
e65d4d96 | 641 | #if IS_ENABLED(CONFIG_IPV6) |
b7ff8b10 KCP |
642 | static void rds6_conn_message_info_retrans(struct socket *sock, |
643 | unsigned int len, | |
644 | struct rds_info_iterator *iter, | |
645 | struct rds_info_lengths *lens) | |
646 | { | |
647 | rds6_conn_message_info(sock, len, iter, lens, 0); | |
648 | } | |
e65d4d96 | 649 | #endif |
b7ff8b10 | 650 | |
00e0f34c AG |
651 | void rds_for_each_conn_info(struct socket *sock, unsigned int len, |
652 | struct rds_info_iterator *iter, | |
653 | struct rds_info_lengths *lens, | |
654 | int (*visitor)(struct rds_connection *, void *), | |
f1cb9d68 | 655 | u64 *buffer, |
00e0f34c AG |
656 | size_t item_len) |
657 | { | |
00e0f34c | 658 | struct hlist_head *head; |
00e0f34c | 659 | struct rds_connection *conn; |
00e0f34c AG |
660 | size_t i; |
661 | ||
bcf50ef2 | 662 | rcu_read_lock(); |
00e0f34c AG |
663 | |
664 | lens->nr = 0; | |
665 | lens->each = item_len; | |
666 | ||
667 | for (i = 0, head = rds_conn_hash; i < ARRAY_SIZE(rds_conn_hash); | |
668 | i++, head++) { | |
b67bfe0d | 669 | hlist_for_each_entry_rcu(conn, head, c_hash_node) { |
00e0f34c AG |
670 | |
671 | /* XXX no c_lock usage.. */ | |
672 | if (!visitor(conn, buffer)) | |
673 | continue; | |
674 | ||
675 | /* We copy as much as we can fit in the buffer, | |
676 | * but we count all items so that the caller | |
677 | * can resize the buffer. */ | |
678 | if (len >= item_len) { | |
679 | rds_info_copy(iter, buffer, item_len); | |
680 | len -= item_len; | |
681 | } | |
682 | lens->nr++; | |
683 | } | |
684 | } | |
bcf50ef2 | 685 | rcu_read_unlock(); |
00e0f34c | 686 | } |
616b757a | 687 | EXPORT_SYMBOL_GPL(rds_for_each_conn_info); |
00e0f34c | 688 | |
bb789763 SS |
689 | static void rds_walk_conn_path_info(struct socket *sock, unsigned int len, |
690 | struct rds_info_iterator *iter, | |
691 | struct rds_info_lengths *lens, | |
692 | int (*visitor)(struct rds_conn_path *, void *), | |
b2c9272a | 693 | u64 *buffer, |
bb789763 | 694 | size_t item_len) |
992c9ec5 | 695 | { |
992c9ec5 SV |
696 | struct hlist_head *head; |
697 | struct rds_connection *conn; | |
698 | size_t i; | |
992c9ec5 SV |
699 | |
700 | rcu_read_lock(); | |
701 | ||
702 | lens->nr = 0; | |
703 | lens->each = item_len; | |
704 | ||
705 | for (i = 0, head = rds_conn_hash; i < ARRAY_SIZE(rds_conn_hash); | |
706 | i++, head++) { | |
707 | hlist_for_each_entry_rcu(conn, head, c_hash_node) { | |
708 | struct rds_conn_path *cp; | |
709 | ||
eee2fa6a KCP |
710 | /* XXX We only copy the information from the first |
711 | * path for now. The problem is that if there are | |
712 | * more than one underlying paths, we cannot report | |
713 | * information of all of them using the existing | |
714 | * API. For example, there is only one next_tx_seq, | |
715 | * which path's next_tx_seq should we report? It is | |
716 | * a bug in the design of MPRDS. | |
717 | */ | |
718 | cp = conn->c_path; | |
992c9ec5 | 719 | |
eee2fa6a KCP |
720 | /* XXX no cp_lock usage.. */ |
721 | if (!visitor(cp, buffer)) | |
722 | continue; | |
992c9ec5 SV |
723 | |
724 | /* We copy as much as we can fit in the buffer, | |
725 | * but we count all items so that the caller | |
726 | * can resize the buffer. | |
727 | */ | |
728 | if (len >= item_len) { | |
729 | rds_info_copy(iter, buffer, item_len); | |
730 | len -= item_len; | |
731 | } | |
732 | lens->nr++; | |
733 | } | |
734 | } | |
735 | rcu_read_unlock(); | |
736 | } | |
737 | ||
738 | static int rds_conn_info_visitor(struct rds_conn_path *cp, void *buffer) | |
00e0f34c AG |
739 | { |
740 | struct rds_info_connection *cinfo = buffer; | |
eee2fa6a | 741 | struct rds_connection *conn = cp->cp_conn; |
00e0f34c | 742 | |
1e2b44e7 KCP |
743 | if (conn->c_isv6) |
744 | return 0; | |
745 | ||
992c9ec5 SV |
746 | cinfo->next_tx_seq = cp->cp_next_tx_seq; |
747 | cinfo->next_rx_seq = cp->cp_next_rx_seq; | |
eee2fa6a KCP |
748 | cinfo->laddr = conn->c_laddr.s6_addr32[3]; |
749 | cinfo->faddr = conn->c_faddr.s6_addr32[3]; | |
fc640d4c | 750 | cinfo->tos = conn->c_tos; |
eee2fa6a | 751 | strncpy(cinfo->transport, conn->c_trans->t_name, |
00e0f34c AG |
752 | sizeof(cinfo->transport)); |
753 | cinfo->flags = 0; | |
754 | ||
992c9ec5 | 755 | rds_conn_info_set(cinfo->flags, test_bit(RDS_IN_XMIT, &cp->cp_flags), |
0f4b1c7e | 756 | SENDING); |
00e0f34c AG |
757 | /* XXX Future: return the state rather than these funky bits */ |
758 | rds_conn_info_set(cinfo->flags, | |
992c9ec5 | 759 | atomic_read(&cp->cp_state) == RDS_CONN_CONNECTING, |
00e0f34c AG |
760 | CONNECTING); |
761 | rds_conn_info_set(cinfo->flags, | |
992c9ec5 | 762 | atomic_read(&cp->cp_state) == RDS_CONN_UP, |
00e0f34c AG |
763 | CONNECTED); |
764 | return 1; | |
765 | } | |
766 | ||
e65d4d96 | 767 | #if IS_ENABLED(CONFIG_IPV6) |
b7ff8b10 KCP |
768 | static int rds6_conn_info_visitor(struct rds_conn_path *cp, void *buffer) |
769 | { | |
770 | struct rds6_info_connection *cinfo6 = buffer; | |
771 | struct rds_connection *conn = cp->cp_conn; | |
772 | ||
773 | cinfo6->next_tx_seq = cp->cp_next_tx_seq; | |
774 | cinfo6->next_rx_seq = cp->cp_next_rx_seq; | |
775 | cinfo6->laddr = conn->c_laddr; | |
776 | cinfo6->faddr = conn->c_faddr; | |
777 | strncpy(cinfo6->transport, conn->c_trans->t_name, | |
778 | sizeof(cinfo6->transport)); | |
779 | cinfo6->flags = 0; | |
780 | ||
781 | rds_conn_info_set(cinfo6->flags, test_bit(RDS_IN_XMIT, &cp->cp_flags), | |
782 | SENDING); | |
783 | /* XXX Future: return the state rather than these funky bits */ | |
784 | rds_conn_info_set(cinfo6->flags, | |
785 | atomic_read(&cp->cp_state) == RDS_CONN_CONNECTING, | |
786 | CONNECTING); | |
787 | rds_conn_info_set(cinfo6->flags, | |
788 | atomic_read(&cp->cp_state) == RDS_CONN_UP, | |
789 | CONNECTED); | |
790 | /* Just return 1 as there is no error case. This is a helper function | |
791 | * for rds_walk_conn_path_info() and it wants a return value. | |
792 | */ | |
793 | return 1; | |
794 | } | |
e65d4d96 | 795 | #endif |
b7ff8b10 | 796 | |
00e0f34c AG |
797 | static void rds_conn_info(struct socket *sock, unsigned int len, |
798 | struct rds_info_iterator *iter, | |
799 | struct rds_info_lengths *lens) | |
800 | { | |
b2c9272a SM |
801 | u64 buffer[(sizeof(struct rds_info_connection) + 7) / 8]; |
802 | ||
992c9ec5 | 803 | rds_walk_conn_path_info(sock, len, iter, lens, |
00e0f34c | 804 | rds_conn_info_visitor, |
b2c9272a | 805 | buffer, |
00e0f34c AG |
806 | sizeof(struct rds_info_connection)); |
807 | } | |
808 | ||
e65d4d96 | 809 | #if IS_ENABLED(CONFIG_IPV6) |
b7ff8b10 KCP |
810 | static void rds6_conn_info(struct socket *sock, unsigned int len, |
811 | struct rds_info_iterator *iter, | |
812 | struct rds_info_lengths *lens) | |
813 | { | |
814 | u64 buffer[(sizeof(struct rds6_info_connection) + 7) / 8]; | |
815 | ||
816 | rds_walk_conn_path_info(sock, len, iter, lens, | |
817 | rds6_conn_info_visitor, | |
818 | buffer, | |
819 | sizeof(struct rds6_info_connection)); | |
820 | } | |
e65d4d96 | 821 | #endif |
b7ff8b10 | 822 | |
ef87b7ea | 823 | int rds_conn_init(void) |
00e0f34c | 824 | { |
c809195f SV |
825 | int ret; |
826 | ||
827 | ret = rds_loop_net_init(); /* register pernet callback */ | |
828 | if (ret) | |
829 | return ret; | |
830 | ||
00e0f34c AG |
831 | rds_conn_slab = kmem_cache_create("rds_connection", |
832 | sizeof(struct rds_connection), | |
833 | 0, 0, NULL); | |
c809195f SV |
834 | if (!rds_conn_slab) { |
835 | rds_loop_net_exit(); | |
00e0f34c | 836 | return -ENOMEM; |
c809195f | 837 | } |
00e0f34c AG |
838 | |
839 | rds_info_register_func(RDS_INFO_CONNECTIONS, rds_conn_info); | |
840 | rds_info_register_func(RDS_INFO_SEND_MESSAGES, | |
841 | rds_conn_message_info_send); | |
842 | rds_info_register_func(RDS_INFO_RETRANS_MESSAGES, | |
843 | rds_conn_message_info_retrans); | |
e65d4d96 | 844 | #if IS_ENABLED(CONFIG_IPV6) |
b7ff8b10 KCP |
845 | rds_info_register_func(RDS6_INFO_CONNECTIONS, rds6_conn_info); |
846 | rds_info_register_func(RDS6_INFO_SEND_MESSAGES, | |
847 | rds6_conn_message_info_send); | |
848 | rds_info_register_func(RDS6_INFO_RETRANS_MESSAGES, | |
849 | rds6_conn_message_info_retrans); | |
e65d4d96 | 850 | #endif |
00e0f34c AG |
851 | return 0; |
852 | } | |
853 | ||
854 | void rds_conn_exit(void) | |
855 | { | |
c809195f | 856 | rds_loop_net_exit(); /* unregister pernet callback */ |
00e0f34c AG |
857 | rds_loop_exit(); |
858 | ||
859 | WARN_ON(!hlist_empty(rds_conn_hash)); | |
860 | ||
861 | kmem_cache_destroy(rds_conn_slab); | |
862 | ||
863 | rds_info_deregister_func(RDS_INFO_CONNECTIONS, rds_conn_info); | |
864 | rds_info_deregister_func(RDS_INFO_SEND_MESSAGES, | |
865 | rds_conn_message_info_send); | |
866 | rds_info_deregister_func(RDS_INFO_RETRANS_MESSAGES, | |
867 | rds_conn_message_info_retrans); | |
e65d4d96 | 868 | #if IS_ENABLED(CONFIG_IPV6) |
b7ff8b10 KCP |
869 | rds_info_deregister_func(RDS6_INFO_CONNECTIONS, rds6_conn_info); |
870 | rds_info_deregister_func(RDS6_INFO_SEND_MESSAGES, | |
871 | rds6_conn_message_info_send); | |
872 | rds_info_deregister_func(RDS6_INFO_RETRANS_MESSAGES, | |
873 | rds6_conn_message_info_retrans); | |
e65d4d96 | 874 | #endif |
00e0f34c AG |
875 | } |
876 | ||
877 | /* | |
878 | * Force a disconnect | |
879 | */ | |
aed20a53 | 880 | void rds_conn_path_drop(struct rds_conn_path *cp, bool destroy) |
0cb43965 SV |
881 | { |
882 | atomic_set(&cp->cp_state, RDS_CONN_ERROR); | |
aed20a53 | 883 | |
3db6e0d1 | 884 | rcu_read_lock(); |
ebeeb1ad | 885 | if (!destroy && rds_destroy_pending(cp->cp_conn)) { |
3db6e0d1 | 886 | rcu_read_unlock(); |
aed20a53 | 887 | return; |
3db6e0d1 | 888 | } |
0cb43965 | 889 | queue_work(rds_wq, &cp->cp_down_w); |
3db6e0d1 | 890 | rcu_read_unlock(); |
0cb43965 SV |
891 | } |
892 | EXPORT_SYMBOL_GPL(rds_conn_path_drop); | |
893 | ||
00e0f34c AG |
894 | void rds_conn_drop(struct rds_connection *conn) |
895 | { | |
5916e2c1 | 896 | WARN_ON(conn->c_trans->t_mp_capable); |
aed20a53 | 897 | rds_conn_path_drop(&conn->c_path[0], false); |
00e0f34c | 898 | } |
616b757a | 899 | EXPORT_SYMBOL_GPL(rds_conn_drop); |
00e0f34c | 900 | |
f3c6808d ZB |
901 | /* |
902 | * If the connection is down, trigger a connect. We may have scheduled a | |
903 | * delayed reconnect however - in this case we should not interfere. | |
904 | */ | |
3c0a5900 SV |
905 | void rds_conn_path_connect_if_down(struct rds_conn_path *cp) |
906 | { | |
3db6e0d1 | 907 | rcu_read_lock(); |
ebeeb1ad | 908 | if (rds_destroy_pending(cp->cp_conn)) { |
3db6e0d1 SV |
909 | rcu_read_unlock(); |
910 | return; | |
911 | } | |
3c0a5900 SV |
912 | if (rds_conn_path_state(cp) == RDS_CONN_DOWN && |
913 | !test_and_set_bit(RDS_RECONNECT_PENDING, &cp->cp_flags)) | |
914 | queue_delayed_work(rds_wq, &cp->cp_conn_w, 0); | |
3db6e0d1 | 915 | rcu_read_unlock(); |
3c0a5900 | 916 | } |
1a0e100f | 917 | EXPORT_SYMBOL_GPL(rds_conn_path_connect_if_down); |
3c0a5900 | 918 | |
9ef845f8 RS |
919 | /* Check connectivity of all paths |
920 | */ | |
921 | void rds_check_all_paths(struct rds_connection *conn) | |
922 | { | |
923 | int i = 0; | |
924 | ||
925 | do { | |
926 | rds_conn_path_connect_if_down(&conn->c_path[i]); | |
927 | } while (++i < conn->c_npaths); | |
928 | } | |
929 | ||
f3c6808d ZB |
930 | void rds_conn_connect_if_down(struct rds_connection *conn) |
931 | { | |
3c0a5900 SV |
932 | WARN_ON(conn->c_trans->t_mp_capable); |
933 | rds_conn_path_connect_if_down(&conn->c_path[0]); | |
f3c6808d ZB |
934 | } |
935 | EXPORT_SYMBOL_GPL(rds_conn_connect_if_down); | |
936 | ||
fb1b3dc4 SV |
937 | void |
938 | __rds_conn_path_error(struct rds_conn_path *cp, const char *fmt, ...) | |
939 | { | |
940 | va_list ap; | |
941 | ||
942 | va_start(ap, fmt); | |
943 | vprintk(fmt, ap); | |
944 | va_end(ap); | |
945 | ||
aed20a53 | 946 | rds_conn_path_drop(cp, false); |
fb1b3dc4 | 947 | } |