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>
44 unsigned int fastreg_pool_size
= RDS_FASTREG_POOL_SIZE
;
45 unsigned int fastreg_message_size
= RDS_FASTREG_SIZE
+ 1; /* +1 allows for unaligned MRs */
47 module_param(fastreg_pool_size
, int, 0444);
48 MODULE_PARM_DESC(fastreg_pool_size
, " Max number of fastreg MRs per device");
49 module_param(fastreg_message_size
, int, 0444);
50 MODULE_PARM_DESC(fastreg_message_size
, " Max size of a RDMA transfer (fastreg MRs)");
52 struct list_head rds_iw_devices
;
54 DEFINE_SPINLOCK(iw_nodev_conns_lock
);
55 LIST_HEAD(iw_nodev_conns
);
57 void rds_iw_add_one(struct ib_device
*device
)
59 struct rds_iw_device
*rds_iwdev
;
60 struct ib_device_attr
*dev_attr
;
62 /* Only handle iwarp devices */
63 if (device
->node_type
!= RDMA_NODE_RNIC
)
66 dev_attr
= kmalloc(sizeof *dev_attr
, GFP_KERNEL
);
70 if (ib_query_device(device
, dev_attr
)) {
71 rdsdebug("Query device failed for %s\n", device
->name
);
75 rds_iwdev
= kmalloc(sizeof *rds_iwdev
, GFP_KERNEL
);
79 spin_lock_init(&rds_iwdev
->spinlock
);
81 rds_iwdev
->dma_local_lkey
= !!(dev_attr
->device_cap_flags
& IB_DEVICE_LOCAL_DMA_LKEY
);
82 rds_iwdev
->max_wrs
= dev_attr
->max_qp_wr
;
83 rds_iwdev
->max_sge
= min(dev_attr
->max_sge
, RDS_IW_MAX_SGE
);
85 rds_iwdev
->page_shift
= max(PAGE_SHIFT
, ffs(dev_attr
->page_size_cap
) - 1);
87 rds_iwdev
->dev
= device
;
88 rds_iwdev
->pd
= ib_alloc_pd(device
);
89 if (IS_ERR(rds_iwdev
->pd
))
92 if (!rds_iwdev
->dma_local_lkey
) {
93 if (device
->node_type
!= RDMA_NODE_RNIC
) {
94 rds_iwdev
->mr
= ib_get_dma_mr(rds_iwdev
->pd
,
95 IB_ACCESS_LOCAL_WRITE
);
97 rds_iwdev
->mr
= ib_get_dma_mr(rds_iwdev
->pd
,
98 IB_ACCESS_REMOTE_READ
|
99 IB_ACCESS_REMOTE_WRITE
|
100 IB_ACCESS_LOCAL_WRITE
);
102 if (IS_ERR(rds_iwdev
->mr
))
105 rds_iwdev
->mr
= NULL
;
107 rds_iwdev
->mr_pool
= rds_iw_create_mr_pool(rds_iwdev
);
108 if (IS_ERR(rds_iwdev
->mr_pool
)) {
109 rds_iwdev
->mr_pool
= NULL
;
113 INIT_LIST_HEAD(&rds_iwdev
->cm_id_list
);
114 INIT_LIST_HEAD(&rds_iwdev
->conn_list
);
115 list_add_tail(&rds_iwdev
->list
, &rds_iw_devices
);
117 ib_set_client_data(device
, &rds_iw_client
, rds_iwdev
);
123 ib_dereg_mr(rds_iwdev
->mr
);
125 ib_dealloc_pd(rds_iwdev
->pd
);
132 void rds_iw_remove_one(struct ib_device
*device
)
134 struct rds_iw_device
*rds_iwdev
;
135 struct rds_iw_cm_id
*i_cm_id
, *next
;
137 rds_iwdev
= ib_get_client_data(device
, &rds_iw_client
);
141 spin_lock_irq(&rds_iwdev
->spinlock
);
142 list_for_each_entry_safe(i_cm_id
, next
, &rds_iwdev
->cm_id_list
, list
) {
143 list_del(&i_cm_id
->list
);
146 spin_unlock_irq(&rds_iwdev
->spinlock
);
148 rds_iw_remove_conns(rds_iwdev
);
150 if (rds_iwdev
->mr_pool
)
151 rds_iw_destroy_mr_pool(rds_iwdev
->mr_pool
);
154 ib_dereg_mr(rds_iwdev
->mr
);
156 while (ib_dealloc_pd(rds_iwdev
->pd
)) {
157 rdsdebug("Failed to dealloc pd %p\n", rds_iwdev
->pd
);
161 list_del(&rds_iwdev
->list
);
165 struct ib_client rds_iw_client
= {
167 .add
= rds_iw_add_one
,
168 .remove
= rds_iw_remove_one
171 static int rds_iw_conn_info_visitor(struct rds_connection
*conn
,
174 struct rds_info_rdma_connection
*iinfo
= buffer
;
175 struct rds_iw_connection
*ic
;
177 /* We will only ever look at IB transports */
178 if (conn
->c_trans
!= &rds_iw_transport
)
181 iinfo
->src_addr
= conn
->c_laddr
;
182 iinfo
->dst_addr
= conn
->c_faddr
;
184 memset(&iinfo
->src_gid
, 0, sizeof(iinfo
->src_gid
));
185 memset(&iinfo
->dst_gid
, 0, sizeof(iinfo
->dst_gid
));
186 if (rds_conn_state(conn
) == RDS_CONN_UP
) {
187 struct rds_iw_device
*rds_iwdev
;
188 struct rdma_dev_addr
*dev_addr
;
190 ic
= conn
->c_transport_data
;
191 dev_addr
= &ic
->i_cm_id
->route
.addr
.dev_addr
;
193 ib_addr_get_sgid(dev_addr
, (union ib_gid
*) &iinfo
->src_gid
);
194 ib_addr_get_dgid(dev_addr
, (union ib_gid
*) &iinfo
->dst_gid
);
196 rds_iwdev
= ib_get_client_data(ic
->i_cm_id
->device
, &rds_iw_client
);
197 iinfo
->max_send_wr
= ic
->i_send_ring
.w_nr
;
198 iinfo
->max_recv_wr
= ic
->i_recv_ring
.w_nr
;
199 iinfo
->max_send_sge
= rds_iwdev
->max_sge
;
200 rds_iw_get_mr_info(rds_iwdev
, iinfo
);
205 static void rds_iw_ic_info(struct socket
*sock
, unsigned int len
,
206 struct rds_info_iterator
*iter
,
207 struct rds_info_lengths
*lens
)
209 rds_for_each_conn_info(sock
, len
, iter
, lens
,
210 rds_iw_conn_info_visitor
,
211 sizeof(struct rds_info_rdma_connection
));
216 * Early RDS/IB was built to only bind to an address if there is an IPoIB
217 * device with that address set.
219 * If it were me, I'd advocate for something more flexible. Sending and
220 * receiving should be device-agnostic. Transports would try and maintain
221 * connections between peers who have messages queued. Userspace would be
222 * allowed to influence which paths have priority. We could call userspace
223 * asserting this policy "routing".
225 static int rds_iw_laddr_check(__be32 addr
)
228 struct rdma_cm_id
*cm_id
;
229 struct sockaddr_in sin
;
231 /* Create a CMA ID and try to bind it. This catches both
232 * IB and iWARP capable NICs.
234 cm_id
= rdma_create_id(NULL
, NULL
, RDMA_PS_TCP
);
236 return -EADDRNOTAVAIL
;
238 memset(&sin
, 0, sizeof(sin
));
239 sin
.sin_family
= AF_INET
;
240 sin
.sin_addr
.s_addr
= addr
;
242 /* rdma_bind_addr will only succeed for IB & iWARP devices */
243 ret
= rdma_bind_addr(cm_id
, (struct sockaddr
*)&sin
);
244 /* due to this, we will claim to support IB devices unless we
246 if (ret
|| cm_id
->device
->node_type
!= RDMA_NODE_RNIC
)
247 ret
= -EADDRNOTAVAIL
;
249 rdsdebug("addr %pI4 ret %d node type %d\n",
251 cm_id
->device
? cm_id
->device
->node_type
: -1);
253 rdma_destroy_id(cm_id
);
258 void rds_iw_exit(void)
260 rds_info_deregister_func(RDS_INFO_IWARP_CONNECTIONS
, rds_iw_ic_info
);
261 rds_iw_remove_nodev_conns();
262 ib_unregister_client(&rds_iw_client
);
263 rds_iw_sysctl_exit();
265 rds_trans_unregister(&rds_iw_transport
);
268 struct rds_transport rds_iw_transport
= {
269 .laddr_check
= rds_iw_laddr_check
,
270 .xmit_complete
= rds_iw_xmit_complete
,
272 .xmit_cong_map
= NULL
,
273 .xmit_rdma
= rds_iw_xmit_rdma
,
275 .conn_alloc
= rds_iw_conn_alloc
,
276 .conn_free
= rds_iw_conn_free
,
277 .conn_connect
= rds_iw_conn_connect
,
278 .conn_shutdown
= rds_iw_conn_shutdown
,
279 .inc_copy_to_user
= rds_iw_inc_copy_to_user
,
280 .inc_purge
= rds_iw_inc_purge
,
281 .inc_free
= rds_iw_inc_free
,
282 .cm_initiate_connect
= rds_iw_cm_initiate_connect
,
283 .cm_handle_connect
= rds_iw_cm_handle_connect
,
284 .cm_connect_complete
= rds_iw_cm_connect_complete
,
285 .stats_info_copy
= rds_iw_stats_info_copy
,
287 .get_mr
= rds_iw_get_mr
,
288 .sync_mr
= rds_iw_sync_mr
,
289 .free_mr
= rds_iw_free_mr
,
290 .flush_mrs
= rds_iw_flush_mrs
,
291 .t_owner
= THIS_MODULE
,
293 .t_prefer_loopback
= 1,
296 int __init
rds_iw_init(void)
300 INIT_LIST_HEAD(&rds_iw_devices
);
302 ret
= ib_register_client(&rds_iw_client
);
306 ret
= rds_iw_sysctl_init();
310 ret
= rds_iw_recv_init();
314 ret
= rds_trans_register(&rds_iw_transport
);
318 rds_info_register_func(RDS_INFO_IWARP_CONNECTIONS
, rds_iw_ic_info
);
325 rds_iw_sysctl_exit();
327 ib_unregister_client(&rds_iw_client
);
332 MODULE_LICENSE("GPL");