hw/rdma/rdma_rm.c

   1 /*
   2  * QEMU paravirtual RDMA - Resource Manager Implementation
   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/error.h"
  18 #include "cpu.h"
  19 #include "monitor/monitor.h"
  20
  21 #include "trace.h"
  22 #include "rdma_utils.h"
  23 #include "rdma_backend.h"
  24 #include "rdma_rm.h"
  25
  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) }
  29
  30 void rdma_dump_device_counters(Monitor *mon, RdmaDeviceResources *dev_res)
  31 {
  32     monitor_printf(mon, "\ttx               : %" PRId64 "\n",
  33                    dev_res->stats.tx);
  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);
  82 }
  83
  84 static inline void res_tbl_init(const char *name, RdmaRmResTbl *tbl,
  85                                 uint32_t tbl_sz, uint32_t res_sz)
  86 {
  87     tbl->tbl = g_malloc(tbl_sz * res_sz);
  88
  89     strncpy(tbl->name, name, MAX_RM_TBL_NAME);
  90     tbl->name[MAX_RM_TBL_NAME - 1] = 0;
  91
  92     tbl->bitmap = bitmap_new(tbl_sz);
  93     tbl->tbl_sz = tbl_sz;
  94     tbl->res_sz = res_sz;
  95     tbl->used = 0;
  96     qemu_mutex_init(&tbl->lock);
  97 }
  98
  99 static inline void res_tbl_free(RdmaRmResTbl *tbl)
 100 {
 101     if (!tbl->bitmap) {
 102         return;
 103     }
 104     qemu_mutex_destroy(&tbl->lock);
 105     g_free(tbl->tbl);
 106     g_free(tbl->bitmap);
 107 }
 108
 109 static inline void *rdma_res_tbl_get(RdmaRmResTbl *tbl, uint32_t handle)
 110 {
 111     trace_rdma_res_tbl_get(tbl->name, handle);
 112
 113     if ((handle < tbl->tbl_sz) && (test_bit(handle, tbl->bitmap))) {
 114         return tbl->tbl + handle * tbl->res_sz;
 115     } else {
 116         rdma_error_report("Table %s, invalid handle %d", tbl->name, handle);
 117         return NULL;
 118     }
 119 }
 120
 121 static inline void *rdma_res_tbl_alloc(RdmaRmResTbl *tbl, uint32_t *handle)
 122 {
 123     qemu_mutex_lock(&tbl->lock);
 124
 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",
 128                           tbl->name);
 129         qemu_mutex_unlock(&tbl->lock);
 130         return NULL;
 131     }
 132
 133     set_bit(*handle, tbl->bitmap);
 134
 135     tbl->used++;
 136
 137     qemu_mutex_unlock(&tbl->lock);
 138
 139     memset(tbl->tbl + *handle * tbl->res_sz, 0, tbl->res_sz);
 140
 141     trace_rdma_res_tbl_alloc(tbl->name, *handle);
 142
 143     return tbl->tbl + *handle * tbl->res_sz;
 144 }
 145
 146 static inline void rdma_res_tbl_dealloc(RdmaRmResTbl *tbl, uint32_t handle)
 147 {
 148     trace_rdma_res_tbl_dealloc(tbl->name, handle);
 149
 150     qemu_mutex_lock(&tbl->lock);
 151
 152     if (handle < tbl->tbl_sz) {
 153         clear_bit(handle, tbl->bitmap);
 154         tbl->used--;
 155     }
 156
 157     qemu_mutex_unlock(&tbl->lock);
 158 }
 159
 160 int rdma_rm_alloc_pd(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
 161                      uint32_t *pd_handle, uint32_t ctx_handle)
 162 {
 163     RdmaRmPD *pd;
 164     int ret = -ENOMEM;
 165
 166     pd = rdma_res_tbl_alloc(&dev_res->pd_tbl, pd_handle);
 167     if (!pd) {
 168         goto out;
 169     }
 170
 171     ret = rdma_backend_create_pd(backend_dev, &pd->backend_pd);
 172     if (ret) {
 173         ret = -EIO;
 174         goto out_tbl_dealloc;
 175     }
 176
 177     pd->ctx_handle = ctx_handle;
 178
 179     return 0;
 180
 181 out_tbl_dealloc:
 182     rdma_res_tbl_dealloc(&dev_res->pd_tbl, *pd_handle);
 183
 184 out:
 185     return ret;
 186 }
 187
 188 RdmaRmPD *rdma_rm_get_pd(RdmaDeviceResources *dev_res, uint32_t pd_handle)
 189 {
 190     return rdma_res_tbl_get(&dev_res->pd_tbl, pd_handle);
 191 }
 192
 193 void rdma_rm_dealloc_pd(RdmaDeviceResources *dev_res, uint32_t pd_handle)
 194 {
 195     RdmaRmPD *pd = rdma_rm_get_pd(dev_res, pd_handle);
 196
 197     if (pd) {
 198         rdma_backend_destroy_pd(&pd->backend_pd);
 199         rdma_res_tbl_dealloc(&dev_res->pd_tbl, pd_handle);
 200     }
 201 }
 202
 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)
 207 {
 208     RdmaRmMR *mr;
 209     int ret = 0;
 210     RdmaRmPD *pd;
 211
 212     pd = rdma_rm_get_pd(dev_res, pd_handle);
 213     if (!pd) {
 214         return -EINVAL;
 215     }
 216
 217     mr = rdma_res_tbl_alloc(&dev_res->mr_tbl, mr_handle);
 218     if (!mr) {
 219         return -ENOMEM;
 220     }
 221     trace_rdma_rm_alloc_mr(*mr_handle, host_virt, guest_start, guest_length,
 222                            access_flags);
 223
 224     if (host_virt) {
 225         mr->virt = host_virt;
 226         mr->start = guest_start;
 227         mr->length = guest_length;
 228         mr->virt += (mr->start & (TARGET_PAGE_SIZE - 1));
 229
 230         ret = rdma_backend_create_mr(&mr->backend_mr, &pd->backend_pd, mr->virt,
 231                                      mr->length, access_flags);
 232         if (ret) {
 233             ret = -EIO;
 234             goto out_dealloc_mr;
 235         }
 236     }
 237
 238     /* We keep mr_handle in lkey so send and recv get get mr ptr */
 239     *lkey = *mr_handle;
 240     *rkey = -1;
 241
 242     mr->pd_handle = pd_handle;
 243
 244     return 0;
 245
 246 out_dealloc_mr:
 247     rdma_res_tbl_dealloc(&dev_res->mr_tbl, *mr_handle);
 248
 249     return ret;
 250 }
 251
 252 RdmaRmMR *rdma_rm_get_mr(RdmaDeviceResources *dev_res, uint32_t mr_handle)
 253 {
 254     return rdma_res_tbl_get(&dev_res->mr_tbl, mr_handle);
 255 }
 256
 257 void rdma_rm_dealloc_mr(RdmaDeviceResources *dev_res, uint32_t mr_handle)
 258 {
 259     RdmaRmMR *mr = rdma_rm_get_mr(dev_res, mr_handle);
 260
 261     if (mr) {
 262         rdma_backend_destroy_mr(&mr->backend_mr);
 263         trace_rdma_rm_dealloc_mr(mr_handle, mr->start);
 264         if (mr->start) {
 265             mr->virt -= (mr->start & (TARGET_PAGE_SIZE - 1));
 266             munmap(mr->virt, mr->length);
 267         }
 268         rdma_res_tbl_dealloc(&dev_res->mr_tbl, mr_handle);
 269     }
 270 }
 271
 272 int rdma_rm_alloc_uc(RdmaDeviceResources *dev_res, uint32_t pfn,
 273                      uint32_t *uc_handle)
 274 {
 275     RdmaRmUC *uc;
 276
 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,
 281                           RDMA_BAR2_UAR_SIZE);
 282         return -ENOMEM;
 283     }
 284     */
 285
 286     uc = rdma_res_tbl_alloc(&dev_res->uc_tbl, uc_handle);
 287     if (!uc) {
 288         return -ENOMEM;
 289     }
 290
 291     return 0;
 292 }
 293
 294 RdmaRmUC *rdma_rm_get_uc(RdmaDeviceResources *dev_res, uint32_t uc_handle)
 295 {
 296     return rdma_res_tbl_get(&dev_res->uc_tbl, uc_handle);
 297 }
 298
 299 void rdma_rm_dealloc_uc(RdmaDeviceResources *dev_res, uint32_t uc_handle)
 300 {
 301     RdmaRmUC *uc = rdma_rm_get_uc(dev_res, uc_handle);
 302
 303     if (uc) {
 304         rdma_res_tbl_dealloc(&dev_res->uc_tbl, uc_handle);
 305     }
 306 }
 307
 308 RdmaRmCQ *rdma_rm_get_cq(RdmaDeviceResources *dev_res, uint32_t cq_handle)
 309 {
 310     return rdma_res_tbl_get(&dev_res->cq_tbl, cq_handle);
 311 }
 312
 313 int rdma_rm_alloc_cq(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
 314                      uint32_t cqe, uint32_t *cq_handle, void *opaque)
 315 {
 316     int rc;
 317     RdmaRmCQ *cq;
 318
 319     cq = rdma_res_tbl_alloc(&dev_res->cq_tbl, cq_handle);
 320     if (!cq) {
 321         return -ENOMEM;
 322     }
 323
 324     cq->opaque = opaque;
 325     cq->notify = CNT_CLEAR;
 326
 327     rc = rdma_backend_create_cq(backend_dev, &cq->backend_cq, cqe);
 328     if (rc) {
 329         rc = -EIO;
 330         goto out_dealloc_cq;
 331     }
 332
 333     return 0;
 334
 335 out_dealloc_cq:
 336     rdma_rm_dealloc_cq(dev_res, *cq_handle);
 337
 338     return rc;
 339 }
 340
 341 void rdma_rm_req_notify_cq(RdmaDeviceResources *dev_res, uint32_t cq_handle,
 342                            bool notify)
 343 {
 344     RdmaRmCQ *cq;
 345
 346     cq = rdma_rm_get_cq(dev_res, cq_handle);
 347     if (!cq) {
 348         return;
 349     }
 350
 351     if (cq->notify != CNT_SET) {
 352         cq->notify = notify ? CNT_ARM : CNT_CLEAR;
 353     }
 354 }
 355
 356 void rdma_rm_dealloc_cq(RdmaDeviceResources *dev_res, uint32_t cq_handle)
 357 {
 358     RdmaRmCQ *cq;
 359
 360     cq = rdma_rm_get_cq(dev_res, cq_handle);
 361     if (!cq) {
 362         return;
 363     }
 364
 365     rdma_backend_destroy_cq(&cq->backend_cq);
 366
 367     rdma_res_tbl_dealloc(&dev_res->cq_tbl, cq_handle);
 368 }
 369
 370 RdmaRmQP *rdma_rm_get_qp(RdmaDeviceResources *dev_res, uint32_t qpn)
 371 {
 372     GBytes *key = g_bytes_new(&qpn, sizeof(qpn));
 373
 374     RdmaRmQP *qp = g_hash_table_lookup(dev_res->qp_hash, key);
 375
 376     g_bytes_unref(key);
 377
 378     if (!qp) {
 379         rdma_error_report("Invalid QP handle %d", qpn);
 380     }
 381
 382     return qp;
 383 }
 384
 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 {
 391     int rc;
 392     RdmaRmQP *qp;
 393     RdmaRmCQ *scq, *rcq;
 394     RdmaRmPD *pd;
 395     uint32_t rm_qpn;
 396
 397     pd = rdma_rm_get_pd(dev_res, pd_handle);
 398     if (!pd) {
 399         return -EINVAL;
 400     }
 401
 402     scq = rdma_rm_get_cq(dev_res, send_cq_handle);
 403     rcq = rdma_rm_get_cq(dev_res, recv_cq_handle);
 404
 405     if (!scq || !rcq) {
 406         rdma_error_report("Invalid send_cqn or recv_cqn (%d, %d)",
 407                           send_cq_handle, recv_cq_handle);
 408         return -EINVAL;
 409     }
 410
 411     if (qp_type == IBV_QPT_GSI) {
 412         scq->notify = CNT_SET;
 413         rcq->notify = CNT_SET;
 414     }
 415
 416     qp = rdma_res_tbl_alloc(&dev_res->qp_tbl, &rm_qpn);
 417     if (!qp) {
 418         return -ENOMEM;
 419     }
 420
 421     qp->qpn = rm_qpn;
 422     qp->qp_state = IBV_QPS_RESET;
 423     qp->qp_type = qp_type;
 424     qp->send_cq_handle = send_cq_handle;
 425     qp->recv_cq_handle = recv_cq_handle;
 426     qp->opaque = opaque;
 427
 428     rc = rdma_backend_create_qp(&qp->backend_qp, qp_type, &pd->backend_pd,
 429                                 &scq->backend_cq, &rcq->backend_cq, max_send_wr,
 430                                 max_recv_wr, max_send_sge, max_recv_sge);
 431     if (rc) {
 432         rc = -EIO;
 433         goto out_dealloc_qp;
 434     }
 435
 436     *qpn = rdma_backend_qpn(&qp->backend_qp);
 437     trace_rdma_rm_alloc_qp(rm_qpn, *qpn, qp_type);
 438     g_hash_table_insert(dev_res->qp_hash, g_bytes_new(qpn, sizeof(*qpn)), qp);
 439
 440     return 0;
 441
 442 out_dealloc_qp:
 443     rdma_res_tbl_dealloc(&dev_res->qp_tbl, qp->qpn);
 444
 445     return rc;
 446 }
 447
 448 int rdma_rm_modify_qp(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
 449                       uint32_t qp_handle, uint32_t attr_mask, uint8_t sgid_idx,
 450                       union ibv_gid *dgid, uint32_t dqpn,
 451                       enum ibv_qp_state qp_state, uint32_t qkey,
 452                       uint32_t rq_psn, uint32_t sq_psn)
 453 {
 454     RdmaRmQP *qp;
 455     int ret;
 456
 457     qp = rdma_rm_get_qp(dev_res, qp_handle);
 458     if (!qp) {
 459         return -EINVAL;
 460     }
 461
 462     if (qp->qp_type == IBV_QPT_SMI) {
 463         rdma_error_report("Got QP0 request");
 464         return -EPERM;
 465     } else if (qp->qp_type == IBV_QPT_GSI) {
 466         return 0;
 467     }
 468
 469     trace_rdma_rm_modify_qp(qp_handle, attr_mask, qp_state, sgid_idx);
 470
 471     if (attr_mask & IBV_QP_STATE) {
 472         qp->qp_state = qp_state;
 473
 474         if (qp->qp_state == IBV_QPS_INIT) {
 475             ret = rdma_backend_qp_state_init(backend_dev, &qp->backend_qp,
 476                                              qp->qp_type, qkey);
 477             if (ret) {
 478                 return -EIO;
 479             }
 480         }
 481
 482         if (qp->qp_state == IBV_QPS_RTR) {
 483             /* Get backend gid index */
 484             sgid_idx = rdma_rm_get_backend_gid_index(dev_res, backend_dev,
 485                                                      sgid_idx);
 486             if (sgid_idx <= 0) { /* TODO check also less than bk.max_sgid */
 487                 rdma_error_report("Failed to get bk sgid_idx for sgid_idx %d",
 488                                   sgid_idx);
 489                 return -EIO;
 490             }
 491
 492             ret = rdma_backend_qp_state_rtr(backend_dev, &qp->backend_qp,
 493                                             qp->qp_type, sgid_idx, dgid, dqpn,
 494                                             rq_psn, qkey,
 495                                             attr_mask & IBV_QP_QKEY);
 496             if (ret) {
 497                 return -EIO;
 498             }
 499         }
 500
 501         if (qp->qp_state == IBV_QPS_RTS) {
 502             ret = rdma_backend_qp_state_rts(&qp->backend_qp, qp->qp_type,
 503                                             sq_psn, qkey,
 504                                             attr_mask & IBV_QP_QKEY);
 505             if (ret) {
 506                 return -EIO;
 507             }
 508         }
 509     }
 510
 511     return 0;
 512 }
 513
 514 int rdma_rm_query_qp(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
 515                      uint32_t qp_handle, struct ibv_qp_attr *attr,
 516                      int attr_mask, struct ibv_qp_init_attr *init_attr)
 517 {
 518     RdmaRmQP *qp;
 519
 520     qp = rdma_rm_get_qp(dev_res, qp_handle);
 521     if (!qp) {
 522         return -EINVAL;
 523     }
 524
 525     return rdma_backend_query_qp(&qp->backend_qp, attr, attr_mask, init_attr);
 526 }
 527
 528 void rdma_rm_dealloc_qp(RdmaDeviceResources *dev_res, uint32_t qp_handle)
 529 {
 530     RdmaRmQP *qp;
 531     GBytes *key;
 532
 533     key = g_bytes_new(&qp_handle, sizeof(qp_handle));
 534     qp = g_hash_table_lookup(dev_res->qp_hash, key);
 535     g_hash_table_remove(dev_res->qp_hash, key);
 536     g_bytes_unref(key);
 537
 538     if (!qp) {
 539         return;
 540     }
 541
 542     rdma_backend_destroy_qp(&qp->backend_qp, dev_res);
 543
 544     rdma_res_tbl_dealloc(&dev_res->qp_tbl, qp->qpn);
 545 }
 546
 547 RdmaRmSRQ *rdma_rm_get_srq(RdmaDeviceResources *dev_res, uint32_t srq_handle)
 548 {
 549     return rdma_res_tbl_get(&dev_res->srq_tbl, srq_handle);
 550 }
 551
 552 int rdma_rm_alloc_srq(RdmaDeviceResources *dev_res, uint32_t pd_handle,
 553                       uint32_t max_wr, uint32_t max_sge, uint32_t srq_limit,
 554                       uint32_t *srq_handle, void *opaque)
 555 {
 556     RdmaRmSRQ *srq;
 557     RdmaRmPD *pd;
 558     int rc;
 559
 560     pd = rdma_rm_get_pd(dev_res, pd_handle);
 561     if (!pd) {
 562         return -EINVAL;
 563     }
 564
 565     srq = rdma_res_tbl_alloc(&dev_res->srq_tbl, srq_handle);
 566     if (!srq) {
 567         return -ENOMEM;
 568     }
 569
 570     rc = rdma_backend_create_srq(&srq->backend_srq, &pd->backend_pd,
 571                                  max_wr, max_sge, srq_limit);
 572     if (rc) {
 573         rc = -EIO;
 574         goto out_dealloc_srq;
 575     }
 576
 577     srq->opaque = opaque;
 578
 579     return 0;
 580
 581 out_dealloc_srq:
 582     rdma_res_tbl_dealloc(&dev_res->srq_tbl, *srq_handle);
 583
 584     return rc;
 585 }
 586
 587 int rdma_rm_query_srq(RdmaDeviceResources *dev_res, uint32_t srq_handle,
 588                       struct ibv_srq_attr *srq_attr)
 589 {
 590     RdmaRmSRQ *srq;
 591
 592     srq = rdma_rm_get_srq(dev_res, srq_handle);
 593     if (!srq) {
 594         return -EINVAL;
 595     }
 596
 597     return rdma_backend_query_srq(&srq->backend_srq, srq_attr);
 598 }
 599
 600 int rdma_rm_modify_srq(RdmaDeviceResources *dev_res, uint32_t srq_handle,
 601                        struct ibv_srq_attr *srq_attr, int srq_attr_mask)
 602 {
 603     RdmaRmSRQ *srq;
 604
 605     srq = rdma_rm_get_srq(dev_res, srq_handle);
 606     if (!srq) {
 607         return -EINVAL;
 608     }
 609
 610     if ((srq_attr_mask & IBV_SRQ_LIMIT) &&
 611         (srq_attr->srq_limit == 0)) {
 612         return -EINVAL;
 613     }
 614
 615     if ((srq_attr_mask & IBV_SRQ_MAX_WR) &&
 616         (srq_attr->max_wr == 0)) {
 617         return -EINVAL;
 618     }
 619
 620     return rdma_backend_modify_srq(&srq->backend_srq, srq_attr,
 621                                    srq_attr_mask);
 622 }
 623
 624 void rdma_rm_dealloc_srq(RdmaDeviceResources *dev_res, uint32_t srq_handle)
 625 {
 626     RdmaRmSRQ *srq;
 627
 628     srq = rdma_rm_get_srq(dev_res, srq_handle);
 629     if (!srq) {
 630         return;
 631     }
 632
 633     rdma_backend_destroy_srq(&srq->backend_srq, dev_res);
 634     rdma_res_tbl_dealloc(&dev_res->srq_tbl, srq_handle);
 635 }
 636
 637 void *rdma_rm_get_cqe_ctx(RdmaDeviceResources *dev_res, uint32_t cqe_ctx_id)
 638 {
 639     void **cqe_ctx;
 640
 641     cqe_ctx = rdma_res_tbl_get(&dev_res->cqe_ctx_tbl, cqe_ctx_id);
 642     if (!cqe_ctx) {
 643         return NULL;
 644     }
 645
 646     return *cqe_ctx;
 647 }
 648
 649 int rdma_rm_alloc_cqe_ctx(RdmaDeviceResources *dev_res, uint32_t *cqe_ctx_id,
 650                           void *ctx)
 651 {
 652     void **cqe_ctx;
 653
 654     cqe_ctx = rdma_res_tbl_alloc(&dev_res->cqe_ctx_tbl, cqe_ctx_id);
 655     if (!cqe_ctx) {
 656         return -ENOMEM;
 657     }
 658
 659     *cqe_ctx = ctx;
 660
 661     return 0;
 662 }
 663
 664 void rdma_rm_dealloc_cqe_ctx(RdmaDeviceResources *dev_res, uint32_t cqe_ctx_id)
 665 {
 666     rdma_res_tbl_dealloc(&dev_res->cqe_ctx_tbl, cqe_ctx_id);
 667 }
 668
 669 int rdma_rm_add_gid(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
 670                     const char *ifname, union ibv_gid *gid, int gid_idx)
 671 {
 672     int rc;
 673
 674     rc = rdma_backend_add_gid(backend_dev, ifname, gid);
 675     if (rc) {
 676         return -EINVAL;
 677     }
 678
 679     memcpy(&dev_res->port.gid_tbl[gid_idx].gid, gid, sizeof(*gid));
 680
 681     return 0;
 682 }
 683
 684 int rdma_rm_del_gid(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
 685                     const char *ifname, int gid_idx)
 686 {
 687     int rc;
 688
 689     if (!dev_res->port.gid_tbl[gid_idx].gid.global.interface_id) {
 690         return 0;
 691     }
 692
 693     rc = rdma_backend_del_gid(backend_dev, ifname,
 694                               &dev_res->port.gid_tbl[gid_idx].gid);
 695     if (rc) {
 696         return -EINVAL;
 697     }
 698
 699     memset(dev_res->port.gid_tbl[gid_idx].gid.raw, 0,
 700            sizeof(dev_res->port.gid_tbl[gid_idx].gid));
 701     dev_res->port.gid_tbl[gid_idx].backend_gid_index = -1;
 702
 703     return 0;
 704 }
 705
 706 int rdma_rm_get_backend_gid_index(RdmaDeviceResources *dev_res,
 707                                   RdmaBackendDev *backend_dev, int sgid_idx)
 708 {
 709     if (unlikely(sgid_idx < 0 || sgid_idx >= MAX_PORT_GIDS)) {
 710         rdma_error_report("Got invalid sgid_idx %d", sgid_idx);
 711         return -EINVAL;
 712     }
 713
 714     if (unlikely(dev_res->port.gid_tbl[sgid_idx].backend_gid_index == -1)) {
 715         dev_res->port.gid_tbl[sgid_idx].backend_gid_index =
 716         rdma_backend_get_gid_index(backend_dev,
 717                                    &dev_res->port.gid_tbl[sgid_idx].gid);
 718     }
 719
 720     return dev_res->port.gid_tbl[sgid_idx].backend_gid_index;
 721 }
 722
 723 static void destroy_qp_hash_key(gpointer data)
 724 {
 725     g_bytes_unref(data);
 726 }
 727
 728 static void init_ports(RdmaDeviceResources *dev_res)
 729 {
 730     int i;
 731
 732     memset(&dev_res->port, 0, sizeof(dev_res->port));
 733
 734     dev_res->port.state = IBV_PORT_DOWN;
 735     for (i = 0; i < MAX_PORT_GIDS; i++) {
 736         dev_res->port.gid_tbl[i].backend_gid_index = -1;
 737     }
 738 }
 739
 740 static void fini_ports(RdmaDeviceResources *dev_res,
 741                        RdmaBackendDev *backend_dev, const char *ifname)
 742 {
 743     int i;
 744
 745     dev_res->port.state = IBV_PORT_DOWN;
 746     for (i = 0; i < MAX_PORT_GIDS; i++) {
 747         rdma_rm_del_gid(dev_res, backend_dev, ifname, i);
 748     }
 749 }
 750
 751 int rdma_rm_init(RdmaDeviceResources *dev_res, struct ibv_device_attr *dev_attr)
 752 {
 753     dev_res->qp_hash = g_hash_table_new_full(g_bytes_hash, g_bytes_equal,
 754                                              destroy_qp_hash_key, NULL);
 755     if (!dev_res->qp_hash) {
 756         return -ENOMEM;
 757     }
 758
 759     res_tbl_init("PD", &dev_res->pd_tbl, dev_attr->max_pd, sizeof(RdmaRmPD));
 760     res_tbl_init("CQ", &dev_res->cq_tbl, dev_attr->max_cq, sizeof(RdmaRmCQ));
 761     res_tbl_init("MR", &dev_res->mr_tbl, dev_attr->max_mr, sizeof(RdmaRmMR));
 762     res_tbl_init("QP", &dev_res->qp_tbl, dev_attr->max_qp, sizeof(RdmaRmQP));
 763     res_tbl_init("CQE_CTX", &dev_res->cqe_ctx_tbl, dev_attr->max_qp *
 764                        dev_attr->max_qp_wr, sizeof(void *));
 765     res_tbl_init("UC", &dev_res->uc_tbl, MAX_UCS, sizeof(RdmaRmUC));
 766     res_tbl_init("SRQ", &dev_res->srq_tbl, dev_attr->max_srq,
 767                  sizeof(RdmaRmSRQ));
 768
 769     init_ports(dev_res);
 770
 771     qemu_mutex_init(&dev_res->lock);
 772
 773     memset(&dev_res->stats, 0, sizeof(dev_res->stats));
 774     atomic_set(&dev_res->stats.missing_cqe, 0);
 775
 776     return 0;
 777 }
 778
 779 void rdma_rm_fini(RdmaDeviceResources *dev_res, RdmaBackendDev *backend_dev,
 780                   const char *ifname)
 781 {
 782     qemu_mutex_destroy(&dev_res->lock);
 783
 784     fini_ports(dev_res, backend_dev, ifname);
 785
 786     res_tbl_free(&dev_res->srq_tbl);
 787     res_tbl_free(&dev_res->uc_tbl);
 788     res_tbl_free(&dev_res->cqe_ctx_tbl);
 789     res_tbl_free(&dev_res->qp_tbl);
 790     res_tbl_free(&dev_res->mr_tbl);
 791     res_tbl_free(&dev_res->cq_tbl);
 792     res_tbl_free(&dev_res->pd_tbl);
 793
 794     if (dev_res->qp_hash) {
 795         g_hash_table_destroy(dev_res->qp_hash);
 796     }
 797 }