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>
36 #include <linux/netdevice.h>
37 #include <linux/inetdevice.h>
38 #include <linux/if_arp.h>
39 #include <linux/delay.h>
40 #include <linux/slab.h>
41 #include <linux/module.h>
46 unsigned int fastreg_pool_size
= RDS_FASTREG_POOL_SIZE
;
47 unsigned int fastreg_message_size
= RDS_FASTREG_SIZE
+ 1; /* +1 allows for unaligned MRs */
49 module_param(fastreg_pool_size
, int, 0444);
50 MODULE_PARM_DESC(fastreg_pool_size
, " Max number of fastreg MRs per device");
51 module_param(fastreg_message_size
, int, 0444);
52 MODULE_PARM_DESC(fastreg_message_size
, " Max size of a RDMA transfer (fastreg MRs)");
54 struct list_head rds_iw_devices
;
56 /* NOTE: if also grabbing iwdev lock, grab this first */
57 DEFINE_SPINLOCK(iw_nodev_conns_lock
);
58 LIST_HEAD(iw_nodev_conns
);
60 static void rds_iw_add_one(struct ib_device
*device
)
62 struct rds_iw_device
*rds_iwdev
;
64 /* Only handle iwarp devices */
65 if (device
->node_type
!= RDMA_NODE_RNIC
)
68 rds_iwdev
= kmalloc(sizeof *rds_iwdev
, GFP_KERNEL
);
72 spin_lock_init(&rds_iwdev
->spinlock
);
74 rds_iwdev
->dma_local_lkey
= !!(device
->attrs
.device_cap_flags
& IB_DEVICE_LOCAL_DMA_LKEY
);
75 rds_iwdev
->max_wrs
= device
->attrs
.max_qp_wr
;
76 rds_iwdev
->max_sge
= min(device
->attrs
.max_sge
, RDS_IW_MAX_SGE
);
78 rds_iwdev
->dev
= device
;
79 rds_iwdev
->pd
= ib_alloc_pd(device
);
80 if (IS_ERR(rds_iwdev
->pd
))
83 if (!rds_iwdev
->dma_local_lkey
) {
84 rds_iwdev
->mr
= ib_get_dma_mr(rds_iwdev
->pd
,
85 IB_ACCESS_REMOTE_READ
|
86 IB_ACCESS_REMOTE_WRITE
|
87 IB_ACCESS_LOCAL_WRITE
);
88 if (IS_ERR(rds_iwdev
->mr
))
93 rds_iwdev
->mr_pool
= rds_iw_create_mr_pool(rds_iwdev
);
94 if (IS_ERR(rds_iwdev
->mr_pool
)) {
95 rds_iwdev
->mr_pool
= NULL
;
99 INIT_LIST_HEAD(&rds_iwdev
->cm_id_list
);
100 INIT_LIST_HEAD(&rds_iwdev
->conn_list
);
101 list_add_tail(&rds_iwdev
->list
, &rds_iw_devices
);
103 ib_set_client_data(device
, &rds_iw_client
, rds_iwdev
);
108 ib_dereg_mr(rds_iwdev
->mr
);
110 ib_dealloc_pd(rds_iwdev
->pd
);
115 static void rds_iw_remove_one(struct ib_device
*device
, void *client_data
)
117 struct rds_iw_device
*rds_iwdev
= client_data
;
118 struct rds_iw_cm_id
*i_cm_id
, *next
;
123 spin_lock_irq(&rds_iwdev
->spinlock
);
124 list_for_each_entry_safe(i_cm_id
, next
, &rds_iwdev
->cm_id_list
, list
) {
125 list_del(&i_cm_id
->list
);
128 spin_unlock_irq(&rds_iwdev
->spinlock
);
130 rds_iw_destroy_conns(rds_iwdev
);
132 if (rds_iwdev
->mr_pool
)
133 rds_iw_destroy_mr_pool(rds_iwdev
->mr_pool
);
136 ib_dereg_mr(rds_iwdev
->mr
);
138 ib_dealloc_pd(rds_iwdev
->pd
);
140 list_del(&rds_iwdev
->list
);
144 struct ib_client rds_iw_client
= {
146 .add
= rds_iw_add_one
,
147 .remove
= rds_iw_remove_one
150 static int rds_iw_conn_info_visitor(struct rds_connection
*conn
,
153 struct rds_info_rdma_connection
*iinfo
= buffer
;
154 struct rds_iw_connection
*ic
;
156 /* We will only ever look at IB transports */
157 if (conn
->c_trans
!= &rds_iw_transport
)
160 iinfo
->src_addr
= conn
->c_laddr
;
161 iinfo
->dst_addr
= conn
->c_faddr
;
163 memset(&iinfo
->src_gid
, 0, sizeof(iinfo
->src_gid
));
164 memset(&iinfo
->dst_gid
, 0, sizeof(iinfo
->dst_gid
));
165 if (rds_conn_state(conn
) == RDS_CONN_UP
) {
166 struct rds_iw_device
*rds_iwdev
;
167 struct rdma_dev_addr
*dev_addr
;
169 ic
= conn
->c_transport_data
;
170 dev_addr
= &ic
->i_cm_id
->route
.addr
.dev_addr
;
172 rdma_addr_get_sgid(dev_addr
, (union ib_gid
*) &iinfo
->src_gid
);
173 rdma_addr_get_dgid(dev_addr
, (union ib_gid
*) &iinfo
->dst_gid
);
175 rds_iwdev
= ib_get_client_data(ic
->i_cm_id
->device
, &rds_iw_client
);
176 iinfo
->max_send_wr
= ic
->i_send_ring
.w_nr
;
177 iinfo
->max_recv_wr
= ic
->i_recv_ring
.w_nr
;
178 iinfo
->max_send_sge
= rds_iwdev
->max_sge
;
179 rds_iw_get_mr_info(rds_iwdev
, iinfo
);
184 static void rds_iw_ic_info(struct socket
*sock
, unsigned int len
,
185 struct rds_info_iterator
*iter
,
186 struct rds_info_lengths
*lens
)
188 rds_for_each_conn_info(sock
, len
, iter
, lens
,
189 rds_iw_conn_info_visitor
,
190 sizeof(struct rds_info_rdma_connection
));
195 * Early RDS/IB was built to only bind to an address if there is an IPoIB
196 * device with that address set.
198 * If it were me, I'd advocate for something more flexible. Sending and
199 * receiving should be device-agnostic. Transports would try and maintain
200 * connections between peers who have messages queued. Userspace would be
201 * allowed to influence which paths have priority. We could call userspace
202 * asserting this policy "routing".
204 static int rds_iw_laddr_check(struct net
*net
, __be32 addr
)
207 struct rdma_cm_id
*cm_id
;
208 struct sockaddr_in sin
;
210 /* Create a CMA ID and try to bind it. This catches both
211 * IB and iWARP capable NICs.
213 cm_id
= rdma_create_id(&init_net
, NULL
, NULL
, RDMA_PS_TCP
, IB_QPT_RC
);
215 return PTR_ERR(cm_id
);
217 memset(&sin
, 0, sizeof(sin
));
218 sin
.sin_family
= AF_INET
;
219 sin
.sin_addr
.s_addr
= addr
;
221 /* rdma_bind_addr will only succeed for IB & iWARP devices */
222 ret
= rdma_bind_addr(cm_id
, (struct sockaddr
*)&sin
);
223 /* due to this, we will claim to support IB devices unless we
225 if (ret
|| !cm_id
->device
||
226 cm_id
->device
->node_type
!= RDMA_NODE_RNIC
)
227 ret
= -EADDRNOTAVAIL
;
229 rdsdebug("addr %pI4 ret %d node type %d\n",
231 cm_id
->device
? cm_id
->device
->node_type
: -1);
233 rdma_destroy_id(cm_id
);
238 void rds_iw_exit(void)
240 rds_info_deregister_func(RDS_INFO_IWARP_CONNECTIONS
, rds_iw_ic_info
);
241 rds_iw_destroy_nodev_conns();
242 ib_unregister_client(&rds_iw_client
);
243 rds_iw_sysctl_exit();
245 rds_trans_unregister(&rds_iw_transport
);
248 struct rds_transport rds_iw_transport
= {
249 .laddr_check
= rds_iw_laddr_check
,
250 .xmit_complete
= rds_iw_xmit_complete
,
252 .xmit_rdma
= rds_iw_xmit_rdma
,
254 .conn_alloc
= rds_iw_conn_alloc
,
255 .conn_free
= rds_iw_conn_free
,
256 .conn_connect
= rds_iw_conn_connect
,
257 .conn_shutdown
= rds_iw_conn_shutdown
,
258 .inc_copy_to_user
= rds_iw_inc_copy_to_user
,
259 .inc_free
= rds_iw_inc_free
,
260 .cm_initiate_connect
= rds_iw_cm_initiate_connect
,
261 .cm_handle_connect
= rds_iw_cm_handle_connect
,
262 .cm_connect_complete
= rds_iw_cm_connect_complete
,
263 .stats_info_copy
= rds_iw_stats_info_copy
,
265 .get_mr
= rds_iw_get_mr
,
266 .sync_mr
= rds_iw_sync_mr
,
267 .free_mr
= rds_iw_free_mr
,
268 .flush_mrs
= rds_iw_flush_mrs
,
269 .t_owner
= THIS_MODULE
,
271 .t_type
= RDS_TRANS_IWARP
,
272 .t_prefer_loopback
= 1,
275 int rds_iw_init(void)
279 INIT_LIST_HEAD(&rds_iw_devices
);
281 ret
= ib_register_client(&rds_iw_client
);
285 ret
= rds_iw_sysctl_init();
289 ret
= rds_iw_recv_init();
293 ret
= rds_trans_register(&rds_iw_transport
);
297 rds_info_register_func(RDS_INFO_IWARP_CONNECTIONS
, rds_iw_ic_info
);
304 rds_iw_sysctl_exit();
306 ib_unregister_client(&rds_iw_client
);
311 MODULE_LICENSE("GPL");