2 * Copyright (c) 2006 Oracle. All rights reserved.
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:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
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.
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
33 #include <linux/kernel.h>
35 #include <linux/slab.h>
36 #include <linux/vmalloc.h>
42 * Set the selected protocol version
44 static void rds_iw_set_protocol(struct rds_connection
*conn
, unsigned int version
)
46 conn
->c_version
= version
;
52 static void rds_iw_set_flow_control(struct rds_connection
*conn
, u32 credits
)
54 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
56 if (rds_iw_sysctl_flow_control
&& credits
!= 0) {
57 /* We're doing flow control */
59 rds_iw_send_add_credits(conn
, credits
);
66 * Connection established.
67 * We get here for both outgoing and incoming connection.
69 void rds_iw_cm_connect_complete(struct rds_connection
*conn
, struct rdma_cm_event
*event
)
71 const struct rds_iw_connect_private
*dp
= NULL
;
72 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
73 struct rds_iw_device
*rds_iwdev
;
76 if (event
->param
.conn
.private_data_len
) {
77 dp
= event
->param
.conn
.private_data
;
79 rds_iw_set_protocol(conn
,
80 RDS_PROTOCOL(dp
->dp_protocol_major
,
81 dp
->dp_protocol_minor
));
82 rds_iw_set_flow_control(conn
, be32_to_cpu(dp
->dp_credit
));
85 /* update ib_device with this local ipaddr & conn */
86 rds_iwdev
= ib_get_client_data(ic
->i_cm_id
->device
, &rds_iw_client
);
87 err
= rds_iw_update_cm_id(rds_iwdev
, ic
->i_cm_id
);
89 printk(KERN_ERR
"rds_iw_update_ipaddr failed (%d)\n", err
);
90 rds_iw_add_conn(rds_iwdev
, conn
);
92 /* If the peer gave us the last packet it saw, process this as if
93 * we had received a regular ACK. */
94 if (dp
&& dp
->dp_ack_seq
)
95 rds_send_drop_acked(conn
, be64_to_cpu(dp
->dp_ack_seq
), NULL
);
97 printk(KERN_NOTICE
"RDS/IW: connected to %pI4<->%pI4 version %u.%u%s\n",
98 &conn
->c_laddr
, &conn
->c_faddr
,
99 RDS_PROTOCOL_MAJOR(conn
->c_version
),
100 RDS_PROTOCOL_MINOR(conn
->c_version
),
101 ic
->i_flowctl
? ", flow control" : "");
103 rds_connect_complete(conn
);
106 static void rds_iw_cm_fill_conn_param(struct rds_connection
*conn
,
107 struct rdma_conn_param
*conn_param
,
108 struct rds_iw_connect_private
*dp
,
109 u32 protocol_version
)
111 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
113 memset(conn_param
, 0, sizeof(struct rdma_conn_param
));
114 conn_param
->responder_resources
= 1;
115 conn_param
->initiator_depth
= 1;
118 memset(dp
, 0, sizeof(*dp
));
119 dp
->dp_saddr
= conn
->c_laddr
;
120 dp
->dp_daddr
= conn
->c_faddr
;
121 dp
->dp_protocol_major
= RDS_PROTOCOL_MAJOR(protocol_version
);
122 dp
->dp_protocol_minor
= RDS_PROTOCOL_MINOR(protocol_version
);
123 dp
->dp_protocol_minor_mask
= cpu_to_be16(RDS_IW_SUPPORTED_PROTOCOLS
);
124 dp
->dp_ack_seq
= rds_iw_piggyb_ack(ic
);
126 /* Advertise flow control */
128 unsigned int credits
;
130 credits
= IB_GET_POST_CREDITS(atomic_read(&ic
->i_credits
));
131 dp
->dp_credit
= cpu_to_be32(credits
);
132 atomic_sub(IB_SET_POST_CREDITS(credits
), &ic
->i_credits
);
135 conn_param
->private_data
= dp
;
136 conn_param
->private_data_len
= sizeof(*dp
);
140 static void rds_iw_cq_event_handler(struct ib_event
*event
, void *data
)
142 rdsdebug("event %u data %p\n", event
->event
, data
);
145 static void rds_iw_qp_event_handler(struct ib_event
*event
, void *data
)
147 struct rds_connection
*conn
= data
;
148 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
150 rdsdebug("conn %p ic %p event %u\n", conn
, ic
, event
->event
);
152 switch (event
->event
) {
153 case IB_EVENT_COMM_EST
:
154 rdma_notify(ic
->i_cm_id
, IB_EVENT_COMM_EST
);
156 case IB_EVENT_QP_REQ_ERR
:
157 case IB_EVENT_QP_FATAL
:
159 rdsdebug("Fatal QP Event %u "
160 "- connection %pI4->%pI4, reconnecting\n",
161 event
->event
, &conn
->c_laddr
,
171 static int rds_iw_init_qp_attrs(struct ib_qp_init_attr
*attr
,
172 struct rds_iw_device
*rds_iwdev
,
173 struct rds_iw_work_ring
*send_ring
,
174 void (*send_cq_handler
)(struct ib_cq
*, void *),
175 struct rds_iw_work_ring
*recv_ring
,
176 void (*recv_cq_handler
)(struct ib_cq
*, void *),
179 struct ib_device
*dev
= rds_iwdev
->dev
;
180 unsigned int send_size
, recv_size
;
183 /* The offset of 1 is to accomodate the additional ACK WR. */
184 send_size
= min_t(unsigned int, rds_iwdev
->max_wrs
, rds_iw_sysctl_max_send_wr
+ 1);
185 recv_size
= min_t(unsigned int, rds_iwdev
->max_wrs
, rds_iw_sysctl_max_recv_wr
+ 1);
186 rds_iw_ring_resize(send_ring
, send_size
- 1);
187 rds_iw_ring_resize(recv_ring
, recv_size
- 1);
189 memset(attr
, 0, sizeof(*attr
));
190 attr
->event_handler
= rds_iw_qp_event_handler
;
191 attr
->qp_context
= context
;
192 attr
->cap
.max_send_wr
= send_size
;
193 attr
->cap
.max_recv_wr
= recv_size
;
194 attr
->cap
.max_send_sge
= rds_iwdev
->max_sge
;
195 attr
->cap
.max_recv_sge
= RDS_IW_RECV_SGE
;
196 attr
->sq_sig_type
= IB_SIGNAL_REQ_WR
;
197 attr
->qp_type
= IB_QPT_RC
;
199 attr
->send_cq
= ib_create_cq(dev
, send_cq_handler
,
200 rds_iw_cq_event_handler
,
201 context
, send_size
, 0);
202 if (IS_ERR(attr
->send_cq
)) {
203 ret
= PTR_ERR(attr
->send_cq
);
204 attr
->send_cq
= NULL
;
205 rdsdebug("ib_create_cq send failed: %d\n", ret
);
209 attr
->recv_cq
= ib_create_cq(dev
, recv_cq_handler
,
210 rds_iw_cq_event_handler
,
211 context
, recv_size
, 0);
212 if (IS_ERR(attr
->recv_cq
)) {
213 ret
= PTR_ERR(attr
->recv_cq
);
214 attr
->recv_cq
= NULL
;
215 rdsdebug("ib_create_cq send failed: %d\n", ret
);
219 ret
= ib_req_notify_cq(attr
->send_cq
, IB_CQ_NEXT_COMP
);
221 rdsdebug("ib_req_notify_cq send failed: %d\n", ret
);
225 ret
= ib_req_notify_cq(attr
->recv_cq
, IB_CQ_SOLICITED
);
227 rdsdebug("ib_req_notify_cq recv failed: %d\n", ret
);
234 ib_destroy_cq(attr
->send_cq
);
236 ib_destroy_cq(attr
->recv_cq
);
242 * This needs to be very careful to not leave IS_ERR pointers around for
243 * cleanup to trip over.
245 static int rds_iw_setup_qp(struct rds_connection
*conn
)
247 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
248 struct ib_device
*dev
= ic
->i_cm_id
->device
;
249 struct ib_qp_init_attr attr
;
250 struct rds_iw_device
*rds_iwdev
;
253 /* rds_iw_add_one creates a rds_iw_device object per IB device,
254 * and allocates a protection domain, memory range and MR pool
255 * for each. If that fails for any reason, it will not register
256 * the rds_iwdev at all.
258 rds_iwdev
= ib_get_client_data(dev
, &rds_iw_client
);
259 if (rds_iwdev
== NULL
) {
260 if (printk_ratelimit())
261 printk(KERN_NOTICE
"RDS/IW: No client_data for device %s\n",
266 /* Protection domain and memory range */
267 ic
->i_pd
= rds_iwdev
->pd
;
268 ic
->i_mr
= rds_iwdev
->mr
;
270 ret
= rds_iw_init_qp_attrs(&attr
, rds_iwdev
,
271 &ic
->i_send_ring
, rds_iw_send_cq_comp_handler
,
272 &ic
->i_recv_ring
, rds_iw_recv_cq_comp_handler
,
277 ic
->i_send_cq
= attr
.send_cq
;
278 ic
->i_recv_cq
= attr
.recv_cq
;
280 ret
= rdma_create_qp(ic
->i_cm_id
, ic
->i_pd
, &attr
);
282 rdsdebug("rdma_create_qp failed: %d\n", ret
);
286 ic
->i_send_hdrs
= ib_dma_alloc_coherent(dev
,
287 ic
->i_send_ring
.w_nr
*
288 sizeof(struct rds_header
),
289 &ic
->i_send_hdrs_dma
, GFP_KERNEL
);
290 if (ic
->i_send_hdrs
== NULL
) {
292 rdsdebug("ib_dma_alloc_coherent send failed\n");
296 ic
->i_recv_hdrs
= ib_dma_alloc_coherent(dev
,
297 ic
->i_recv_ring
.w_nr
*
298 sizeof(struct rds_header
),
299 &ic
->i_recv_hdrs_dma
, GFP_KERNEL
);
300 if (ic
->i_recv_hdrs
== NULL
) {
302 rdsdebug("ib_dma_alloc_coherent recv failed\n");
306 ic
->i_ack
= ib_dma_alloc_coherent(dev
, sizeof(struct rds_header
),
307 &ic
->i_ack_dma
, GFP_KERNEL
);
308 if (ic
->i_ack
== NULL
) {
310 rdsdebug("ib_dma_alloc_coherent ack failed\n");
314 ic
->i_sends
= vmalloc(ic
->i_send_ring
.w_nr
* sizeof(struct rds_iw_send_work
));
315 if (ic
->i_sends
== NULL
) {
317 rdsdebug("send allocation failed\n");
320 rds_iw_send_init_ring(ic
);
322 ic
->i_recvs
= vmalloc(ic
->i_recv_ring
.w_nr
* sizeof(struct rds_iw_recv_work
));
323 if (ic
->i_recvs
== NULL
) {
325 rdsdebug("recv allocation failed\n");
329 rds_iw_recv_init_ring(ic
);
330 rds_iw_recv_init_ack(ic
);
332 /* Post receive buffers - as a side effect, this will update
333 * the posted credit count. */
334 rds_iw_recv_refill(conn
, GFP_KERNEL
, GFP_HIGHUSER
, 1);
336 rdsdebug("conn %p pd %p mr %p cq %p %p\n", conn
, ic
->i_pd
, ic
->i_mr
,
337 ic
->i_send_cq
, ic
->i_recv_cq
);
343 static u32
rds_iw_protocol_compatible(const struct rds_iw_connect_private
*dp
)
348 /* rdma_cm private data is odd - when there is any private data in the
349 * request, we will be given a pretty large buffer without telling us the
350 * original size. The only way to tell the difference is by looking at
351 * the contents, which are initialized to zero.
352 * If the protocol version fields aren't set, this is a connection attempt
353 * from an older version. This could could be 3.0 or 2.0 - we can't tell.
354 * We really should have changed this for OFED 1.3 :-( */
355 if (dp
->dp_protocol_major
== 0)
356 return RDS_PROTOCOL_3_0
;
358 common
= be16_to_cpu(dp
->dp_protocol_minor_mask
) & RDS_IW_SUPPORTED_PROTOCOLS
;
359 if (dp
->dp_protocol_major
== 3 && common
) {
360 version
= RDS_PROTOCOL_3_0
;
361 while ((common
>>= 1) != 0)
363 } else if (printk_ratelimit()) {
364 printk(KERN_NOTICE
"RDS: Connection from %pI4 using "
365 "incompatible protocol version %u.%u\n",
367 dp
->dp_protocol_major
,
368 dp
->dp_protocol_minor
);
373 int rds_iw_cm_handle_connect(struct rdma_cm_id
*cm_id
,
374 struct rdma_cm_event
*event
)
376 const struct rds_iw_connect_private
*dp
= event
->param
.conn
.private_data
;
377 struct rds_iw_connect_private dp_rep
;
378 struct rds_connection
*conn
= NULL
;
379 struct rds_iw_connection
*ic
= NULL
;
380 struct rdma_conn_param conn_param
;
381 struct rds_iw_device
*rds_iwdev
;
383 int err
, destroy
= 1;
385 /* Check whether the remote protocol version matches ours. */
386 version
= rds_iw_protocol_compatible(dp
);
390 rdsdebug("saddr %pI4 daddr %pI4 RDSv%u.%u\n",
391 &dp
->dp_saddr
, &dp
->dp_daddr
,
392 RDS_PROTOCOL_MAJOR(version
), RDS_PROTOCOL_MINOR(version
));
394 conn
= rds_conn_create(dp
->dp_daddr
, dp
->dp_saddr
, &rds_iw_transport
,
397 rdsdebug("rds_conn_create failed (%ld)\n", PTR_ERR(conn
));
403 * The connection request may occur while the
404 * previous connection exist, e.g. in case of failover.
405 * But as connections may be initiated simultaneously
406 * by both hosts, we have a random backoff mechanism -
407 * see the comment above rds_queue_reconnect()
409 mutex_lock(&conn
->c_cm_lock
);
410 if (!rds_conn_transition(conn
, RDS_CONN_DOWN
, RDS_CONN_CONNECTING
)) {
411 if (rds_conn_state(conn
) == RDS_CONN_UP
) {
412 rdsdebug("incoming connect while connecting\n");
414 rds_iw_stats_inc(s_iw_listen_closed_stale
);
416 if (rds_conn_state(conn
) == RDS_CONN_CONNECTING
) {
417 /* Wait and see - our connect may still be succeeding */
418 rds_iw_stats_inc(s_iw_connect_raced
);
420 mutex_unlock(&conn
->c_cm_lock
);
424 ic
= conn
->c_transport_data
;
426 rds_iw_set_protocol(conn
, version
);
427 rds_iw_set_flow_control(conn
, be32_to_cpu(dp
->dp_credit
));
429 /* If the peer gave us the last packet it saw, process this as if
430 * we had received a regular ACK. */
432 rds_send_drop_acked(conn
, be64_to_cpu(dp
->dp_ack_seq
), NULL
);
434 BUG_ON(cm_id
->context
);
438 cm_id
->context
= conn
;
440 rds_iwdev
= ib_get_client_data(cm_id
->device
, &rds_iw_client
);
441 ic
->i_dma_local_lkey
= rds_iwdev
->dma_local_lkey
;
443 /* We got halfway through setting up the ib_connection, if we
444 * fail now, we have to take the long route out of this mess. */
447 err
= rds_iw_setup_qp(conn
);
449 rds_iw_conn_error(conn
, "rds_iw_setup_qp failed (%d)\n", err
);
450 mutex_unlock(&conn
->c_cm_lock
);
454 rds_iw_cm_fill_conn_param(conn
, &conn_param
, &dp_rep
, version
);
456 /* rdma_accept() calls rdma_reject() internally if it fails */
457 err
= rdma_accept(cm_id
, &conn_param
);
458 mutex_unlock(&conn
->c_cm_lock
);
460 rds_iw_conn_error(conn
, "rdma_accept failed (%d)\n", err
);
467 rdma_reject(cm_id
, NULL
, 0);
472 int rds_iw_cm_initiate_connect(struct rdma_cm_id
*cm_id
)
474 struct rds_connection
*conn
= cm_id
->context
;
475 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
476 struct rdma_conn_param conn_param
;
477 struct rds_iw_connect_private dp
;
480 /* If the peer doesn't do protocol negotiation, we must
481 * default to RDSv3.0 */
482 rds_iw_set_protocol(conn
, RDS_PROTOCOL_3_0
);
483 ic
->i_flowctl
= rds_iw_sysctl_flow_control
; /* advertise flow control */
485 ret
= rds_iw_setup_qp(conn
);
487 rds_iw_conn_error(conn
, "rds_iw_setup_qp failed (%d)\n", ret
);
491 rds_iw_cm_fill_conn_param(conn
, &conn_param
, &dp
, RDS_PROTOCOL_VERSION
);
493 ret
= rdma_connect(cm_id
, &conn_param
);
495 rds_iw_conn_error(conn
, "rdma_connect failed (%d)\n", ret
);
498 /* Beware - returning non-zero tells the rdma_cm to destroy
499 * the cm_id. We should certainly not do it as long as we still
500 * "own" the cm_id. */
502 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
504 if (ic
->i_cm_id
== cm_id
)
510 int rds_iw_conn_connect(struct rds_connection
*conn
)
512 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
513 struct rds_iw_device
*rds_iwdev
;
514 struct sockaddr_in src
, dest
;
517 /* delegate cm event handler to rdma_transport */
518 ic
->i_cm_id
= rdma_create_id(rds_rdma_cm_event_handler
, conn
,
520 if (IS_ERR(ic
->i_cm_id
)) {
521 ret
= PTR_ERR(ic
->i_cm_id
);
523 rdsdebug("rdma_create_id() failed: %d\n", ret
);
527 rdsdebug("created cm id %p for conn %p\n", ic
->i_cm_id
, conn
);
529 src
.sin_family
= AF_INET
;
530 src
.sin_addr
.s_addr
= (__force u32
)conn
->c_laddr
;
531 src
.sin_port
= (__force u16
)htons(0);
533 /* First, bind to the local address and device. */
534 ret
= rdma_bind_addr(ic
->i_cm_id
, (struct sockaddr
*) &src
);
536 rdsdebug("rdma_bind_addr(%pI4) failed: %d\n",
537 &conn
->c_laddr
, ret
);
538 rdma_destroy_id(ic
->i_cm_id
);
543 rds_iwdev
= ib_get_client_data(ic
->i_cm_id
->device
, &rds_iw_client
);
544 ic
->i_dma_local_lkey
= rds_iwdev
->dma_local_lkey
;
546 dest
.sin_family
= AF_INET
;
547 dest
.sin_addr
.s_addr
= (__force u32
)conn
->c_faddr
;
548 dest
.sin_port
= (__force u16
)htons(RDS_PORT
);
550 ret
= rdma_resolve_addr(ic
->i_cm_id
, (struct sockaddr
*)&src
,
551 (struct sockaddr
*)&dest
,
552 RDS_RDMA_RESOLVE_TIMEOUT_MS
);
554 rdsdebug("addr resolve failed for cm id %p: %d\n", ic
->i_cm_id
,
556 rdma_destroy_id(ic
->i_cm_id
);
565 * This is so careful about only cleaning up resources that were built up
566 * so that it can be called at any point during startup. In fact it
567 * can be called multiple times for a given connection.
569 void rds_iw_conn_shutdown(struct rds_connection
*conn
)
571 struct rds_iw_connection
*ic
= conn
->c_transport_data
;
573 struct ib_qp_attr qp_attr
;
575 rdsdebug("cm %p pd %p cq %p %p qp %p\n", ic
->i_cm_id
,
576 ic
->i_pd
, ic
->i_send_cq
, ic
->i_recv_cq
,
577 ic
->i_cm_id
? ic
->i_cm_id
->qp
: NULL
);
580 struct ib_device
*dev
= ic
->i_cm_id
->device
;
582 rdsdebug("disconnecting cm %p\n", ic
->i_cm_id
);
583 err
= rdma_disconnect(ic
->i_cm_id
);
585 /* Actually this may happen quite frequently, when
586 * an outgoing connect raced with an incoming connect.
588 rdsdebug("rds_iw_conn_shutdown: failed to disconnect,"
589 " cm: %p err %d\n", ic
->i_cm_id
, err
);
592 if (ic
->i_cm_id
->qp
) {
593 qp_attr
.qp_state
= IB_QPS_ERR
;
594 ib_modify_qp(ic
->i_cm_id
->qp
, &qp_attr
, IB_QP_STATE
);
597 wait_event(rds_iw_ring_empty_wait
,
598 rds_iw_ring_empty(&ic
->i_send_ring
) &&
599 rds_iw_ring_empty(&ic
->i_recv_ring
));
602 ib_dma_free_coherent(dev
,
603 ic
->i_send_ring
.w_nr
*
604 sizeof(struct rds_header
),
606 ic
->i_send_hdrs_dma
);
609 ib_dma_free_coherent(dev
,
610 ic
->i_recv_ring
.w_nr
*
611 sizeof(struct rds_header
),
613 ic
->i_recv_hdrs_dma
);
616 ib_dma_free_coherent(dev
, sizeof(struct rds_header
),
617 ic
->i_ack
, ic
->i_ack_dma
);
620 rds_iw_send_clear_ring(ic
);
622 rds_iw_recv_clear_ring(ic
);
625 rdma_destroy_qp(ic
->i_cm_id
);
627 ib_destroy_cq(ic
->i_send_cq
);
629 ib_destroy_cq(ic
->i_recv_cq
);
632 * If associated with an rds_iw_device:
633 * Move connection back to the nodev list.
634 * Remove cm_id from the device cm_id list.
637 rds_iw_remove_conn(ic
->rds_iwdev
, conn
);
639 rdma_destroy_id(ic
->i_cm_id
);
644 ic
->i_send_cq
= NULL
;
645 ic
->i_recv_cq
= NULL
;
646 ic
->i_send_hdrs
= NULL
;
647 ic
->i_recv_hdrs
= NULL
;
650 BUG_ON(ic
->rds_iwdev
);
652 /* Clear pending transmit */
654 rds_message_put(ic
->i_rm
);
658 /* Clear the ACK state */
659 clear_bit(IB_ACK_IN_FLIGHT
, &ic
->i_ack_flags
);
660 #ifdef KERNEL_HAS_ATOMIC64
661 atomic64_set(&ic
->i_ack_next
, 0);
667 /* Clear flow control state */
669 atomic_set(&ic
->i_credits
, 0);
671 rds_iw_ring_init(&ic
->i_send_ring
, rds_iw_sysctl_max_send_wr
);
672 rds_iw_ring_init(&ic
->i_recv_ring
, rds_iw_sysctl_max_recv_wr
);
675 rds_inc_put(&ic
->i_iwinc
->ii_inc
);
683 rdsdebug("shutdown complete\n");
686 int rds_iw_conn_alloc(struct rds_connection
*conn
, gfp_t gfp
)
688 struct rds_iw_connection
*ic
;
691 ic
= kzalloc(sizeof(struct rds_iw_connection
), GFP_KERNEL
);
695 INIT_LIST_HEAD(&ic
->iw_node
);
696 tasklet_init(&ic
->i_recv_tasklet
, rds_iw_recv_tasklet_fn
,
698 mutex_init(&ic
->i_recv_mutex
);
699 #ifndef KERNEL_HAS_ATOMIC64
700 spin_lock_init(&ic
->i_ack_lock
);
704 * rds_iw_conn_shutdown() waits for these to be emptied so they
705 * must be initialized before it can be called.
707 rds_iw_ring_init(&ic
->i_send_ring
, rds_iw_sysctl_max_send_wr
);
708 rds_iw_ring_init(&ic
->i_recv_ring
, rds_iw_sysctl_max_recv_wr
);
711 conn
->c_transport_data
= ic
;
713 spin_lock_irqsave(&iw_nodev_conns_lock
, flags
);
714 list_add_tail(&ic
->iw_node
, &iw_nodev_conns
);
715 spin_unlock_irqrestore(&iw_nodev_conns_lock
, flags
);
718 rdsdebug("conn %p conn ic %p\n", conn
, conn
->c_transport_data
);
723 * Free a connection. Connection must be shut down and not set for reconnect.
725 void rds_iw_conn_free(void *arg
)
727 struct rds_iw_connection
*ic
= arg
;
728 spinlock_t
*lock_ptr
;
730 rdsdebug("ic %p\n", ic
);
733 * Conn is either on a dev's list or on the nodev list.
734 * A race with shutdown() or connect() would cause problems
735 * (since rds_iwdev would change) but that should never happen.
737 lock_ptr
= ic
->rds_iwdev
? &ic
->rds_iwdev
->spinlock
: &iw_nodev_conns_lock
;
739 spin_lock_irq(lock_ptr
);
740 list_del(&ic
->iw_node
);
741 spin_unlock_irq(lock_ptr
);
747 * An error occurred on the connection
750 __rds_iw_conn_error(struct rds_connection
*conn
, const char *fmt
, ...)