hw/arm/bcm2836: Only provide "enabled-cpus" property to multicore SoCs
[qemu.git] / hw / rdma / rdma_backend.c
1 /*
2 * QEMU paravirtual RDMA - Generic RDMA backend
3 *
4 * Copyright (C) 2018 Oracle
5 * Copyright (C) 2018 Red Hat Inc
6 *
7 * Authors:
8 * Yuval Shaia <yuval.shaia@oracle.com>
9 * Marcel Apfelbaum <marcel@redhat.com>
10 *
11 * This work is licensed under the terms of the GNU GPL, version 2 or later.
12 * See the COPYING file in the top-level directory.
13 *
14 */
15
16 #include "qemu/osdep.h"
17 #include "qapi/qapi-events-rdma.h"
18
19 #include <infiniband/verbs.h>
20
21 #include "contrib/rdmacm-mux/rdmacm-mux.h"
22 #include "trace.h"
23 #include "rdma_utils.h"
24 #include "rdma_rm.h"
25 #include "rdma_backend.h"
26
27 #define THR_NAME_LEN 16
28 #define THR_POLL_TO 5000
29
30 #define MAD_HDR_SIZE sizeof(struct ibv_grh)
31
32 typedef struct BackendCtx {
33 void *up_ctx;
34 struct ibv_sge sge; /* Used to save MAD recv buffer */
35 RdmaBackendQP *backend_qp; /* To maintain recv buffers */
36 RdmaBackendSRQ *backend_srq;
37 } BackendCtx;
38
39 struct backend_umad {
40 struct ib_user_mad hdr;
41 char mad[RDMA_MAX_PRIVATE_DATA];
42 };
43
44 static void (*comp_handler)(void *ctx, struct ibv_wc *wc);
45
46 static void dummy_comp_handler(void *ctx, struct ibv_wc *wc)
47 {
48 rdma_error_report("No completion handler is registered");
49 }
50
51 static inline void complete_work(enum ibv_wc_status status, uint32_t vendor_err,
52 void *ctx)
53 {
54 struct ibv_wc wc = {};
55
56 wc.status = status;
57 wc.vendor_err = vendor_err;
58
59 comp_handler(ctx, &wc);
60 }
61
62 static void free_cqe_ctx(gpointer data, gpointer user_data)
63 {
64 BackendCtx *bctx;
65 RdmaDeviceResources *rdma_dev_res = user_data;
66 unsigned long cqe_ctx_id = GPOINTER_TO_INT(data);
67
68 bctx = rdma_rm_get_cqe_ctx(rdma_dev_res, cqe_ctx_id);
69 if (bctx) {
70 rdma_rm_dealloc_cqe_ctx(rdma_dev_res, cqe_ctx_id);
71 qatomic_dec(&rdma_dev_res->stats.missing_cqe);
72 }
73 g_free(bctx);
74 }
75
76 static void clean_recv_mads(RdmaBackendDev *backend_dev)
77 {
78 unsigned long cqe_ctx_id;
79
80 do {
81 cqe_ctx_id = rdma_protected_qlist_pop_int64(&backend_dev->
82 recv_mads_list);
83 if (cqe_ctx_id != -ENOENT) {
84 qatomic_inc(&backend_dev->rdma_dev_res->stats.missing_cqe);
85 free_cqe_ctx(GINT_TO_POINTER(cqe_ctx_id),
86 backend_dev->rdma_dev_res);
87 }
88 } while (cqe_ctx_id != -ENOENT);
89 }
90
91 static int rdma_poll_cq(RdmaDeviceResources *rdma_dev_res, struct ibv_cq *ibcq)
92 {
93 int i, ne, total_ne = 0;
94 BackendCtx *bctx;
95 struct ibv_wc wc[2];
96 RdmaProtectedGSList *cqe_ctx_list;
97
98 WITH_QEMU_LOCK_GUARD(&rdma_dev_res->lock) {
99 do {
100 ne = ibv_poll_cq(ibcq, ARRAY_SIZE(wc), wc);
101
102 trace_rdma_poll_cq(ne, ibcq);
103
104 for (i = 0; i < ne; i++) {
105 bctx = rdma_rm_get_cqe_ctx(rdma_dev_res, wc[i].wr_id);
106 if (unlikely(!bctx)) {
107 rdma_error_report("No matching ctx for req %"PRId64,
108 wc[i].wr_id);
109 continue;
110 }
111
112 comp_handler(bctx->up_ctx, &wc[i]);
113
114 if (bctx->backend_qp) {
115 cqe_ctx_list = &bctx->backend_qp->cqe_ctx_list;
116 } else {
117 cqe_ctx_list = &bctx->backend_srq->cqe_ctx_list;
118 }
119
120 rdma_protected_gslist_remove_int32(cqe_ctx_list, wc[i].wr_id);
121 rdma_rm_dealloc_cqe_ctx(rdma_dev_res, wc[i].wr_id);
122 g_free(bctx);
123 }
124 total_ne += ne;
125 } while (ne > 0);
126 qatomic_sub(&rdma_dev_res->stats.missing_cqe, total_ne);
127 }
128
129 if (ne < 0) {
130 rdma_error_report("ibv_poll_cq fail, rc=%d, errno=%d", ne, errno);
131 }
132
133 rdma_dev_res->stats.completions += total_ne;
134
135 return total_ne;
136 }
137
138 static void *comp_handler_thread(void *arg)
139 {
140 RdmaBackendDev *backend_dev = (RdmaBackendDev *)arg;
141 int rc;
142 struct ibv_cq *ev_cq;
143 void *ev_ctx;
144 int flags;
145 GPollFD pfds[1];
146
147 /* Change to non-blocking mode */
148 flags = fcntl(backend_dev->channel->fd, F_GETFL);
149 rc = fcntl(backend_dev->channel->fd, F_SETFL, flags | O_NONBLOCK);
150 if (rc < 0) {
151 rdma_error_report("Failed to change backend channel FD to non-blocking");
152 return NULL;
153 }
154
155 pfds[0].fd = backend_dev->channel->fd;
156 pfds[0].events = G_IO_IN | G_IO_HUP | G_IO_ERR;
157
158 backend_dev->comp_thread.is_running = true;
159
160 while (backend_dev->comp_thread.run) {
161 do {
162 rc = qemu_poll_ns(pfds, 1, THR_POLL_TO * (int64_t)SCALE_MS);
163 if (!rc) {
164 backend_dev->rdma_dev_res->stats.poll_cq_ppoll_to++;
165 }
166 } while (!rc && backend_dev->comp_thread.run);
167
168 if (backend_dev->comp_thread.run) {
169 rc = ibv_get_cq_event(backend_dev->channel, &ev_cq, &ev_ctx);
170 if (unlikely(rc)) {
171 rdma_error_report("ibv_get_cq_event fail, rc=%d, errno=%d", rc,
172 errno);
173 continue;
174 }
175
176 rc = ibv_req_notify_cq(ev_cq, 0);
177 if (unlikely(rc)) {
178 rdma_error_report("ibv_req_notify_cq fail, rc=%d, errno=%d", rc,
179 errno);
180 }
181
182 backend_dev->rdma_dev_res->stats.poll_cq_from_bk++;
183 rdma_poll_cq(backend_dev->rdma_dev_res, ev_cq);
184
185 ibv_ack_cq_events(ev_cq, 1);
186 }
187 }
188
189 backend_dev->comp_thread.is_running = false;
190
191 qemu_thread_exit(0);
192
193 return NULL;
194 }
195
196 static inline void disable_rdmacm_mux_async(RdmaBackendDev *backend_dev)
197 {
198 qatomic_set(&backend_dev->rdmacm_mux.can_receive, 0);
199 }
200
201 static inline void enable_rdmacm_mux_async(RdmaBackendDev *backend_dev)
202 {
203 qatomic_set(&backend_dev->rdmacm_mux.can_receive, sizeof(RdmaCmMuxMsg));
204 }
205
206 static inline int rdmacm_mux_can_process_async(RdmaBackendDev *backend_dev)
207 {
208 return qatomic_read(&backend_dev->rdmacm_mux.can_receive);
209 }
210
211 static int rdmacm_mux_check_op_status(CharBackend *mad_chr_be)
212 {
213 RdmaCmMuxMsg msg = {};
214 int ret;
215
216 ret = qemu_chr_fe_read_all(mad_chr_be, (uint8_t *)&msg, sizeof(msg));
217 if (ret != sizeof(msg)) {
218 rdma_error_report("Got invalid message from mux: size %d, expecting %d",
219 ret, (int)sizeof(msg));
220 return -EIO;
221 }
222
223 trace_rdmacm_mux_check_op_status(msg.hdr.msg_type, msg.hdr.op_code,
224 msg.hdr.err_code);
225
226 if (msg.hdr.msg_type != RDMACM_MUX_MSG_TYPE_RESP) {
227 rdma_error_report("Got invalid message type %d", msg.hdr.msg_type);
228 return -EIO;
229 }
230
231 if (msg.hdr.err_code != RDMACM_MUX_ERR_CODE_OK) {
232 rdma_error_report("Operation failed in mux, error code %d",
233 msg.hdr.err_code);
234 return -EIO;
235 }
236
237 return 0;
238 }
239
240 static int rdmacm_mux_send(RdmaBackendDev *backend_dev, RdmaCmMuxMsg *msg)
241 {
242 int rc = 0;
243
244 msg->hdr.msg_type = RDMACM_MUX_MSG_TYPE_REQ;
245 trace_rdmacm_mux("send", msg->hdr.msg_type, msg->hdr.op_code);
246 disable_rdmacm_mux_async(backend_dev);
247 rc = qemu_chr_fe_write(backend_dev->rdmacm_mux.chr_be,
248 (const uint8_t *)msg, sizeof(*msg));
249 if (rc != sizeof(*msg)) {
250 enable_rdmacm_mux_async(backend_dev);
251 rdma_error_report("Failed to send request to rdmacm_mux (rc=%d)", rc);
252 return -EIO;
253 }
254
255 rc = rdmacm_mux_check_op_status(backend_dev->rdmacm_mux.chr_be);
256 if (rc) {
257 rdma_error_report("Failed to execute rdmacm_mux request %d (rc=%d)",
258 msg->hdr.op_code, rc);
259 }
260
261 enable_rdmacm_mux_async(backend_dev);
262
263 return 0;
264 }
265
266 static void stop_backend_thread(RdmaBackendThread *thread)
267 {
268 thread->run = false;
269 while (thread->is_running) {
270 sleep(THR_POLL_TO / SCALE_US / 2);
271 }
272 }
273
274 static void start_comp_thread(RdmaBackendDev *backend_dev)
275 {
276 char thread_name[THR_NAME_LEN] = {};
277
278 stop_backend_thread(&backend_dev->comp_thread);
279
280 snprintf(thread_name, sizeof(thread_name), "rdma_comp_%s",
281 ibv_get_device_name(backend_dev->ib_dev));
282 backend_dev->comp_thread.run = true;
283 qemu_thread_create(&backend_dev->comp_thread.thread, thread_name,
284 comp_handler_thread, backend_dev, QEMU_THREAD_DETACHED);
285 }
286
287 void rdma_backend_register_comp_handler(void (*handler)(void *ctx,
288 struct ibv_wc *wc))
289 {
290 comp_handler = handler;
291 }
292
293 void rdma_backend_unregister_comp_handler(void)
294 {
295 rdma_backend_register_comp_handler(dummy_comp_handler);
296 }
297
298 int rdma_backend_query_port(RdmaBackendDev *backend_dev,
299 struct ibv_port_attr *port_attr)
300 {
301 int rc;
302
303 rc = ibv_query_port(backend_dev->context, backend_dev->port_num, port_attr);
304 if (rc) {
305 rdma_error_report("ibv_query_port fail, rc=%d, errno=%d", rc, errno);
306 return -EIO;
307 }
308
309 return 0;
310 }
311
312 void rdma_backend_poll_cq(RdmaDeviceResources *rdma_dev_res, RdmaBackendCQ *cq)
313 {
314 int polled;
315
316 rdma_dev_res->stats.poll_cq_from_guest++;
317 polled = rdma_poll_cq(rdma_dev_res, cq->ibcq);
318 if (!polled) {
319 rdma_dev_res->stats.poll_cq_from_guest_empty++;
320 }
321 }
322
323 static GHashTable *ah_hash;
324
325 static struct ibv_ah *create_ah(RdmaBackendDev *backend_dev, struct ibv_pd *pd,
326 uint8_t sgid_idx, union ibv_gid *dgid)
327 {
328 GBytes *ah_key = g_bytes_new(dgid, sizeof(*dgid));
329 struct ibv_ah *ah = g_hash_table_lookup(ah_hash, ah_key);
330
331 if (ah) {
332 trace_rdma_create_ah_cache_hit(be64_to_cpu(dgid->global.subnet_prefix),
333 be64_to_cpu(dgid->global.interface_id));
334 g_bytes_unref(ah_key);
335 } else {
336 struct ibv_ah_attr ah_attr = {
337 .is_global = 1,
338 .port_num = backend_dev->port_num,
339 .grh.hop_limit = 1,
340 };
341
342 ah_attr.grh.dgid = *dgid;
343 ah_attr.grh.sgid_index = sgid_idx;
344
345 ah = ibv_create_ah(pd, &ah_attr);
346 if (ah) {
347 g_hash_table_insert(ah_hash, ah_key, ah);
348 } else {
349 g_bytes_unref(ah_key);
350 rdma_error_report("Failed to create AH for gid <0x%" PRIx64", 0x%"PRIx64">",
351 be64_to_cpu(dgid->global.subnet_prefix),
352 be64_to_cpu(dgid->global.interface_id));
353 }
354
355 trace_rdma_create_ah_cache_miss(be64_to_cpu(dgid->global.subnet_prefix),
356 be64_to_cpu(dgid->global.interface_id));
357 }
358
359 return ah;
360 }
361
362 static void destroy_ah_hash_key(gpointer data)
363 {
364 g_bytes_unref(data);
365 }
366
367 static void destroy_ah_hast_data(gpointer data)
368 {
369 struct ibv_ah *ah = data;
370
371 ibv_destroy_ah(ah);
372 }
373
374 static void ah_cache_init(void)
375 {
376 ah_hash = g_hash_table_new_full(g_bytes_hash, g_bytes_equal,
377 destroy_ah_hash_key, destroy_ah_hast_data);
378 }
379
380 #ifdef LEGACY_RDMA_REG_MR
381 static int build_host_sge_array(RdmaDeviceResources *rdma_dev_res,
382 struct ibv_sge *sge, uint8_t num_sge,
383 uint64_t *total_length)
384 {
385 RdmaRmMR *mr;
386 int idx;
387
388 for (idx = 0; idx < num_sge; idx++) {
389 mr = rdma_rm_get_mr(rdma_dev_res, sge[idx].lkey);
390 if (unlikely(!mr)) {
391 rdma_error_report("Invalid lkey 0x%x", sge[idx].lkey);
392 return VENDOR_ERR_INVLKEY | sge[idx].lkey;
393 }
394
395 sge[idx].addr = (uintptr_t)mr->virt + sge[idx].addr - mr->start;
396 sge[idx].lkey = rdma_backend_mr_lkey(&mr->backend_mr);
397
398 *total_length += sge[idx].length;
399 }
400
401 return 0;
402 }
403 #else
404 static inline int build_host_sge_array(RdmaDeviceResources *rdma_dev_res,
405 struct ibv_sge *sge, uint8_t num_sge,
406 uint64_t *total_length)
407 {
408 int idx;
409
410 for (idx = 0; idx < num_sge; idx++) {
411 *total_length += sge[idx].length;
412 }
413 return 0;
414 }
415 #endif
416
417 static void trace_mad_message(const char *title, char *buf, int len)
418 {
419 int i;
420 char *b = g_malloc0(len * 3 + 1);
421 char b1[4];
422
423 for (i = 0; i < len; i++) {
424 sprintf(b1, "%.2X ", buf[i] & 0x000000FF);
425 strcat(b, b1);
426 }
427
428 trace_rdma_mad_message(title, len, b);
429
430 g_free(b);
431 }
432
433 static int mad_send(RdmaBackendDev *backend_dev, uint8_t sgid_idx,
434 union ibv_gid *sgid, struct ibv_sge *sge, uint32_t num_sge)
435 {
436 RdmaCmMuxMsg msg = {};
437 char *hdr, *data;
438 int ret;
439
440 if (num_sge != 2) {
441 return -EINVAL;
442 }
443
444 msg.hdr.op_code = RDMACM_MUX_OP_CODE_MAD;
445 memcpy(msg.hdr.sgid.raw, sgid->raw, sizeof(msg.hdr.sgid));
446
447 msg.umad_len = sge[0].length + sge[1].length;
448
449 if (msg.umad_len > sizeof(msg.umad.mad)) {
450 return -ENOMEM;
451 }
452
453 msg.umad.hdr.addr.qpn = htobe32(1);
454 msg.umad.hdr.addr.grh_present = 1;
455 msg.umad.hdr.addr.gid_index = sgid_idx;
456 memcpy(msg.umad.hdr.addr.gid, sgid->raw, sizeof(msg.umad.hdr.addr.gid));
457 msg.umad.hdr.addr.hop_limit = 0xFF;
458
459 hdr = rdma_pci_dma_map(backend_dev->dev, sge[0].addr, sge[0].length);
460 if (!hdr) {
461 return -ENOMEM;
462 }
463 data = rdma_pci_dma_map(backend_dev->dev, sge[1].addr, sge[1].length);
464 if (!data) {
465 rdma_pci_dma_unmap(backend_dev->dev, hdr, sge[0].length);
466 return -ENOMEM;
467 }
468
469 memcpy(&msg.umad.mad[0], hdr, sge[0].length);
470 memcpy(&msg.umad.mad[sge[0].length], data, sge[1].length);
471
472 rdma_pci_dma_unmap(backend_dev->dev, data, sge[1].length);
473 rdma_pci_dma_unmap(backend_dev->dev, hdr, sge[0].length);
474
475 trace_mad_message("send", msg.umad.mad, msg.umad_len);
476
477 ret = rdmacm_mux_send(backend_dev, &msg);
478 if (ret) {
479 rdma_error_report("Failed to send MAD to rdma_umadmux (%d)", ret);
480 return -EIO;
481 }
482
483 return 0;
484 }
485
486 void rdma_backend_post_send(RdmaBackendDev *backend_dev,
487 RdmaBackendQP *qp, uint8_t qp_type,
488 struct ibv_sge *sge, uint32_t num_sge,
489 uint8_t sgid_idx, union ibv_gid *sgid,
490 union ibv_gid *dgid, uint32_t dqpn, uint32_t dqkey,
491 void *ctx)
492 {
493 BackendCtx *bctx;
494 uint32_t bctx_id;
495 int rc;
496 struct ibv_send_wr wr = {}, *bad_wr;
497
498 if (!qp->ibqp) { /* This field is not initialized for QP0 and QP1 */
499 if (qp_type == IBV_QPT_SMI) {
500 rdma_error_report("Got QP0 request");
501 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_QP0, ctx);
502 } else if (qp_type == IBV_QPT_GSI) {
503 rc = mad_send(backend_dev, sgid_idx, sgid, sge, num_sge);
504 if (rc) {
505 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_MAD_SEND, ctx);
506 backend_dev->rdma_dev_res->stats.mad_tx_err++;
507 } else {
508 complete_work(IBV_WC_SUCCESS, 0, ctx);
509 backend_dev->rdma_dev_res->stats.mad_tx++;
510 }
511 }
512 return;
513 }
514
515 bctx = g_malloc0(sizeof(*bctx));
516 bctx->up_ctx = ctx;
517 bctx->backend_qp = qp;
518
519 rc = rdma_rm_alloc_cqe_ctx(backend_dev->rdma_dev_res, &bctx_id, bctx);
520 if (unlikely(rc)) {
521 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_NOMEM, ctx);
522 goto err_free_bctx;
523 }
524
525 rdma_protected_gslist_append_int32(&qp->cqe_ctx_list, bctx_id);
526
527 rc = build_host_sge_array(backend_dev->rdma_dev_res, sge, num_sge,
528 &backend_dev->rdma_dev_res->stats.tx_len);
529 if (rc) {
530 complete_work(IBV_WC_GENERAL_ERR, rc, ctx);
531 goto err_dealloc_cqe_ctx;
532 }
533
534 if (qp_type == IBV_QPT_UD) {
535 wr.wr.ud.ah = create_ah(backend_dev, qp->ibpd, sgid_idx, dgid);
536 if (!wr.wr.ud.ah) {
537 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_FAIL_BACKEND, ctx);
538 goto err_dealloc_cqe_ctx;
539 }
540 wr.wr.ud.remote_qpn = dqpn;
541 wr.wr.ud.remote_qkey = dqkey;
542 }
543
544 wr.num_sge = num_sge;
545 wr.opcode = IBV_WR_SEND;
546 wr.send_flags = IBV_SEND_SIGNALED;
547 wr.sg_list = sge;
548 wr.wr_id = bctx_id;
549
550 rc = ibv_post_send(qp->ibqp, &wr, &bad_wr);
551 if (rc) {
552 rdma_error_report("ibv_post_send fail, qpn=0x%x, rc=%d, errno=%d",
553 qp->ibqp->qp_num, rc, errno);
554 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_FAIL_BACKEND, ctx);
555 goto err_dealloc_cqe_ctx;
556 }
557
558 qatomic_inc(&backend_dev->rdma_dev_res->stats.missing_cqe);
559 backend_dev->rdma_dev_res->stats.tx++;
560
561 return;
562
563 err_dealloc_cqe_ctx:
564 backend_dev->rdma_dev_res->stats.tx_err++;
565 rdma_rm_dealloc_cqe_ctx(backend_dev->rdma_dev_res, bctx_id);
566
567 err_free_bctx:
568 g_free(bctx);
569 }
570
571 static unsigned int save_mad_recv_buffer(RdmaBackendDev *backend_dev,
572 struct ibv_sge *sge, uint32_t num_sge,
573 void *ctx)
574 {
575 BackendCtx *bctx;
576 int rc;
577 uint32_t bctx_id;
578
579 if (num_sge != 1) {
580 rdma_error_report("Invalid num_sge (%d), expecting 1", num_sge);
581 return VENDOR_ERR_INV_NUM_SGE;
582 }
583
584 if (sge[0].length < RDMA_MAX_PRIVATE_DATA + sizeof(struct ibv_grh)) {
585 rdma_error_report("Too small buffer for MAD");
586 return VENDOR_ERR_INV_MAD_BUFF;
587 }
588
589 bctx = g_malloc0(sizeof(*bctx));
590
591 rc = rdma_rm_alloc_cqe_ctx(backend_dev->rdma_dev_res, &bctx_id, bctx);
592 if (unlikely(rc)) {
593 g_free(bctx);
594 return VENDOR_ERR_NOMEM;
595 }
596
597 bctx->up_ctx = ctx;
598 bctx->sge = *sge;
599
600 rdma_protected_qlist_append_int64(&backend_dev->recv_mads_list, bctx_id);
601
602 return 0;
603 }
604
605 void rdma_backend_post_recv(RdmaBackendDev *backend_dev,
606 RdmaBackendQP *qp, uint8_t qp_type,
607 struct ibv_sge *sge, uint32_t num_sge, void *ctx)
608 {
609 BackendCtx *bctx;
610 uint32_t bctx_id;
611 int rc;
612 struct ibv_recv_wr wr = {}, *bad_wr;
613
614 if (!qp->ibqp) { /* This field does not get initialized for QP0 and QP1 */
615 if (qp_type == IBV_QPT_SMI) {
616 rdma_error_report("Got QP0 request");
617 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_QP0, ctx);
618 }
619 if (qp_type == IBV_QPT_GSI) {
620 rc = save_mad_recv_buffer(backend_dev, sge, num_sge, ctx);
621 if (rc) {
622 complete_work(IBV_WC_GENERAL_ERR, rc, ctx);
623 backend_dev->rdma_dev_res->stats.mad_rx_bufs_err++;
624 } else {
625 backend_dev->rdma_dev_res->stats.mad_rx_bufs++;
626 }
627 }
628 return;
629 }
630
631 bctx = g_malloc0(sizeof(*bctx));
632 bctx->up_ctx = ctx;
633 bctx->backend_qp = qp;
634
635 rc = rdma_rm_alloc_cqe_ctx(backend_dev->rdma_dev_res, &bctx_id, bctx);
636 if (unlikely(rc)) {
637 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_NOMEM, ctx);
638 goto err_free_bctx;
639 }
640
641 rdma_protected_gslist_append_int32(&qp->cqe_ctx_list, bctx_id);
642
643 rc = build_host_sge_array(backend_dev->rdma_dev_res, sge, num_sge,
644 &backend_dev->rdma_dev_res->stats.rx_bufs_len);
645 if (rc) {
646 complete_work(IBV_WC_GENERAL_ERR, rc, ctx);
647 goto err_dealloc_cqe_ctx;
648 }
649
650 wr.num_sge = num_sge;
651 wr.sg_list = sge;
652 wr.wr_id = bctx_id;
653 rc = ibv_post_recv(qp->ibqp, &wr, &bad_wr);
654 if (rc) {
655 rdma_error_report("ibv_post_recv fail, qpn=0x%x, rc=%d, errno=%d",
656 qp->ibqp->qp_num, rc, errno);
657 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_FAIL_BACKEND, ctx);
658 goto err_dealloc_cqe_ctx;
659 }
660
661 qatomic_inc(&backend_dev->rdma_dev_res->stats.missing_cqe);
662 backend_dev->rdma_dev_res->stats.rx_bufs++;
663
664 return;
665
666 err_dealloc_cqe_ctx:
667 backend_dev->rdma_dev_res->stats.rx_bufs_err++;
668 rdma_rm_dealloc_cqe_ctx(backend_dev->rdma_dev_res, bctx_id);
669
670 err_free_bctx:
671 g_free(bctx);
672 }
673
674 void rdma_backend_post_srq_recv(RdmaBackendDev *backend_dev,
675 RdmaBackendSRQ *srq, struct ibv_sge *sge,
676 uint32_t num_sge, void *ctx)
677 {
678 BackendCtx *bctx;
679 uint32_t bctx_id;
680 int rc;
681 struct ibv_recv_wr wr = {}, *bad_wr;
682
683 bctx = g_malloc0(sizeof(*bctx));
684 bctx->up_ctx = ctx;
685 bctx->backend_srq = srq;
686
687 rc = rdma_rm_alloc_cqe_ctx(backend_dev->rdma_dev_res, &bctx_id, bctx);
688 if (unlikely(rc)) {
689 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_NOMEM, ctx);
690 goto err_free_bctx;
691 }
692
693 rdma_protected_gslist_append_int32(&srq->cqe_ctx_list, bctx_id);
694
695 rc = build_host_sge_array(backend_dev->rdma_dev_res, sge, num_sge,
696 &backend_dev->rdma_dev_res->stats.rx_bufs_len);
697 if (rc) {
698 complete_work(IBV_WC_GENERAL_ERR, rc, ctx);
699 goto err_dealloc_cqe_ctx;
700 }
701
702 wr.num_sge = num_sge;
703 wr.sg_list = sge;
704 wr.wr_id = bctx_id;
705 rc = ibv_post_srq_recv(srq->ibsrq, &wr, &bad_wr);
706 if (rc) {
707 rdma_error_report("ibv_post_srq_recv fail, srqn=0x%x, rc=%d, errno=%d",
708 srq->ibsrq->handle, rc, errno);
709 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_FAIL_BACKEND, ctx);
710 goto err_dealloc_cqe_ctx;
711 }
712
713 qatomic_inc(&backend_dev->rdma_dev_res->stats.missing_cqe);
714 backend_dev->rdma_dev_res->stats.rx_bufs++;
715 backend_dev->rdma_dev_res->stats.rx_srq++;
716
717 return;
718
719 err_dealloc_cqe_ctx:
720 backend_dev->rdma_dev_res->stats.rx_bufs_err++;
721 rdma_rm_dealloc_cqe_ctx(backend_dev->rdma_dev_res, bctx_id);
722
723 err_free_bctx:
724 g_free(bctx);
725 }
726
727 int rdma_backend_create_pd(RdmaBackendDev *backend_dev, RdmaBackendPD *pd)
728 {
729 pd->ibpd = ibv_alloc_pd(backend_dev->context);
730
731 if (!pd->ibpd) {
732 rdma_error_report("ibv_alloc_pd fail, errno=%d", errno);
733 return -EIO;
734 }
735
736 return 0;
737 }
738
739 void rdma_backend_destroy_pd(RdmaBackendPD *pd)
740 {
741 if (pd->ibpd) {
742 ibv_dealloc_pd(pd->ibpd);
743 }
744 }
745
746 int rdma_backend_create_mr(RdmaBackendMR *mr, RdmaBackendPD *pd, void *addr,
747 size_t length, uint64_t guest_start, int access)
748 {
749 #ifdef LEGACY_RDMA_REG_MR
750 mr->ibmr = ibv_reg_mr(pd->ibpd, addr, length, access);
751 #else
752 mr->ibmr = ibv_reg_mr_iova(pd->ibpd, addr, length, guest_start, access);
753 #endif
754 if (!mr->ibmr) {
755 rdma_error_report("ibv_reg_mr fail, errno=%d", errno);
756 return -EIO;
757 }
758
759 mr->ibpd = pd->ibpd;
760
761 return 0;
762 }
763
764 void rdma_backend_destroy_mr(RdmaBackendMR *mr)
765 {
766 if (mr->ibmr) {
767 ibv_dereg_mr(mr->ibmr);
768 }
769 }
770
771 int rdma_backend_create_cq(RdmaBackendDev *backend_dev, RdmaBackendCQ *cq,
772 int cqe)
773 {
774 int rc;
775
776 cq->ibcq = ibv_create_cq(backend_dev->context, cqe + 1, NULL,
777 backend_dev->channel, 0);
778 if (!cq->ibcq) {
779 rdma_error_report("ibv_create_cq fail, errno=%d", errno);
780 return -EIO;
781 }
782
783 rc = ibv_req_notify_cq(cq->ibcq, 0);
784 if (rc) {
785 rdma_warn_report("ibv_req_notify_cq fail, rc=%d, errno=%d", rc, errno);
786 }
787
788 cq->backend_dev = backend_dev;
789
790 return 0;
791 }
792
793 void rdma_backend_destroy_cq(RdmaBackendCQ *cq)
794 {
795 if (cq->ibcq) {
796 ibv_destroy_cq(cq->ibcq);
797 }
798 }
799
800 int rdma_backend_create_qp(RdmaBackendQP *qp, uint8_t qp_type,
801 RdmaBackendPD *pd, RdmaBackendCQ *scq,
802 RdmaBackendCQ *rcq, RdmaBackendSRQ *srq,
803 uint32_t max_send_wr, uint32_t max_recv_wr,
804 uint32_t max_send_sge, uint32_t max_recv_sge)
805 {
806 struct ibv_qp_init_attr attr = {};
807
808 qp->ibqp = 0;
809
810 switch (qp_type) {
811 case IBV_QPT_GSI:
812 return 0;
813
814 case IBV_QPT_RC:
815 /* fall through */
816 case IBV_QPT_UD:
817 /* do nothing */
818 break;
819
820 default:
821 rdma_error_report("Unsupported QP type %d", qp_type);
822 return -EIO;
823 }
824
825 attr.qp_type = qp_type;
826 attr.send_cq = scq->ibcq;
827 attr.recv_cq = rcq->ibcq;
828 attr.cap.max_send_wr = max_send_wr;
829 attr.cap.max_recv_wr = max_recv_wr;
830 attr.cap.max_send_sge = max_send_sge;
831 attr.cap.max_recv_sge = max_recv_sge;
832 if (srq) {
833 attr.srq = srq->ibsrq;
834 }
835
836 qp->ibqp = ibv_create_qp(pd->ibpd, &attr);
837 if (!qp->ibqp) {
838 rdma_error_report("ibv_create_qp fail, errno=%d", errno);
839 return -EIO;
840 }
841
842 rdma_protected_gslist_init(&qp->cqe_ctx_list);
843
844 qp->ibpd = pd->ibpd;
845
846 /* TODO: Query QP to get max_inline_data and save it to be used in send */
847
848 return 0;
849 }
850
851 int rdma_backend_qp_state_init(RdmaBackendDev *backend_dev, RdmaBackendQP *qp,
852 uint8_t qp_type, uint32_t qkey)
853 {
854 struct ibv_qp_attr attr = {};
855 int rc, attr_mask;
856
857 attr_mask = IBV_QP_STATE | IBV_QP_PKEY_INDEX | IBV_QP_PORT;
858 attr.qp_state = IBV_QPS_INIT;
859 attr.pkey_index = 0;
860 attr.port_num = backend_dev->port_num;
861
862 switch (qp_type) {
863 case IBV_QPT_RC:
864 attr_mask |= IBV_QP_ACCESS_FLAGS;
865 trace_rdma_backend_rc_qp_state_init(qp->ibqp->qp_num);
866 break;
867
868 case IBV_QPT_UD:
869 attr.qkey = qkey;
870 attr_mask |= IBV_QP_QKEY;
871 trace_rdma_backend_ud_qp_state_init(qp->ibqp->qp_num, qkey);
872 break;
873
874 default:
875 rdma_error_report("Unsupported QP type %d", qp_type);
876 return -EIO;
877 }
878
879 rc = ibv_modify_qp(qp->ibqp, &attr, attr_mask);
880 if (rc) {
881 rdma_error_report("ibv_modify_qp fail, rc=%d, errno=%d", rc, errno);
882 return -EIO;
883 }
884
885 return 0;
886 }
887
888 int rdma_backend_qp_state_rtr(RdmaBackendDev *backend_dev, RdmaBackendQP *qp,
889 uint8_t qp_type, uint8_t sgid_idx,
890 union ibv_gid *dgid, uint32_t dqpn,
891 uint32_t rq_psn, uint32_t qkey, bool use_qkey)
892 {
893 struct ibv_qp_attr attr = {};
894 union ibv_gid ibv_gid = {
895 .global.interface_id = dgid->global.interface_id,
896 .global.subnet_prefix = dgid->global.subnet_prefix
897 };
898 int rc, attr_mask;
899
900 attr.qp_state = IBV_QPS_RTR;
901 attr_mask = IBV_QP_STATE;
902
903 qp->sgid_idx = sgid_idx;
904
905 switch (qp_type) {
906 case IBV_QPT_RC:
907 attr.path_mtu = IBV_MTU_1024;
908 attr.dest_qp_num = dqpn;
909 attr.max_dest_rd_atomic = 1;
910 attr.min_rnr_timer = 12;
911 attr.ah_attr.port_num = backend_dev->port_num;
912 attr.ah_attr.is_global = 1;
913 attr.ah_attr.grh.hop_limit = 1;
914 attr.ah_attr.grh.dgid = ibv_gid;
915 attr.ah_attr.grh.sgid_index = qp->sgid_idx;
916 attr.rq_psn = rq_psn;
917
918 attr_mask |= IBV_QP_AV | IBV_QP_PATH_MTU | IBV_QP_DEST_QPN |
919 IBV_QP_RQ_PSN | IBV_QP_MAX_DEST_RD_ATOMIC |
920 IBV_QP_MIN_RNR_TIMER;
921
922 trace_rdma_backend_rc_qp_state_rtr(qp->ibqp->qp_num,
923 be64_to_cpu(ibv_gid.global.
924 subnet_prefix),
925 be64_to_cpu(ibv_gid.global.
926 interface_id),
927 qp->sgid_idx, dqpn, rq_psn);
928 break;
929
930 case IBV_QPT_UD:
931 if (use_qkey) {
932 attr.qkey = qkey;
933 attr_mask |= IBV_QP_QKEY;
934 }
935 trace_rdma_backend_ud_qp_state_rtr(qp->ibqp->qp_num, use_qkey ? qkey :
936 0);
937 break;
938 }
939
940 rc = ibv_modify_qp(qp->ibqp, &attr, attr_mask);
941 if (rc) {
942 rdma_error_report("ibv_modify_qp fail, rc=%d, errno=%d", rc, errno);
943 return -EIO;
944 }
945
946 return 0;
947 }
948
949 int rdma_backend_qp_state_rts(RdmaBackendQP *qp, uint8_t qp_type,
950 uint32_t sq_psn, uint32_t qkey, bool use_qkey)
951 {
952 struct ibv_qp_attr attr = {};
953 int rc, attr_mask;
954
955 attr.qp_state = IBV_QPS_RTS;
956 attr.sq_psn = sq_psn;
957 attr_mask = IBV_QP_STATE | IBV_QP_SQ_PSN;
958
959 switch (qp_type) {
960 case IBV_QPT_RC:
961 attr.timeout = 14;
962 attr.retry_cnt = 7;
963 attr.rnr_retry = 7;
964 attr.max_rd_atomic = 1;
965
966 attr_mask |= IBV_QP_TIMEOUT | IBV_QP_RETRY_CNT | IBV_QP_RNR_RETRY |
967 IBV_QP_MAX_QP_RD_ATOMIC;
968 trace_rdma_backend_rc_qp_state_rts(qp->ibqp->qp_num, sq_psn);
969 break;
970
971 case IBV_QPT_UD:
972 if (use_qkey) {
973 attr.qkey = qkey;
974 attr_mask |= IBV_QP_QKEY;
975 }
976 trace_rdma_backend_ud_qp_state_rts(qp->ibqp->qp_num, sq_psn,
977 use_qkey ? qkey : 0);
978 break;
979 }
980
981 rc = ibv_modify_qp(qp->ibqp, &attr, attr_mask);
982 if (rc) {
983 rdma_error_report("ibv_modify_qp fail, rc=%d, errno=%d", rc, errno);
984 return -EIO;
985 }
986
987 return 0;
988 }
989
990 int rdma_backend_query_qp(RdmaBackendQP *qp, struct ibv_qp_attr *attr,
991 int attr_mask, struct ibv_qp_init_attr *init_attr)
992 {
993 if (!qp->ibqp) {
994 attr->qp_state = IBV_QPS_RTS;
995 return 0;
996 }
997
998 return ibv_query_qp(qp->ibqp, attr, attr_mask, init_attr);
999 }
1000
1001 void rdma_backend_destroy_qp(RdmaBackendQP *qp, RdmaDeviceResources *dev_res)
1002 {
1003 if (qp->ibqp) {
1004 ibv_destroy_qp(qp->ibqp);
1005 }
1006 g_slist_foreach(qp->cqe_ctx_list.list, free_cqe_ctx, dev_res);
1007 rdma_protected_gslist_destroy(&qp->cqe_ctx_list);
1008 }
1009
1010 int rdma_backend_create_srq(RdmaBackendSRQ *srq, RdmaBackendPD *pd,
1011 uint32_t max_wr, uint32_t max_sge,
1012 uint32_t srq_limit)
1013 {
1014 struct ibv_srq_init_attr srq_init_attr = {};
1015
1016 srq_init_attr.attr.max_wr = max_wr;
1017 srq_init_attr.attr.max_sge = max_sge;
1018 srq_init_attr.attr.srq_limit = srq_limit;
1019
1020 srq->ibsrq = ibv_create_srq(pd->ibpd, &srq_init_attr);
1021 if (!srq->ibsrq) {
1022 rdma_error_report("ibv_create_srq failed, errno=%d", errno);
1023 return -EIO;
1024 }
1025
1026 rdma_protected_gslist_init(&srq->cqe_ctx_list);
1027
1028 return 0;
1029 }
1030
1031 int rdma_backend_query_srq(RdmaBackendSRQ *srq, struct ibv_srq_attr *srq_attr)
1032 {
1033 if (!srq->ibsrq) {
1034 return -EINVAL;
1035 }
1036
1037 return ibv_query_srq(srq->ibsrq, srq_attr);
1038 }
1039
1040 int rdma_backend_modify_srq(RdmaBackendSRQ *srq, struct ibv_srq_attr *srq_attr,
1041 int srq_attr_mask)
1042 {
1043 if (!srq->ibsrq) {
1044 return -EINVAL;
1045 }
1046
1047 return ibv_modify_srq(srq->ibsrq, srq_attr, srq_attr_mask);
1048 }
1049
1050 void rdma_backend_destroy_srq(RdmaBackendSRQ *srq, RdmaDeviceResources *dev_res)
1051 {
1052 if (srq->ibsrq) {
1053 ibv_destroy_srq(srq->ibsrq);
1054 }
1055 g_slist_foreach(srq->cqe_ctx_list.list, free_cqe_ctx, dev_res);
1056 rdma_protected_gslist_destroy(&srq->cqe_ctx_list);
1057 }
1058
1059 #define CHK_ATTR(req, dev, member, fmt) ({ \
1060 trace_rdma_check_dev_attr(#member, dev.member, req->member); \
1061 if (req->member > dev.member) { \
1062 rdma_warn_report("%s = "fmt" is higher than host device capability "fmt, \
1063 #member, req->member, dev.member); \
1064 req->member = dev.member; \
1065 } \
1066 })
1067
1068 static int init_device_caps(RdmaBackendDev *backend_dev,
1069 struct ibv_device_attr *dev_attr)
1070 {
1071 struct ibv_device_attr bk_dev_attr;
1072 int rc;
1073
1074 rc = ibv_query_device(backend_dev->context, &bk_dev_attr);
1075 if (rc) {
1076 rdma_error_report("ibv_query_device fail, rc=%d, errno=%d", rc, errno);
1077 return -EIO;
1078 }
1079
1080 dev_attr->max_sge = MAX_SGE;
1081 dev_attr->max_srq_sge = MAX_SGE;
1082
1083 CHK_ATTR(dev_attr, bk_dev_attr, max_mr_size, "%" PRId64);
1084 CHK_ATTR(dev_attr, bk_dev_attr, max_qp, "%d");
1085 CHK_ATTR(dev_attr, bk_dev_attr, max_sge, "%d");
1086 CHK_ATTR(dev_attr, bk_dev_attr, max_cq, "%d");
1087 CHK_ATTR(dev_attr, bk_dev_attr, max_mr, "%d");
1088 CHK_ATTR(dev_attr, bk_dev_attr, max_pd, "%d");
1089 CHK_ATTR(dev_attr, bk_dev_attr, max_qp_rd_atom, "%d");
1090 CHK_ATTR(dev_attr, bk_dev_attr, max_qp_init_rd_atom, "%d");
1091 CHK_ATTR(dev_attr, bk_dev_attr, max_ah, "%d");
1092 CHK_ATTR(dev_attr, bk_dev_attr, max_srq, "%d");
1093
1094 return 0;
1095 }
1096
1097 static inline void build_mad_hdr(struct ibv_grh *grh, union ibv_gid *sgid,
1098 union ibv_gid *my_gid, int paylen)
1099 {
1100 grh->paylen = htons(paylen);
1101 grh->sgid = *sgid;
1102 grh->dgid = *my_gid;
1103 }
1104
1105 static void process_incoming_mad_req(RdmaBackendDev *backend_dev,
1106 RdmaCmMuxMsg *msg)
1107 {
1108 unsigned long cqe_ctx_id;
1109 BackendCtx *bctx;
1110 char *mad;
1111
1112 trace_mad_message("recv", msg->umad.mad, msg->umad_len);
1113
1114 cqe_ctx_id = rdma_protected_qlist_pop_int64(&backend_dev->recv_mads_list);
1115 if (cqe_ctx_id == -ENOENT) {
1116 rdma_warn_report("No more free MADs buffers, waiting for a while");
1117 sleep(THR_POLL_TO);
1118 return;
1119 }
1120
1121 bctx = rdma_rm_get_cqe_ctx(backend_dev->rdma_dev_res, cqe_ctx_id);
1122 if (unlikely(!bctx)) {
1123 rdma_error_report("No matching ctx for req %ld", cqe_ctx_id);
1124 backend_dev->rdma_dev_res->stats.mad_rx_err++;
1125 return;
1126 }
1127
1128 mad = rdma_pci_dma_map(backend_dev->dev, bctx->sge.addr,
1129 bctx->sge.length);
1130 if (!mad || bctx->sge.length < msg->umad_len + MAD_HDR_SIZE) {
1131 backend_dev->rdma_dev_res->stats.mad_rx_err++;
1132 complete_work(IBV_WC_GENERAL_ERR, VENDOR_ERR_INV_MAD_BUFF,
1133 bctx->up_ctx);
1134 } else {
1135 struct ibv_wc wc = {};
1136 memset(mad, 0, bctx->sge.length);
1137 build_mad_hdr((struct ibv_grh *)mad,
1138 (union ibv_gid *)&msg->umad.hdr.addr.gid, &msg->hdr.sgid,
1139 msg->umad_len);
1140 memcpy(&mad[MAD_HDR_SIZE], msg->umad.mad, msg->umad_len);
1141 rdma_pci_dma_unmap(backend_dev->dev, mad, bctx->sge.length);
1142
1143 wc.byte_len = msg->umad_len;
1144 wc.status = IBV_WC_SUCCESS;
1145 wc.wc_flags = IBV_WC_GRH;
1146 backend_dev->rdma_dev_res->stats.mad_rx++;
1147 comp_handler(bctx->up_ctx, &wc);
1148 }
1149
1150 g_free(bctx);
1151 rdma_rm_dealloc_cqe_ctx(backend_dev->rdma_dev_res, cqe_ctx_id);
1152 }
1153
1154 static inline int rdmacm_mux_can_receive(void *opaque)
1155 {
1156 RdmaBackendDev *backend_dev = (RdmaBackendDev *)opaque;
1157
1158 return rdmacm_mux_can_process_async(backend_dev);
1159 }
1160
1161 static void rdmacm_mux_read(void *opaque, const uint8_t *buf, int size)
1162 {
1163 RdmaBackendDev *backend_dev = (RdmaBackendDev *)opaque;
1164 RdmaCmMuxMsg *msg = (RdmaCmMuxMsg *)buf;
1165
1166 trace_rdmacm_mux("read", msg->hdr.msg_type, msg->hdr.op_code);
1167
1168 if (msg->hdr.msg_type != RDMACM_MUX_MSG_TYPE_REQ &&
1169 msg->hdr.op_code != RDMACM_MUX_OP_CODE_MAD) {
1170 rdma_error_report("Error: Not a MAD request, skipping");
1171 return;
1172 }
1173 process_incoming_mad_req(backend_dev, msg);
1174 }
1175
1176 static int mad_init(RdmaBackendDev *backend_dev, CharBackend *mad_chr_be)
1177 {
1178 int ret;
1179
1180 backend_dev->rdmacm_mux.chr_be = mad_chr_be;
1181
1182 ret = qemu_chr_fe_backend_connected(backend_dev->rdmacm_mux.chr_be);
1183 if (!ret) {
1184 rdma_error_report("Missing chardev for MAD multiplexer");
1185 return -EIO;
1186 }
1187
1188 rdma_protected_qlist_init(&backend_dev->recv_mads_list);
1189
1190 enable_rdmacm_mux_async(backend_dev);
1191
1192 qemu_chr_fe_set_handlers(backend_dev->rdmacm_mux.chr_be,
1193 rdmacm_mux_can_receive, rdmacm_mux_read, NULL,
1194 NULL, backend_dev, NULL, true);
1195
1196 return 0;
1197 }
1198
1199 static void mad_stop(RdmaBackendDev *backend_dev)
1200 {
1201 clean_recv_mads(backend_dev);
1202 }
1203
1204 static void mad_fini(RdmaBackendDev *backend_dev)
1205 {
1206 disable_rdmacm_mux_async(backend_dev);
1207 qemu_chr_fe_disconnect(backend_dev->rdmacm_mux.chr_be);
1208 rdma_protected_qlist_destroy(&backend_dev->recv_mads_list);
1209 }
1210
1211 int rdma_backend_get_gid_index(RdmaBackendDev *backend_dev,
1212 union ibv_gid *gid)
1213 {
1214 union ibv_gid sgid;
1215 int ret;
1216 int i = 0;
1217
1218 do {
1219 ret = ibv_query_gid(backend_dev->context, backend_dev->port_num, i,
1220 &sgid);
1221 i++;
1222 } while (!ret && (memcmp(&sgid, gid, sizeof(*gid))));
1223
1224 trace_rdma_backend_get_gid_index(be64_to_cpu(gid->global.subnet_prefix),
1225 be64_to_cpu(gid->global.interface_id),
1226 i - 1);
1227
1228 return ret ? ret : i - 1;
1229 }
1230
1231 int rdma_backend_add_gid(RdmaBackendDev *backend_dev, const char *ifname,
1232 union ibv_gid *gid)
1233 {
1234 RdmaCmMuxMsg msg = {};
1235 int ret;
1236
1237 trace_rdma_backend_gid_change("add", be64_to_cpu(gid->global.subnet_prefix),
1238 be64_to_cpu(gid->global.interface_id));
1239
1240 msg.hdr.op_code = RDMACM_MUX_OP_CODE_REG;
1241 memcpy(msg.hdr.sgid.raw, gid->raw, sizeof(msg.hdr.sgid));
1242
1243 ret = rdmacm_mux_send(backend_dev, &msg);
1244 if (ret) {
1245 rdma_error_report("Failed to register GID to rdma_umadmux (%d)", ret);
1246 return -EIO;
1247 }
1248
1249 qapi_event_send_rdma_gid_status_changed(ifname, true,
1250 gid->global.subnet_prefix,
1251 gid->global.interface_id);
1252
1253 return ret;
1254 }
1255
1256 int rdma_backend_del_gid(RdmaBackendDev *backend_dev, const char *ifname,
1257 union ibv_gid *gid)
1258 {
1259 RdmaCmMuxMsg msg = {};
1260 int ret;
1261
1262 trace_rdma_backend_gid_change("del", be64_to_cpu(gid->global.subnet_prefix),
1263 be64_to_cpu(gid->global.interface_id));
1264
1265 msg.hdr.op_code = RDMACM_MUX_OP_CODE_UNREG;
1266 memcpy(msg.hdr.sgid.raw, gid->raw, sizeof(msg.hdr.sgid));
1267
1268 ret = rdmacm_mux_send(backend_dev, &msg);
1269 if (ret) {
1270 rdma_error_report("Failed to unregister GID from rdma_umadmux (%d)",
1271 ret);
1272 return -EIO;
1273 }
1274
1275 qapi_event_send_rdma_gid_status_changed(ifname, false,
1276 gid->global.subnet_prefix,
1277 gid->global.interface_id);
1278
1279 return 0;
1280 }
1281
1282 int rdma_backend_init(RdmaBackendDev *backend_dev, PCIDevice *pdev,
1283 RdmaDeviceResources *rdma_dev_res,
1284 const char *backend_device_name, uint8_t port_num,
1285 struct ibv_device_attr *dev_attr, CharBackend *mad_chr_be)
1286 {
1287 int i;
1288 int ret = 0;
1289 int num_ibv_devices;
1290 struct ibv_device **dev_list;
1291
1292 memset(backend_dev, 0, sizeof(*backend_dev));
1293
1294 backend_dev->dev = pdev;
1295 backend_dev->port_num = port_num;
1296 backend_dev->rdma_dev_res = rdma_dev_res;
1297
1298 rdma_backend_register_comp_handler(dummy_comp_handler);
1299
1300 dev_list = ibv_get_device_list(&num_ibv_devices);
1301 if (!dev_list) {
1302 rdma_error_report("Failed to get IB devices list");
1303 return -EIO;
1304 }
1305
1306 if (num_ibv_devices == 0) {
1307 rdma_error_report("No IB devices were found");
1308 ret = -ENXIO;
1309 goto out_free_dev_list;
1310 }
1311
1312 if (backend_device_name) {
1313 for (i = 0; dev_list[i]; ++i) {
1314 if (!strcmp(ibv_get_device_name(dev_list[i]),
1315 backend_device_name)) {
1316 break;
1317 }
1318 }
1319
1320 backend_dev->ib_dev = dev_list[i];
1321 if (!backend_dev->ib_dev) {
1322 rdma_error_report("Failed to find IB device %s",
1323 backend_device_name);
1324 ret = -EIO;
1325 goto out_free_dev_list;
1326 }
1327 } else {
1328 backend_dev->ib_dev = *dev_list;
1329 }
1330
1331 rdma_info_report("uverb device %s", backend_dev->ib_dev->dev_name);
1332
1333 backend_dev->context = ibv_open_device(backend_dev->ib_dev);
1334 if (!backend_dev->context) {
1335 rdma_error_report("Failed to open IB device %s",
1336 ibv_get_device_name(backend_dev->ib_dev));
1337 ret = -EIO;
1338 goto out;
1339 }
1340
1341 backend_dev->channel = ibv_create_comp_channel(backend_dev->context);
1342 if (!backend_dev->channel) {
1343 rdma_error_report("Failed to create IB communication channel");
1344 ret = -EIO;
1345 goto out_close_device;
1346 }
1347
1348 ret = init_device_caps(backend_dev, dev_attr);
1349 if (ret) {
1350 rdma_error_report("Failed to initialize device capabilities");
1351 ret = -EIO;
1352 goto out_destroy_comm_channel;
1353 }
1354
1355
1356 ret = mad_init(backend_dev, mad_chr_be);
1357 if (ret) {
1358 rdma_error_report("Failed to initialize mad");
1359 ret = -EIO;
1360 goto out_destroy_comm_channel;
1361 }
1362
1363 backend_dev->comp_thread.run = false;
1364 backend_dev->comp_thread.is_running = false;
1365
1366 ah_cache_init();
1367
1368 goto out_free_dev_list;
1369
1370 out_destroy_comm_channel:
1371 ibv_destroy_comp_channel(backend_dev->channel);
1372
1373 out_close_device:
1374 ibv_close_device(backend_dev->context);
1375
1376 out_free_dev_list:
1377 ibv_free_device_list(dev_list);
1378
1379 out:
1380 return ret;
1381 }
1382
1383
1384 void rdma_backend_start(RdmaBackendDev *backend_dev)
1385 {
1386 start_comp_thread(backend_dev);
1387 }
1388
1389 void rdma_backend_stop(RdmaBackendDev *backend_dev)
1390 {
1391 mad_stop(backend_dev);
1392 stop_backend_thread(&backend_dev->comp_thread);
1393 }
1394
1395 void rdma_backend_fini(RdmaBackendDev *backend_dev)
1396 {
1397 mad_fini(backend_dev);
1398 g_hash_table_destroy(ah_hash);
1399 ibv_destroy_comp_channel(backend_dev->channel);
1400 ibv_close_device(backend_dev->context);
1401 }