2 * QEMU paravirtual RDMA - Resource Manager Implementation
4 * Copyright (C) 2018 Oracle
5 * Copyright (C) 2018 Red Hat Inc
8 * Yuval Shaia <yuval.shaia@oracle.com>
9 * Marcel Apfelbaum <marcel@redhat.com>
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.
16 #include "qemu/osdep.h"
17 #include "qapi/error.h"
19 #include "monitor/monitor.h"
22 #include "rdma_utils.h"
23 #include "rdma_backend.h"
26 /* Page directory and page tables */
27 #define PG_DIR_SZ { TARGET_PAGE_SIZE / sizeof(__u64) }
28 #define PG_TBL_SZ { TARGET_PAGE_SIZE / sizeof(__u64) }
30 void rdma_dump_device_counters(Monitor
*mon
, RdmaDeviceResources
*dev_res
)
32 monitor_printf(mon
, "\ttx : %" PRId64
"\n",
34 monitor_printf(mon
, "\ttx_len : %" PRId64
"\n",
35 dev_res
->stats
.tx_len
);
36 monitor_printf(mon
, "\ttx_err : %" PRId64
"\n",
37 dev_res
->stats
.tx_err
);
38 monitor_printf(mon
, "\trx_bufs : %" PRId64
"\n",
39 dev_res
->stats
.rx_bufs
);
40 monitor_printf(mon
, "\trx_srq : %" PRId64
"\n",
41 dev_res
->stats
.rx_srq
);
42 monitor_printf(mon
, "\trx_bufs_len : %" PRId64
"\n",
43 dev_res
->stats
.rx_bufs_len
);
44 monitor_printf(mon
, "\trx_bufs_err : %" PRId64
"\n",
45 dev_res
->stats
.rx_bufs_err
);
46 monitor_printf(mon
, "\tcomps : %" PRId64
"\n",
47 dev_res
->stats
.completions
);
48 monitor_printf(mon
, "\tmissing_comps : %" PRId32
"\n",
49 dev_res
->stats
.missing_cqe
);
50 monitor_printf(mon
, "\tpoll_cq (bk) : %" PRId64
"\n",
51 dev_res
->stats
.poll_cq_from_bk
);
52 monitor_printf(mon
, "\tpoll_cq_ppoll_to : %" PRId64
"\n",
53 dev_res
->stats
.poll_cq_ppoll_to
);
54 monitor_printf(mon
, "\tpoll_cq (fe) : %" PRId64
"\n",
55 dev_res
->stats
.poll_cq_from_guest
);
56 monitor_printf(mon
, "\tpoll_cq_empty : %" PRId64
"\n",
57 dev_res
->stats
.poll_cq_from_guest_empty
);
58 monitor_printf(mon
, "\tmad_tx : %" PRId64
"\n",
59 dev_res
->stats
.mad_tx
);
60 monitor_printf(mon
, "\tmad_tx_err : %" PRId64
"\n",
61 dev_res
->stats
.mad_tx_err
);
62 monitor_printf(mon
, "\tmad_rx : %" PRId64
"\n",
63 dev_res
->stats
.mad_rx
);
64 monitor_printf(mon
, "\tmad_rx_err : %" PRId64
"\n",
65 dev_res
->stats
.mad_rx_err
);
66 monitor_printf(mon
, "\tmad_rx_bufs : %" PRId64
"\n",
67 dev_res
->stats
.mad_rx_bufs
);
68 monitor_printf(mon
, "\tmad_rx_bufs_err : %" PRId64
"\n",
69 dev_res
->stats
.mad_rx_bufs_err
);
70 monitor_printf(mon
, "\tPDs : %" PRId32
"\n",
71 dev_res
->pd_tbl
.used
);
72 monitor_printf(mon
, "\tMRs : %" PRId32
"\n",
73 dev_res
->mr_tbl
.used
);
74 monitor_printf(mon
, "\tUCs : %" PRId32
"\n",
75 dev_res
->uc_tbl
.used
);
76 monitor_printf(mon
, "\tQPs : %" PRId32
"\n",
77 dev_res
->qp_tbl
.used
);
78 monitor_printf(mon
, "\tCQs : %" PRId32
"\n",
79 dev_res
->cq_tbl
.used
);
80 monitor_printf(mon
, "\tCEQ_CTXs : %" PRId32
"\n",
81 dev_res
->cqe_ctx_tbl
.used
);
84 static inline void res_tbl_init(const char *name
, RdmaRmResTbl
*tbl
,
85 uint32_t tbl_sz
, uint32_t res_sz
)
87 tbl
->tbl
= g_malloc(tbl_sz
* res_sz
);
89 strncpy(tbl
->name
, name
, MAX_RM_TBL_NAME
);
90 tbl
->name
[MAX_RM_TBL_NAME
- 1] = 0;
92 tbl
->bitmap
= bitmap_new(tbl_sz
);
96 qemu_mutex_init(&tbl
->lock
);
99 static inline void res_tbl_free(RdmaRmResTbl
*tbl
)
104 qemu_mutex_destroy(&tbl
->lock
);
109 static inline void *rdma_res_tbl_get(RdmaRmResTbl
*tbl
, uint32_t handle
)
111 trace_rdma_res_tbl_get(tbl
->name
, handle
);
113 if ((handle
< tbl
->tbl_sz
) && (test_bit(handle
, tbl
->bitmap
))) {
114 return tbl
->tbl
+ handle
* tbl
->res_sz
;
116 rdma_error_report("Table %s, invalid handle %d", tbl
->name
, handle
);
121 static inline void *rdma_res_tbl_alloc(RdmaRmResTbl
*tbl
, uint32_t *handle
)
123 qemu_mutex_lock(&tbl
->lock
);
125 *handle
= find_first_zero_bit(tbl
->bitmap
, tbl
->tbl_sz
);
126 if (*handle
> tbl
->tbl_sz
) {
127 rdma_error_report("Table %s, failed to allocate, bitmap is full",
129 qemu_mutex_unlock(&tbl
->lock
);
133 set_bit(*handle
, tbl
->bitmap
);
137 qemu_mutex_unlock(&tbl
->lock
);
139 memset(tbl
->tbl
+ *handle
* tbl
->res_sz
, 0, tbl
->res_sz
);
141 trace_rdma_res_tbl_alloc(tbl
->name
, *handle
);
143 return tbl
->tbl
+ *handle
* tbl
->res_sz
;
146 static inline void rdma_res_tbl_dealloc(RdmaRmResTbl
*tbl
, uint32_t handle
)
148 trace_rdma_res_tbl_dealloc(tbl
->name
, handle
);
150 qemu_mutex_lock(&tbl
->lock
);
152 if (handle
< tbl
->tbl_sz
) {
153 clear_bit(handle
, tbl
->bitmap
);
157 qemu_mutex_unlock(&tbl
->lock
);
160 int rdma_rm_alloc_pd(RdmaDeviceResources
*dev_res
, RdmaBackendDev
*backend_dev
,
161 uint32_t *pd_handle
, uint32_t ctx_handle
)
166 pd
= rdma_res_tbl_alloc(&dev_res
->pd_tbl
, pd_handle
);
171 ret
= rdma_backend_create_pd(backend_dev
, &pd
->backend_pd
);
174 goto out_tbl_dealloc
;
177 pd
->ctx_handle
= ctx_handle
;
182 rdma_res_tbl_dealloc(&dev_res
->pd_tbl
, *pd_handle
);
188 RdmaRmPD
*rdma_rm_get_pd(RdmaDeviceResources
*dev_res
, uint32_t pd_handle
)
190 return rdma_res_tbl_get(&dev_res
->pd_tbl
, pd_handle
);
193 void rdma_rm_dealloc_pd(RdmaDeviceResources
*dev_res
, uint32_t pd_handle
)
195 RdmaRmPD
*pd
= rdma_rm_get_pd(dev_res
, pd_handle
);
198 rdma_backend_destroy_pd(&pd
->backend_pd
);
199 rdma_res_tbl_dealloc(&dev_res
->pd_tbl
, pd_handle
);
203 int rdma_rm_alloc_mr(RdmaDeviceResources
*dev_res
, uint32_t pd_handle
,
204 uint64_t guest_start
, uint64_t guest_length
,
205 void *host_virt
, int access_flags
, uint32_t *mr_handle
,
206 uint32_t *lkey
, uint32_t *rkey
)
212 pd
= rdma_rm_get_pd(dev_res
, pd_handle
);
217 mr
= rdma_res_tbl_alloc(&dev_res
->mr_tbl
, mr_handle
);
221 trace_rdma_rm_alloc_mr(*mr_handle
, host_virt
, guest_start
, guest_length
,
225 mr
->virt
= host_virt
;
226 mr
->start
= guest_start
;
227 mr
->length
= guest_length
;
228 mr
->virt
+= (mr
->start
& (TARGET_PAGE_SIZE
- 1));
230 ret
= rdma_backend_create_mr(&mr
->backend_mr
, &pd
->backend_pd
, mr
->virt
,
231 mr
->length
, access_flags
);
238 /* We keep mr_handle in lkey so send and recv get get mr ptr */
242 mr
->pd_handle
= pd_handle
;
247 rdma_res_tbl_dealloc(&dev_res
->mr_tbl
, *mr_handle
);
252 RdmaRmMR
*rdma_rm_get_mr(RdmaDeviceResources
*dev_res
, uint32_t mr_handle
)
254 return rdma_res_tbl_get(&dev_res
->mr_tbl
, mr_handle
);
257 void rdma_rm_dealloc_mr(RdmaDeviceResources
*dev_res
, uint32_t mr_handle
)
259 RdmaRmMR
*mr
= rdma_rm_get_mr(dev_res
, mr_handle
);
262 rdma_backend_destroy_mr(&mr
->backend_mr
);
263 trace_rdma_rm_dealloc_mr(mr_handle
, mr
->start
);
265 mr
->virt
-= (mr
->start
& (TARGET_PAGE_SIZE
- 1));
266 munmap(mr
->virt
, mr
->length
);
268 rdma_res_tbl_dealloc(&dev_res
->mr_tbl
, mr_handle
);
272 int rdma_rm_alloc_uc(RdmaDeviceResources
*dev_res
, uint32_t pfn
,
277 /* TODO: Need to make sure pfn is between bar start address and
278 * bsd+RDMA_BAR2_UAR_SIZE
279 if (pfn > RDMA_BAR2_UAR_SIZE) {
280 rdma_error_report("pfn out of range (%d > %d)", pfn,
286 uc
= rdma_res_tbl_alloc(&dev_res
->uc_tbl
, uc_handle
);
294 RdmaRmUC
*rdma_rm_get_uc(RdmaDeviceResources
*dev_res
, uint32_t uc_handle
)
296 return rdma_res_tbl_get(&dev_res
->uc_tbl
, uc_handle
);
299 void rdma_rm_dealloc_uc(RdmaDeviceResources
*dev_res
, uint32_t uc_handle
)
301 RdmaRmUC
*uc
= rdma_rm_get_uc(dev_res
, uc_handle
);
304 rdma_res_tbl_dealloc(&dev_res
->uc_tbl
, uc_handle
);
308 RdmaRmCQ
*rdma_rm_get_cq(RdmaDeviceResources
*dev_res
, uint32_t cq_handle
)
310 return rdma_res_tbl_get(&dev_res
->cq_tbl
, cq_handle
);
313 int rdma_rm_alloc_cq(RdmaDeviceResources
*dev_res
, RdmaBackendDev
*backend_dev
,
314 uint32_t cqe
, uint32_t *cq_handle
, void *opaque
)
319 cq
= rdma_res_tbl_alloc(&dev_res
->cq_tbl
, cq_handle
);
325 cq
->notify
= CNT_CLEAR
;
327 rc
= rdma_backend_create_cq(backend_dev
, &cq
->backend_cq
, cqe
);
336 rdma_rm_dealloc_cq(dev_res
, *cq_handle
);
341 void rdma_rm_req_notify_cq(RdmaDeviceResources
*dev_res
, uint32_t cq_handle
,
346 cq
= rdma_rm_get_cq(dev_res
, cq_handle
);
351 if (cq
->notify
!= CNT_SET
) {
352 cq
->notify
= notify
? CNT_ARM
: CNT_CLEAR
;
356 void rdma_rm_dealloc_cq(RdmaDeviceResources
*dev_res
, uint32_t cq_handle
)
360 cq
= rdma_rm_get_cq(dev_res
, cq_handle
);
365 rdma_backend_destroy_cq(&cq
->backend_cq
);
367 rdma_res_tbl_dealloc(&dev_res
->cq_tbl
, cq_handle
);
370 RdmaRmQP
*rdma_rm_get_qp(RdmaDeviceResources
*dev_res
, uint32_t qpn
)
372 GBytes
*key
= g_bytes_new(&qpn
, sizeof(qpn
));
374 RdmaRmQP
*qp
= g_hash_table_lookup(dev_res
->qp_hash
, key
);
379 rdma_error_report("Invalid QP handle %d", qpn
);
385 int rdma_rm_alloc_qp(RdmaDeviceResources
*dev_res
, uint32_t pd_handle
,
386 uint8_t qp_type
, uint32_t max_send_wr
,
387 uint32_t max_send_sge
, uint32_t send_cq_handle
,
388 uint32_t max_recv_wr
, uint32_t max_recv_sge
,
389 uint32_t recv_cq_handle
, void *opaque
, uint32_t *qpn
,
390 uint8_t is_srq
, uint32_t srq_handle
)
396 RdmaRmSRQ
*srq
= NULL
;
399 pd
= rdma_rm_get_pd(dev_res
, pd_handle
);
404 scq
= rdma_rm_get_cq(dev_res
, send_cq_handle
);
405 rcq
= rdma_rm_get_cq(dev_res
, recv_cq_handle
);
408 rdma_error_report("Invalid send_cqn or recv_cqn (%d, %d)",
409 send_cq_handle
, recv_cq_handle
);
414 srq
= rdma_rm_get_srq(dev_res
, srq_handle
);
416 rdma_error_report("Invalid srqn %d", srq_handle
);
420 srq
->recv_cq_handle
= recv_cq_handle
;
423 if (qp_type
== IBV_QPT_GSI
) {
424 scq
->notify
= CNT_SET
;
425 rcq
->notify
= CNT_SET
;
428 qp
= rdma_res_tbl_alloc(&dev_res
->qp_tbl
, &rm_qpn
);
434 qp
->qp_state
= IBV_QPS_RESET
;
435 qp
->qp_type
= qp_type
;
436 qp
->send_cq_handle
= send_cq_handle
;
437 qp
->recv_cq_handle
= recv_cq_handle
;
441 rc
= rdma_backend_create_qp(&qp
->backend_qp
, qp_type
, &pd
->backend_pd
,
442 &scq
->backend_cq
, &rcq
->backend_cq
,
443 is_srq
? &srq
->backend_srq
: NULL
,
444 max_send_wr
, max_recv_wr
, max_send_sge
,
452 *qpn
= rdma_backend_qpn(&qp
->backend_qp
);
453 trace_rdma_rm_alloc_qp(rm_qpn
, *qpn
, qp_type
);
454 g_hash_table_insert(dev_res
->qp_hash
, g_bytes_new(qpn
, sizeof(*qpn
)), qp
);
459 rdma_res_tbl_dealloc(&dev_res
->qp_tbl
, qp
->qpn
);
464 int rdma_rm_modify_qp(RdmaDeviceResources
*dev_res
, RdmaBackendDev
*backend_dev
,
465 uint32_t qp_handle
, uint32_t attr_mask
, uint8_t sgid_idx
,
466 union ibv_gid
*dgid
, uint32_t dqpn
,
467 enum ibv_qp_state qp_state
, uint32_t qkey
,
468 uint32_t rq_psn
, uint32_t sq_psn
)
473 qp
= rdma_rm_get_qp(dev_res
, qp_handle
);
478 if (qp
->qp_type
== IBV_QPT_SMI
) {
479 rdma_error_report("Got QP0 request");
481 } else if (qp
->qp_type
== IBV_QPT_GSI
) {
485 trace_rdma_rm_modify_qp(qp_handle
, attr_mask
, qp_state
, sgid_idx
);
487 if (attr_mask
& IBV_QP_STATE
) {
488 qp
->qp_state
= qp_state
;
490 if (qp
->qp_state
== IBV_QPS_INIT
) {
491 ret
= rdma_backend_qp_state_init(backend_dev
, &qp
->backend_qp
,
498 if (qp
->qp_state
== IBV_QPS_RTR
) {
499 /* Get backend gid index */
500 sgid_idx
= rdma_rm_get_backend_gid_index(dev_res
, backend_dev
,
502 if (sgid_idx
<= 0) { /* TODO check also less than bk.max_sgid */
503 rdma_error_report("Failed to get bk sgid_idx for sgid_idx %d",
508 ret
= rdma_backend_qp_state_rtr(backend_dev
, &qp
->backend_qp
,
509 qp
->qp_type
, sgid_idx
, dgid
, dqpn
,
511 attr_mask
& IBV_QP_QKEY
);
517 if (qp
->qp_state
== IBV_QPS_RTS
) {
518 ret
= rdma_backend_qp_state_rts(&qp
->backend_qp
, qp
->qp_type
,
520 attr_mask
& IBV_QP_QKEY
);
530 int rdma_rm_query_qp(RdmaDeviceResources
*dev_res
, RdmaBackendDev
*backend_dev
,
531 uint32_t qp_handle
, struct ibv_qp_attr
*attr
,
532 int attr_mask
, struct ibv_qp_init_attr
*init_attr
)
536 qp
= rdma_rm_get_qp(dev_res
, qp_handle
);
541 return rdma_backend_query_qp(&qp
->backend_qp
, attr
, attr_mask
, init_attr
);
544 void rdma_rm_dealloc_qp(RdmaDeviceResources
*dev_res
, uint32_t qp_handle
)
549 key
= g_bytes_new(&qp_handle
, sizeof(qp_handle
));
550 qp
= g_hash_table_lookup(dev_res
->qp_hash
, key
);
551 g_hash_table_remove(dev_res
->qp_hash
, key
);
558 rdma_backend_destroy_qp(&qp
->backend_qp
, dev_res
);
560 rdma_res_tbl_dealloc(&dev_res
->qp_tbl
, qp
->qpn
);
563 RdmaRmSRQ
*rdma_rm_get_srq(RdmaDeviceResources
*dev_res
, uint32_t srq_handle
)
565 return rdma_res_tbl_get(&dev_res
->srq_tbl
, srq_handle
);
568 int rdma_rm_alloc_srq(RdmaDeviceResources
*dev_res
, uint32_t pd_handle
,
569 uint32_t max_wr
, uint32_t max_sge
, uint32_t srq_limit
,
570 uint32_t *srq_handle
, void *opaque
)
576 pd
= rdma_rm_get_pd(dev_res
, pd_handle
);
581 srq
= rdma_res_tbl_alloc(&dev_res
->srq_tbl
, srq_handle
);
586 rc
= rdma_backend_create_srq(&srq
->backend_srq
, &pd
->backend_pd
,
587 max_wr
, max_sge
, srq_limit
);
590 goto out_dealloc_srq
;
593 srq
->opaque
= opaque
;
598 rdma_res_tbl_dealloc(&dev_res
->srq_tbl
, *srq_handle
);
603 int rdma_rm_query_srq(RdmaDeviceResources
*dev_res
, uint32_t srq_handle
,
604 struct ibv_srq_attr
*srq_attr
)
608 srq
= rdma_rm_get_srq(dev_res
, srq_handle
);
613 return rdma_backend_query_srq(&srq
->backend_srq
, srq_attr
);
616 int rdma_rm_modify_srq(RdmaDeviceResources
*dev_res
, uint32_t srq_handle
,
617 struct ibv_srq_attr
*srq_attr
, int srq_attr_mask
)
621 srq
= rdma_rm_get_srq(dev_res
, srq_handle
);
626 if ((srq_attr_mask
& IBV_SRQ_LIMIT
) &&
627 (srq_attr
->srq_limit
== 0)) {
631 if ((srq_attr_mask
& IBV_SRQ_MAX_WR
) &&
632 (srq_attr
->max_wr
== 0)) {
636 return rdma_backend_modify_srq(&srq
->backend_srq
, srq_attr
,
640 void rdma_rm_dealloc_srq(RdmaDeviceResources
*dev_res
, uint32_t srq_handle
)
644 srq
= rdma_rm_get_srq(dev_res
, srq_handle
);
649 rdma_backend_destroy_srq(&srq
->backend_srq
, dev_res
);
650 rdma_res_tbl_dealloc(&dev_res
->srq_tbl
, srq_handle
);
653 void *rdma_rm_get_cqe_ctx(RdmaDeviceResources
*dev_res
, uint32_t cqe_ctx_id
)
657 cqe_ctx
= rdma_res_tbl_get(&dev_res
->cqe_ctx_tbl
, cqe_ctx_id
);
665 int rdma_rm_alloc_cqe_ctx(RdmaDeviceResources
*dev_res
, uint32_t *cqe_ctx_id
,
670 cqe_ctx
= rdma_res_tbl_alloc(&dev_res
->cqe_ctx_tbl
, cqe_ctx_id
);
680 void rdma_rm_dealloc_cqe_ctx(RdmaDeviceResources
*dev_res
, uint32_t cqe_ctx_id
)
682 rdma_res_tbl_dealloc(&dev_res
->cqe_ctx_tbl
, cqe_ctx_id
);
685 int rdma_rm_add_gid(RdmaDeviceResources
*dev_res
, RdmaBackendDev
*backend_dev
,
686 const char *ifname
, union ibv_gid
*gid
, int gid_idx
)
690 rc
= rdma_backend_add_gid(backend_dev
, ifname
, gid
);
695 memcpy(&dev_res
->port
.gid_tbl
[gid_idx
].gid
, gid
, sizeof(*gid
));
700 int rdma_rm_del_gid(RdmaDeviceResources
*dev_res
, RdmaBackendDev
*backend_dev
,
701 const char *ifname
, int gid_idx
)
705 if (!dev_res
->port
.gid_tbl
[gid_idx
].gid
.global
.interface_id
) {
709 rc
= rdma_backend_del_gid(backend_dev
, ifname
,
710 &dev_res
->port
.gid_tbl
[gid_idx
].gid
);
715 memset(dev_res
->port
.gid_tbl
[gid_idx
].gid
.raw
, 0,
716 sizeof(dev_res
->port
.gid_tbl
[gid_idx
].gid
));
717 dev_res
->port
.gid_tbl
[gid_idx
].backend_gid_index
= -1;
722 int rdma_rm_get_backend_gid_index(RdmaDeviceResources
*dev_res
,
723 RdmaBackendDev
*backend_dev
, int sgid_idx
)
725 if (unlikely(sgid_idx
< 0 || sgid_idx
>= MAX_PORT_GIDS
)) {
726 rdma_error_report("Got invalid sgid_idx %d", sgid_idx
);
730 if (unlikely(dev_res
->port
.gid_tbl
[sgid_idx
].backend_gid_index
== -1)) {
731 dev_res
->port
.gid_tbl
[sgid_idx
].backend_gid_index
=
732 rdma_backend_get_gid_index(backend_dev
,
733 &dev_res
->port
.gid_tbl
[sgid_idx
].gid
);
736 return dev_res
->port
.gid_tbl
[sgid_idx
].backend_gid_index
;
739 static void destroy_qp_hash_key(gpointer data
)
744 static void init_ports(RdmaDeviceResources
*dev_res
)
748 memset(&dev_res
->port
, 0, sizeof(dev_res
->port
));
750 dev_res
->port
.state
= IBV_PORT_DOWN
;
751 for (i
= 0; i
< MAX_PORT_GIDS
; i
++) {
752 dev_res
->port
.gid_tbl
[i
].backend_gid_index
= -1;
756 static void fini_ports(RdmaDeviceResources
*dev_res
,
757 RdmaBackendDev
*backend_dev
, const char *ifname
)
761 dev_res
->port
.state
= IBV_PORT_DOWN
;
762 for (i
= 0; i
< MAX_PORT_GIDS
; i
++) {
763 rdma_rm_del_gid(dev_res
, backend_dev
, ifname
, i
);
767 int rdma_rm_init(RdmaDeviceResources
*dev_res
, struct ibv_device_attr
*dev_attr
)
769 dev_res
->qp_hash
= g_hash_table_new_full(g_bytes_hash
, g_bytes_equal
,
770 destroy_qp_hash_key
, NULL
);
771 if (!dev_res
->qp_hash
) {
775 res_tbl_init("PD", &dev_res
->pd_tbl
, dev_attr
->max_pd
, sizeof(RdmaRmPD
));
776 res_tbl_init("CQ", &dev_res
->cq_tbl
, dev_attr
->max_cq
, sizeof(RdmaRmCQ
));
777 res_tbl_init("MR", &dev_res
->mr_tbl
, dev_attr
->max_mr
, sizeof(RdmaRmMR
));
778 res_tbl_init("QP", &dev_res
->qp_tbl
, dev_attr
->max_qp
, sizeof(RdmaRmQP
));
779 res_tbl_init("CQE_CTX", &dev_res
->cqe_ctx_tbl
, dev_attr
->max_qp
*
780 dev_attr
->max_qp_wr
, sizeof(void *));
781 res_tbl_init("UC", &dev_res
->uc_tbl
, MAX_UCS
, sizeof(RdmaRmUC
));
782 res_tbl_init("SRQ", &dev_res
->srq_tbl
, dev_attr
->max_srq
,
787 qemu_mutex_init(&dev_res
->lock
);
789 memset(&dev_res
->stats
, 0, sizeof(dev_res
->stats
));
790 atomic_set(&dev_res
->stats
.missing_cqe
, 0);
795 void rdma_rm_fini(RdmaDeviceResources
*dev_res
, RdmaBackendDev
*backend_dev
,
798 qemu_mutex_destroy(&dev_res
->lock
);
800 fini_ports(dev_res
, backend_dev
, ifname
);
802 res_tbl_free(&dev_res
->srq_tbl
);
803 res_tbl_free(&dev_res
->uc_tbl
);
804 res_tbl_free(&dev_res
->cqe_ctx_tbl
);
805 res_tbl_free(&dev_res
->qp_tbl
);
806 res_tbl_free(&dev_res
->mr_tbl
);
807 res_tbl_free(&dev_res
->cq_tbl
);
808 res_tbl_free(&dev_res
->pd_tbl
);
810 if (dev_res
->qp_hash
) {
811 g_hash_table_destroy(dev_res
->qp_hash
);