Root/net/rds/ib.c

1/*
2 * Copyright (c) 2006 Oracle. All rights reserved.
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/in.h>
35#include <linux/if.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
42#include "rds.h"
43#include "ib.h"
44
45unsigned int fmr_pool_size = RDS_FMR_POOL_SIZE;
46unsigned int fmr_message_size = RDS_FMR_SIZE + 1; /* +1 allows for unaligned MRs */
47unsigned int rds_ib_retry_count = RDS_IB_DEFAULT_RETRY_COUNT;
48
49module_param(fmr_pool_size, int, 0444);
50MODULE_PARM_DESC(fmr_pool_size, " Max number of fmr per HCA");
51module_param(fmr_message_size, int, 0444);
52MODULE_PARM_DESC(fmr_message_size, " Max size of a RDMA transfer");
53module_param(rds_ib_retry_count, int, 0444);
54MODULE_PARM_DESC(rds_ib_retry_count, " Number of hw retries before reporting an error");
55
56struct list_head rds_ib_devices;
57
58/* NOTE: if also grabbing ibdev lock, grab this first */
59DEFINE_SPINLOCK(ib_nodev_conns_lock);
60LIST_HEAD(ib_nodev_conns);
61
62void rds_ib_add_one(struct ib_device *device)
63{
64    struct rds_ib_device *rds_ibdev;
65    struct ib_device_attr *dev_attr;
66
67    /* Only handle IB (no iWARP) devices */
68    if (device->node_type != RDMA_NODE_IB_CA)
69        return;
70
71    dev_attr = kmalloc(sizeof *dev_attr, GFP_KERNEL);
72    if (!dev_attr)
73        return;
74
75    if (ib_query_device(device, dev_attr)) {
76        rdsdebug("Query device failed for %s\n", device->name);
77        goto free_attr;
78    }
79
80    rds_ibdev = kmalloc(sizeof *rds_ibdev, GFP_KERNEL);
81    if (!rds_ibdev)
82        goto free_attr;
83
84    spin_lock_init(&rds_ibdev->spinlock);
85
86    rds_ibdev->max_wrs = dev_attr->max_qp_wr;
87    rds_ibdev->max_sge = min(dev_attr->max_sge, RDS_IB_MAX_SGE);
88
89    rds_ibdev->fmr_max_remaps = dev_attr->max_map_per_fmr?: 32;
90    rds_ibdev->max_fmrs = dev_attr->max_fmr ?
91            min_t(unsigned int, dev_attr->max_fmr, fmr_pool_size) :
92            fmr_pool_size;
93
94    rds_ibdev->dev = device;
95    rds_ibdev->pd = ib_alloc_pd(device);
96    if (IS_ERR(rds_ibdev->pd))
97        goto free_dev;
98
99    rds_ibdev->mr = ib_get_dma_mr(rds_ibdev->pd,
100                      IB_ACCESS_LOCAL_WRITE);
101    if (IS_ERR(rds_ibdev->mr))
102        goto err_pd;
103
104    rds_ibdev->mr_pool = rds_ib_create_mr_pool(rds_ibdev);
105    if (IS_ERR(rds_ibdev->mr_pool)) {
106        rds_ibdev->mr_pool = NULL;
107        goto err_mr;
108    }
109
110    INIT_LIST_HEAD(&rds_ibdev->ipaddr_list);
111    INIT_LIST_HEAD(&rds_ibdev->conn_list);
112    list_add_tail(&rds_ibdev->list, &rds_ib_devices);
113
114    ib_set_client_data(device, &rds_ib_client, rds_ibdev);
115
116    goto free_attr;
117
118err_mr:
119    ib_dereg_mr(rds_ibdev->mr);
120err_pd:
121    ib_dealloc_pd(rds_ibdev->pd);
122free_dev:
123    kfree(rds_ibdev);
124free_attr:
125    kfree(dev_attr);
126}
127
128void rds_ib_remove_one(struct ib_device *device)
129{
130    struct rds_ib_device *rds_ibdev;
131    struct rds_ib_ipaddr *i_ipaddr, *i_next;
132
133    rds_ibdev = ib_get_client_data(device, &rds_ib_client);
134    if (!rds_ibdev)
135        return;
136
137    list_for_each_entry_safe(i_ipaddr, i_next, &rds_ibdev->ipaddr_list, list) {
138        list_del(&i_ipaddr->list);
139        kfree(i_ipaddr);
140    }
141
142    rds_ib_destroy_conns(rds_ibdev);
143
144    if (rds_ibdev->mr_pool)
145        rds_ib_destroy_mr_pool(rds_ibdev->mr_pool);
146
147    ib_dereg_mr(rds_ibdev->mr);
148
149    while (ib_dealloc_pd(rds_ibdev->pd)) {
150        rdsdebug("Failed to dealloc pd %p\n", rds_ibdev->pd);
151        msleep(1);
152    }
153
154    list_del(&rds_ibdev->list);
155    kfree(rds_ibdev);
156}
157
158struct ib_client rds_ib_client = {
159    .name = "rds_ib",
160    .add = rds_ib_add_one,
161    .remove = rds_ib_remove_one
162};
163
164static int rds_ib_conn_info_visitor(struct rds_connection *conn,
165                    void *buffer)
166{
167    struct rds_info_rdma_connection *iinfo = buffer;
168    struct rds_ib_connection *ic;
169
170    /* We will only ever look at IB transports */
171    if (conn->c_trans != &rds_ib_transport)
172        return 0;
173
174    iinfo->src_addr = conn->c_laddr;
175    iinfo->dst_addr = conn->c_faddr;
176
177    memset(&iinfo->src_gid, 0, sizeof(iinfo->src_gid));
178    memset(&iinfo->dst_gid, 0, sizeof(iinfo->dst_gid));
179    if (rds_conn_state(conn) == RDS_CONN_UP) {
180        struct rds_ib_device *rds_ibdev;
181        struct rdma_dev_addr *dev_addr;
182
183        ic = conn->c_transport_data;
184        dev_addr = &ic->i_cm_id->route.addr.dev_addr;
185
186        rdma_addr_get_sgid(dev_addr, (union ib_gid *) &iinfo->src_gid);
187        rdma_addr_get_dgid(dev_addr, (union ib_gid *) &iinfo->dst_gid);
188
189        rds_ibdev = ib_get_client_data(ic->i_cm_id->device, &rds_ib_client);
190        iinfo->max_send_wr = ic->i_send_ring.w_nr;
191        iinfo->max_recv_wr = ic->i_recv_ring.w_nr;
192        iinfo->max_send_sge = rds_ibdev->max_sge;
193        rds_ib_get_mr_info(rds_ibdev, iinfo);
194    }
195    return 1;
196}
197
198static void rds_ib_ic_info(struct socket *sock, unsigned int len,
199               struct rds_info_iterator *iter,
200               struct rds_info_lengths *lens)
201{
202    rds_for_each_conn_info(sock, len, iter, lens,
203                rds_ib_conn_info_visitor,
204                sizeof(struct rds_info_rdma_connection));
205}
206
207
208/*
209 * Early RDS/IB was built to only bind to an address if there is an IPoIB
210 * device with that address set.
211 *
212 * If it were me, I'd advocate for something more flexible. Sending and
213 * receiving should be device-agnostic. Transports would try and maintain
214 * connections between peers who have messages queued. Userspace would be
215 * allowed to influence which paths have priority. We could call userspace
216 * asserting this policy "routing".
217 */
218static int rds_ib_laddr_check(__be32 addr)
219{
220    int ret;
221    struct rdma_cm_id *cm_id;
222    struct sockaddr_in sin;
223
224    /* Create a CMA ID and try to bind it. This catches both
225     * IB and iWARP capable NICs.
226     */
227    cm_id = rdma_create_id(NULL, NULL, RDMA_PS_TCP);
228    if (IS_ERR(cm_id))
229        return PTR_ERR(cm_id);
230
231    memset(&sin, 0, sizeof(sin));
232    sin.sin_family = AF_INET;
233    sin.sin_addr.s_addr = addr;
234
235    /* rdma_bind_addr will only succeed for IB & iWARP devices */
236    ret = rdma_bind_addr(cm_id, (struct sockaddr *)&sin);
237    /* due to this, we will claim to support iWARP devices unless we
238       check node_type. */
239    if (ret || cm_id->device->node_type != RDMA_NODE_IB_CA)
240        ret = -EADDRNOTAVAIL;
241
242    rdsdebug("addr %pI4 ret %d node type %d\n",
243        &addr, ret,
244        cm_id->device ? cm_id->device->node_type : -1);
245
246    rdma_destroy_id(cm_id);
247
248    return ret;
249}
250
251void rds_ib_exit(void)
252{
253    rds_info_deregister_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info);
254    rds_ib_destroy_nodev_conns();
255    ib_unregister_client(&rds_ib_client);
256    rds_ib_sysctl_exit();
257    rds_ib_recv_exit();
258    rds_trans_unregister(&rds_ib_transport);
259}
260
261struct rds_transport rds_ib_transport = {
262    .laddr_check = rds_ib_laddr_check,
263    .xmit_complete = rds_ib_xmit_complete,
264    .xmit = rds_ib_xmit,
265    .xmit_cong_map = NULL,
266    .xmit_rdma = rds_ib_xmit_rdma,
267    .recv = rds_ib_recv,
268    .conn_alloc = rds_ib_conn_alloc,
269    .conn_free = rds_ib_conn_free,
270    .conn_connect = rds_ib_conn_connect,
271    .conn_shutdown = rds_ib_conn_shutdown,
272    .inc_copy_to_user = rds_ib_inc_copy_to_user,
273    .inc_purge = rds_ib_inc_purge,
274    .inc_free = rds_ib_inc_free,
275    .cm_initiate_connect = rds_ib_cm_initiate_connect,
276    .cm_handle_connect = rds_ib_cm_handle_connect,
277    .cm_connect_complete = rds_ib_cm_connect_complete,
278    .stats_info_copy = rds_ib_stats_info_copy,
279    .exit = rds_ib_exit,
280    .get_mr = rds_ib_get_mr,
281    .sync_mr = rds_ib_sync_mr,
282    .free_mr = rds_ib_free_mr,
283    .flush_mrs = rds_ib_flush_mrs,
284    .t_owner = THIS_MODULE,
285    .t_name = "infiniband",
286    .t_type = RDS_TRANS_IB
287};
288
289int __init rds_ib_init(void)
290{
291    int ret;
292
293    INIT_LIST_HEAD(&rds_ib_devices);
294
295    ret = ib_register_client(&rds_ib_client);
296    if (ret)
297        goto out;
298
299    ret = rds_ib_sysctl_init();
300    if (ret)
301        goto out_ibreg;
302
303    ret = rds_ib_recv_init();
304    if (ret)
305        goto out_sysctl;
306
307    ret = rds_trans_register(&rds_ib_transport);
308    if (ret)
309        goto out_recv;
310
311    rds_info_register_func(RDS_INFO_IB_CONNECTIONS, rds_ib_ic_info);
312
313    goto out;
314
315out_recv:
316    rds_ib_recv_exit();
317out_sysctl:
318    rds_ib_sysctl_exit();
319out_ibreg:
320    ib_unregister_client(&rds_ib_client);
321out:
322    return ret;
323}
324
325MODULE_LICENSE("GPL");
326
327

Archive Download this file



interactive