| /* |
| * Copyright (c) 2007 Cisco Systems, Inc. All rights reserved. |
| * |
| * This software is available to you under a choice of one of two |
| * licenses. You may choose to be licensed under the terms of the GNU |
| * General Public License (GPL) Version 2, available from the file |
| * COPYING in the main directory of this source tree, or the |
| * OpenIB.org BSD license below: |
| * |
| * Redistribution and use in source and binary forms, with or |
| * without modification, are permitted provided that the following |
| * conditions are met: |
| * |
| * - Redistributions of source code must retain the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials |
| * provided with the distribution. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| */ |
| |
| #if HAVE_CONFIG_H |
| # include <config.h> |
| #endif /* HAVE_CONFIG_H */ |
| |
| #include <string.h> |
| #include <stddef.h> |
| #include <stdlib.h> |
| #include <unistd.h> |
| #include <alloca.h> |
| |
| #include "ibverbs.h" |
| |
| struct ibv_pd_1_0 { |
| struct ibv_context_1_0 *context; |
| uint32_t handle; |
| |
| struct ibv_pd *real_pd; |
| }; |
| |
| struct ibv_mr_1_0 { |
| struct ibv_context_1_0 *context; |
| struct ibv_pd_1_0 *pd; |
| uint32_t handle; |
| uint32_t lkey; |
| uint32_t rkey; |
| |
| struct ibv_mr *real_mr; |
| }; |
| |
| struct ibv_srq_1_0 { |
| struct ibv_context_1_0 *context; |
| void *srq_context; |
| struct ibv_pd_1_0 *pd; |
| uint32_t handle; |
| |
| pthread_mutex_t mutex; |
| pthread_cond_t cond; |
| uint32_t events_completed; |
| |
| struct ibv_srq *real_srq; |
| }; |
| |
| struct ibv_qp_init_attr_1_0 { |
| void *qp_context; |
| struct ibv_cq_1_0 *send_cq; |
| struct ibv_cq_1_0 *recv_cq; |
| struct ibv_srq_1_0 *srq; |
| struct ibv_qp_cap cap; |
| enum ibv_qp_type qp_type; |
| int sq_sig_all; |
| }; |
| |
| struct ibv_send_wr_1_0 { |
| struct ibv_send_wr_1_0 *next; |
| uint64_t wr_id; |
| struct ibv_sge *sg_list; |
| int num_sge; |
| enum ibv_wr_opcode opcode; |
| int send_flags; |
| uint32_t imm_data; /* in network byte order */ |
| union { |
| struct { |
| uint64_t remote_addr; |
| uint32_t rkey; |
| } rdma; |
| struct { |
| uint64_t remote_addr; |
| uint64_t compare_add; |
| uint64_t swap; |
| uint32_t rkey; |
| } atomic; |
| struct { |
| struct ibv_ah_1_0 *ah; |
| uint32_t remote_qpn; |
| uint32_t remote_qkey; |
| } ud; |
| } wr; |
| }; |
| |
| struct ibv_recv_wr_1_0 { |
| struct ibv_recv_wr_1_0 *next; |
| uint64_t wr_id; |
| struct ibv_sge *sg_list; |
| int num_sge; |
| }; |
| |
| struct ibv_qp_1_0 { |
| struct ibv_context_1_0 *context; |
| void *qp_context; |
| struct ibv_pd_1_0 *pd; |
| struct ibv_cq_1_0 *send_cq; |
| struct ibv_cq_1_0 *recv_cq; |
| struct ibv_srq_1_0 *srq; |
| uint32_t handle; |
| uint32_t qp_num; |
| enum ibv_qp_state state; |
| enum ibv_qp_type qp_type; |
| |
| pthread_mutex_t mutex; |
| pthread_cond_t cond; |
| uint32_t events_completed; |
| |
| struct ibv_qp *real_qp; |
| }; |
| |
| struct ibv_cq_1_0 { |
| struct ibv_context_1_0 *context; |
| void *cq_context; |
| uint32_t handle; |
| int cqe; |
| |
| pthread_mutex_t mutex; |
| pthread_cond_t cond; |
| uint32_t comp_events_completed; |
| uint32_t async_events_completed; |
| |
| struct ibv_cq *real_cq; |
| }; |
| |
| struct ibv_ah_1_0 { |
| struct ibv_context_1_0 *context; |
| struct ibv_pd_1_0 *pd; |
| uint32_t handle; |
| |
| struct ibv_ah *real_ah; |
| }; |
| |
| struct ibv_device_1_0 { |
| void *obsolete_sysfs_dev; |
| void *obsolete_sysfs_ibdev; |
| struct ibv_device *real_device; /* was obsolete driver member */ |
| struct ibv_device_ops ops; |
| }; |
| |
| struct ibv_context_ops_1_0 { |
| int (*query_device)(struct ibv_context *context, |
| struct ibv_device_attr *device_attr); |
| int (*query_port)(struct ibv_context *context, uint8_t port_num, |
| struct ibv_port_attr *port_attr); |
| struct ibv_pd * (*alloc_pd)(struct ibv_context *context); |
| int (*dealloc_pd)(struct ibv_pd *pd); |
| struct ibv_mr * (*reg_mr)(struct ibv_pd *pd, void *addr, size_t length, |
| int access); |
| int (*dereg_mr)(struct ibv_mr *mr); |
| struct ibv_cq * (*create_cq)(struct ibv_context *context, int cqe, |
| struct ibv_comp_channel *channel, |
| int comp_vector); |
| int (*poll_cq)(struct ibv_cq_1_0 *cq, int num_entries, |
| struct ibv_wc *wc); |
| int (*req_notify_cq)(struct ibv_cq_1_0 *cq, |
| int solicited_only); |
| void (*cq_event)(struct ibv_cq *cq); |
| int (*resize_cq)(struct ibv_cq *cq, int cqe); |
| int (*destroy_cq)(struct ibv_cq *cq); |
| struct ibv_srq * (*create_srq)(struct ibv_pd *pd, |
| struct ibv_srq_init_attr *srq_init_attr); |
| int (*modify_srq)(struct ibv_srq *srq, |
| struct ibv_srq_attr *srq_attr, |
| int srq_attr_mask); |
| int (*query_srq)(struct ibv_srq *srq, |
| struct ibv_srq_attr *srq_attr); |
| int (*destroy_srq)(struct ibv_srq *srq); |
| int (*post_srq_recv)(struct ibv_srq_1_0 *srq, |
| struct ibv_recv_wr_1_0 *recv_wr, |
| struct ibv_recv_wr_1_0 **bad_recv_wr); |
| struct ibv_qp * (*create_qp)(struct ibv_pd *pd, struct ibv_qp_init_attr *attr); |
| int (*query_qp)(struct ibv_qp *qp, struct ibv_qp_attr *attr, |
| int attr_mask, |
| struct ibv_qp_init_attr *init_attr); |
| int (*modify_qp)(struct ibv_qp *qp, struct ibv_qp_attr *attr, |
| int attr_mask); |
| int (*destroy_qp)(struct ibv_qp *qp); |
| int (*post_send)(struct ibv_qp_1_0 *qp, |
| struct ibv_send_wr_1_0 *wr, |
| struct ibv_send_wr_1_0 **bad_wr); |
| int (*post_recv)(struct ibv_qp_1_0 *qp, |
| struct ibv_recv_wr_1_0 *wr, |
| struct ibv_recv_wr_1_0 **bad_wr); |
| struct ibv_ah * (*create_ah)(struct ibv_pd *pd, struct ibv_ah_attr *attr); |
| int (*destroy_ah)(struct ibv_ah *ah); |
| int (*attach_mcast)(struct ibv_qp *qp, union ibv_gid *gid, |
| uint16_t lid); |
| int (*detach_mcast)(struct ibv_qp *qp, union ibv_gid *gid, |
| uint16_t lid); |
| }; |
| |
| struct ibv_context_1_0 { |
| struct ibv_device_1_0 *device; |
| struct ibv_context_ops_1_0 ops; |
| int cmd_fd; |
| int async_fd; |
| int num_comp_vectors; |
| |
| struct ibv_context *real_context; /* was abi_compat member */ |
| }; |
| |
| struct ibv_device_1_0 **__ibv_get_device_list_1_0(int *num) |
| { |
| struct ibv_device **real_list; |
| struct ibv_device_1_0 **l; |
| int i, n; |
| |
| real_list = ibv_get_device_list(&n); |
| if (!real_list) |
| return NULL; |
| |
| l = calloc(n + 2, sizeof (struct ibv_device_1_0 *)); |
| if (!l) |
| goto free_device_list; |
| |
| l[0] = (void *) real_list; |
| |
| for (i = 0; i < n; ++i) { |
| l[i + 1] = calloc(1, sizeof (struct ibv_device_1_0)); |
| if (!l[i + 1]) |
| goto fail; |
| l[i + 1]->real_device = real_list[i]; |
| } |
| |
| if (num) |
| *num = n; |
| |
| return l + 1; |
| |
| fail: |
| for (i = 1; i <= n; ++i) |
| if (l[i]) |
| free(l[i]); |
| free(l); |
| |
| free_device_list: |
| ibv_free_device_list(real_list); |
| return NULL; |
| } |
| symver(__ibv_get_device_list_1_0, ibv_get_device_list, IBVERBS_1.0); |
| |
| void __ibv_free_device_list_1_0(struct ibv_device_1_0 **list) |
| { |
| struct ibv_device_1_0 **l = list; |
| |
| while (*l) { |
| free(*l); |
| ++l; |
| } |
| |
| ibv_free_device_list((void *) list[-1]); |
| free(list - 1); |
| } |
| symver(__ibv_free_device_list_1_0, ibv_free_device_list, IBVERBS_1.0); |
| |
| const char *__ibv_get_device_name_1_0(struct ibv_device_1_0 *device) |
| { |
| return ibv_get_device_name(device->real_device); |
| } |
| symver(__ibv_get_device_name_1_0, ibv_get_device_name, IBVERBS_1.0); |
| |
| uint64_t __ibv_get_device_guid_1_0(struct ibv_device_1_0 *device) |
| { |
| return ibv_get_device_guid(device->real_device); |
| } |
| symver(__ibv_get_device_guid_1_0, ibv_get_device_guid, IBVERBS_1.0); |
| |
| static int poll_cq_wrapper_1_0(struct ibv_cq_1_0 *cq, int num_entries, |
| struct ibv_wc *wc) |
| { |
| return cq->context->real_context->ops.poll_cq(cq->real_cq, num_entries, wc); |
| } |
| |
| static int req_notify_cq_wrapper_1_0(struct ibv_cq_1_0 *cq, int sol_only) |
| { |
| return cq->context->real_context->ops.req_notify_cq(cq->real_cq, sol_only); |
| } |
| |
| static int post_srq_recv_wrapper_1_0(struct ibv_srq_1_0 *srq, struct ibv_recv_wr_1_0 *wr, |
| struct ibv_recv_wr_1_0 **bad_wr) |
| { |
| struct ibv_recv_wr_1_0 *w; |
| struct ibv_recv_wr *real_wr, *head_wr = NULL, *tail_wr = NULL, *real_bad_wr; |
| int ret; |
| |
| for (w = wr; w; w = w->next) { |
| real_wr = alloca(sizeof *real_wr); |
| real_wr->wr_id = w->wr_id; |
| real_wr->sg_list = w->sg_list; |
| real_wr->num_sge = w->num_sge; |
| real_wr->next = NULL; |
| if (tail_wr) |
| tail_wr->next = real_wr; |
| else |
| head_wr = real_wr; |
| |
| tail_wr = real_wr; |
| } |
| |
| ret = srq->context->real_context->ops.post_srq_recv(srq->real_srq, head_wr, |
| &real_bad_wr); |
| |
| if (ret) { |
| for (real_wr = head_wr, w = wr; |
| real_wr; |
| real_wr = real_wr->next, w = w->next) |
| if (real_wr == real_bad_wr) { |
| *bad_wr = w; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| static int post_send_wrapper_1_0(struct ibv_qp_1_0 *qp, struct ibv_send_wr_1_0 *wr, |
| struct ibv_send_wr_1_0 **bad_wr) |
| { |
| struct ibv_send_wr_1_0 *w; |
| struct ibv_send_wr *real_wr, *head_wr = NULL, *tail_wr = NULL, *real_bad_wr; |
| int is_ud = qp->qp_type == IBV_QPT_UD; |
| int ret; |
| |
| for (w = wr; w; w = w->next) { |
| real_wr = alloca(sizeof *real_wr); |
| real_wr->wr_id = w->wr_id; |
| real_wr->next = NULL; |
| |
| #define TEST_SIZE_2_POINT(f1, f2) \ |
| ((offsetof(struct ibv_send_wr, f1) - offsetof(struct ibv_send_wr, f2)) \ |
| == offsetof(struct ibv_send_wr_1_0, f1) - offsetof(struct ibv_send_wr_1_0, f2)) |
| #define TEST_SIZE_TO_END(f1) \ |
| ((sizeof(struct ibv_send_wr) - offsetof(struct ibv_send_wr, f1)) == \ |
| (sizeof(struct ibv_send_wr_1_0) - offsetof(struct ibv_send_wr_1_0, f1))) |
| |
| if (TEST_SIZE_TO_END (sg_list)) |
| memcpy(&real_wr->sg_list, &w->sg_list, sizeof *real_wr |
| - offsetof(struct ibv_send_wr, sg_list)); |
| else if (TEST_SIZE_2_POINT (imm_data, sg_list) && |
| TEST_SIZE_TO_END (wr)) { |
| /* we have alignment up to wr, but padding between |
| * imm_data and wr, and we know wr itself is the |
| * same size */ |
| memcpy(&real_wr->sg_list, &w->sg_list, |
| offsetof(struct ibv_send_wr, imm_data) - |
| offsetof(struct ibv_send_wr, sg_list) + |
| sizeof real_wr->imm_data); |
| memcpy(&real_wr->wr, &w->wr, sizeof real_wr->wr); |
| } else { |
| real_wr->sg_list = w->sg_list; |
| real_wr->num_sge = w->num_sge; |
| real_wr->opcode = w->opcode; |
| real_wr->send_flags = w->send_flags; |
| real_wr->imm_data = w->imm_data; |
| if (TEST_SIZE_TO_END (wr)) |
| memcpy(&real_wr->wr, &w->wr, |
| sizeof real_wr->wr); |
| else { |
| real_wr->wr.atomic.remote_addr = |
| w->wr.atomic.remote_addr; |
| real_wr->wr.atomic.compare_add = |
| w->wr.atomic.compare_add; |
| real_wr->wr.atomic.swap = |
| w->wr.atomic.swap; |
| real_wr->wr.atomic.rkey = |
| w->wr.atomic.rkey; |
| } |
| } |
| |
| if (is_ud) |
| real_wr->wr.ud.ah = w->wr.ud.ah->real_ah; |
| |
| if (tail_wr) |
| tail_wr->next = real_wr; |
| else |
| head_wr = real_wr; |
| |
| tail_wr = real_wr; |
| } |
| |
| ret = qp->context->real_context->ops.post_send(qp->real_qp, head_wr, |
| &real_bad_wr); |
| |
| if (ret) { |
| for (real_wr = head_wr, w = wr; |
| real_wr; |
| real_wr = real_wr->next, w = w->next) |
| if (real_wr == real_bad_wr) { |
| *bad_wr = w; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| static int post_recv_wrapper_1_0(struct ibv_qp_1_0 *qp, struct ibv_recv_wr_1_0 *wr, |
| struct ibv_recv_wr_1_0 **bad_wr) |
| { |
| struct ibv_recv_wr_1_0 *w; |
| struct ibv_recv_wr *real_wr, *head_wr = NULL, *tail_wr = NULL, *real_bad_wr; |
| int ret; |
| |
| for (w = wr; w; w = w->next) { |
| real_wr = alloca(sizeof *real_wr); |
| real_wr->wr_id = w->wr_id; |
| real_wr->sg_list = w->sg_list; |
| real_wr->num_sge = w->num_sge; |
| real_wr->next = NULL; |
| if (tail_wr) |
| tail_wr->next = real_wr; |
| else |
| head_wr = real_wr; |
| |
| tail_wr = real_wr; |
| } |
| |
| ret = qp->context->real_context->ops.post_recv(qp->real_qp, head_wr, |
| &real_bad_wr); |
| |
| if (ret) { |
| for (real_wr = head_wr, w = wr; |
| real_wr; |
| real_wr = real_wr->next, w = w->next) |
| if (real_wr == real_bad_wr) { |
| *bad_wr = w; |
| break; |
| } |
| } |
| |
| return ret; |
| } |
| |
| struct ibv_context_1_0 *__ibv_open_device_1_0(struct ibv_device_1_0 *device) |
| { |
| struct ibv_context *real_ctx; |
| struct ibv_context_1_0 *ctx; |
| |
| ctx = malloc(sizeof *ctx); |
| if (!ctx) |
| return NULL; |
| |
| real_ctx = ibv_open_device(device->real_device); |
| if (!real_ctx) { |
| free(ctx); |
| return NULL; |
| } |
| |
| ctx->device = device; |
| ctx->real_context = real_ctx; |
| |
| ctx->ops.poll_cq = poll_cq_wrapper_1_0; |
| ctx->ops.req_notify_cq = req_notify_cq_wrapper_1_0; |
| ctx->ops.post_send = post_send_wrapper_1_0; |
| ctx->ops.post_recv = post_recv_wrapper_1_0; |
| ctx->ops.post_srq_recv = post_srq_recv_wrapper_1_0; |
| |
| return ctx; |
| } |
| symver(__ibv_open_device_1_0, ibv_open_device, IBVERBS_1.0); |
| |
| int __ibv_close_device_1_0(struct ibv_context_1_0 *context) |
| { |
| int ret; |
| |
| ret = ibv_close_device(context->real_context); |
| if (ret) |
| return ret; |
| |
| free(context); |
| return 0; |
| } |
| symver(__ibv_close_device_1_0, ibv_close_device, IBVERBS_1.0); |
| |
| int __ibv_get_async_event_1_0(struct ibv_context_1_0 *context, |
| struct ibv_async_event *event) |
| { |
| int ret; |
| |
| ret = ibv_get_async_event(context->real_context, event); |
| if (ret) |
| return ret; |
| |
| switch (event->event_type) { |
| case IBV_EVENT_CQ_ERR: |
| event->element.cq = event->element.cq->cq_context; |
| break; |
| |
| case IBV_EVENT_QP_FATAL: |
| case IBV_EVENT_QP_REQ_ERR: |
| case IBV_EVENT_QP_ACCESS_ERR: |
| case IBV_EVENT_COMM_EST: |
| case IBV_EVENT_SQ_DRAINED: |
| case IBV_EVENT_PATH_MIG: |
| case IBV_EVENT_PATH_MIG_ERR: |
| case IBV_EVENT_QP_LAST_WQE_REACHED: |
| event->element.qp = event->element.qp->qp_context; |
| break; |
| |
| case IBV_EVENT_SRQ_ERR: |
| case IBV_EVENT_SRQ_LIMIT_REACHED: |
| event->element.srq = event->element.srq->srq_context; |
| break; |
| |
| default: |
| break; |
| } |
| |
| return ret; |
| } |
| symver(__ibv_get_async_event_1_0, ibv_get_async_event, IBVERBS_1.0); |
| |
| void __ibv_ack_async_event_1_0(struct ibv_async_event *event) |
| { |
| struct ibv_async_event real_event = *event; |
| |
| switch (event->event_type) { |
| case IBV_EVENT_CQ_ERR: |
| real_event.element.cq = |
| ((struct ibv_cq_1_0 *) event->element.cq)->real_cq; |
| break; |
| |
| case IBV_EVENT_QP_FATAL: |
| case IBV_EVENT_QP_REQ_ERR: |
| case IBV_EVENT_QP_ACCESS_ERR: |
| case IBV_EVENT_COMM_EST: |
| case IBV_EVENT_SQ_DRAINED: |
| case IBV_EVENT_PATH_MIG: |
| case IBV_EVENT_PATH_MIG_ERR: |
| case IBV_EVENT_QP_LAST_WQE_REACHED: |
| real_event.element.qp = |
| ((struct ibv_qp_1_0 *) event->element.qp)->real_qp; |
| break; |
| |
| case IBV_EVENT_SRQ_ERR: |
| case IBV_EVENT_SRQ_LIMIT_REACHED: |
| real_event.element.srq = |
| ((struct ibv_srq_1_0 *) event->element.srq)->real_srq; |
| break; |
| |
| default: |
| break; |
| } |
| |
| ibv_ack_async_event(&real_event); |
| } |
| symver(__ibv_ack_async_event_1_0, ibv_ack_async_event, IBVERBS_1.0); |
| |
| int __ibv_query_device_1_0(struct ibv_context_1_0 *context, |
| struct ibv_device_attr *device_attr) |
| { |
| return ibv_query_device(context->real_context, device_attr); |
| } |
| symver(__ibv_query_device_1_0, ibv_query_device, IBVERBS_1.0); |
| |
| int __ibv_query_port_1_0(struct ibv_context_1_0 *context, uint8_t port_num, |
| struct ibv_port_attr *port_attr) |
| { |
| return ibv_query_port(context->real_context, port_num, port_attr); |
| } |
| symver(__ibv_query_port_1_0, ibv_query_port, IBVERBS_1.0); |
| |
| int __ibv_query_gid_1_0(struct ibv_context_1_0 *context, uint8_t port_num, |
| int index, union ibv_gid *gid) |
| { |
| return ibv_query_gid(context->real_context, port_num, index, gid); |
| } |
| symver(__ibv_query_gid_1_0, ibv_query_gid, IBVERBS_1.0); |
| |
| int __ibv_query_pkey_1_0(struct ibv_context_1_0 *context, uint8_t port_num, |
| int index, uint16_t *pkey) |
| { |
| return ibv_query_pkey(context->real_context, port_num, index, pkey); |
| } |
| symver(__ibv_query_pkey_1_0, ibv_query_pkey, IBVERBS_1.0); |
| |
| struct ibv_pd_1_0 *__ibv_alloc_pd_1_0(struct ibv_context_1_0 *context) |
| { |
| struct ibv_pd *real_pd; |
| struct ibv_pd_1_0 *pd; |
| |
| pd = malloc(sizeof *pd); |
| if (!pd) |
| return NULL; |
| |
| real_pd = ibv_alloc_pd(context->real_context); |
| if (!real_pd) { |
| free(pd); |
| return NULL; |
| } |
| |
| pd->context = context; |
| pd->real_pd = real_pd; |
| |
| return pd; |
| } |
| symver(__ibv_alloc_pd_1_0, ibv_alloc_pd, IBVERBS_1.0); |
| |
| int __ibv_dealloc_pd_1_0(struct ibv_pd_1_0 *pd) |
| { |
| int ret; |
| |
| ret = ibv_dealloc_pd(pd->real_pd); |
| if (ret) |
| return ret; |
| |
| free(pd); |
| return 0; |
| } |
| symver(__ibv_dealloc_pd_1_0, ibv_dealloc_pd, IBVERBS_1.0); |
| |
| struct ibv_mr_1_0 *__ibv_reg_mr_1_0(struct ibv_pd_1_0 *pd, void *addr, |
| size_t length, int access) |
| { |
| struct ibv_mr *real_mr; |
| struct ibv_mr_1_0 *mr; |
| |
| mr = malloc(sizeof *mr); |
| if (!mr) |
| return NULL; |
| |
| real_mr = ibv_reg_mr(pd->real_pd, addr, length, access); |
| if (!real_mr) { |
| free(mr); |
| return NULL; |
| } |
| |
| mr->context = pd->context; |
| mr->pd = pd; |
| mr->lkey = real_mr->lkey; |
| mr->rkey = real_mr->rkey; |
| mr->real_mr = real_mr; |
| |
| return mr; |
| } |
| symver(__ibv_reg_mr_1_0, ibv_reg_mr, IBVERBS_1.0); |
| |
| int __ibv_dereg_mr_1_0(struct ibv_mr_1_0 *mr) |
| { |
| int ret; |
| |
| ret = ibv_dereg_mr(mr->real_mr); |
| if (ret) |
| return ret; |
| |
| free(mr); |
| return 0; |
| } |
| symver(__ibv_dereg_mr_1_0, ibv_dereg_mr, IBVERBS_1.0); |
| |
| struct ibv_cq_1_0 *__ibv_create_cq_1_0(struct ibv_context_1_0 *context, int cqe, |
| void *cq_context, |
| struct ibv_comp_channel *channel, |
| int comp_vector) |
| { |
| struct ibv_cq *real_cq; |
| struct ibv_cq_1_0 *cq; |
| |
| cq = malloc(sizeof *cq); |
| if (!cq) |
| return NULL; |
| |
| real_cq = ibv_create_cq(context->real_context, cqe, cq_context, |
| channel, comp_vector); |
| if (!real_cq) { |
| free(cq); |
| return NULL; |
| } |
| |
| cq->context = context; |
| cq->cq_context = cq_context; |
| cq->cqe = cqe; |
| cq->real_cq = real_cq; |
| |
| real_cq->cq_context = cq; |
| |
| return cq; |
| } |
| symver(__ibv_create_cq_1_0, ibv_create_cq, IBVERBS_1.0); |
| |
| int __ibv_resize_cq_1_0(struct ibv_cq_1_0 *cq, int cqe) |
| { |
| return ibv_resize_cq(cq->real_cq, cqe); |
| } |
| symver(__ibv_resize_cq_1_0, ibv_resize_cq, IBVERBS_1.0); |
| |
| int __ibv_destroy_cq_1_0(struct ibv_cq_1_0 *cq) |
| { |
| int ret; |
| |
| ret = ibv_destroy_cq(cq->real_cq); |
| if (ret) |
| return ret; |
| |
| free(cq); |
| return 0; |
| } |
| symver(__ibv_destroy_cq_1_0, ibv_destroy_cq, IBVERBS_1.0); |
| |
| int __ibv_get_cq_event_1_0(struct ibv_comp_channel *channel, |
| struct ibv_cq_1_0 **cq, void **cq_context) |
| { |
| struct ibv_cq *real_cq; |
| void *cq_ptr; |
| int ret; |
| |
| ret = ibv_get_cq_event(channel, &real_cq, &cq_ptr); |
| if (ret) |
| return ret; |
| |
| *cq = cq_ptr; |
| *cq_context = (*cq)->cq_context; |
| |
| return 0; |
| } |
| symver(__ibv_get_cq_event_1_0, ibv_get_cq_event, IBVERBS_1.0); |
| |
| void __ibv_ack_cq_events_1_0(struct ibv_cq_1_0 *cq, unsigned int nevents) |
| { |
| ibv_ack_cq_events(cq->real_cq, nevents); |
| } |
| symver(__ibv_ack_cq_events_1_0, ibv_ack_cq_events, IBVERBS_1.0); |
| |
| struct ibv_srq_1_0 *__ibv_create_srq_1_0(struct ibv_pd_1_0 *pd, |
| struct ibv_srq_init_attr *srq_init_attr) |
| { |
| struct ibv_srq *real_srq; |
| struct ibv_srq_1_0 *srq; |
| |
| srq = malloc(sizeof *srq); |
| if (!srq) |
| return NULL; |
| |
| real_srq = ibv_create_srq(pd->real_pd, srq_init_attr); |
| if (!real_srq) { |
| free(srq); |
| return NULL; |
| } |
| |
| srq->context = pd->context; |
| srq->srq_context = srq_init_attr->srq_context; |
| srq->pd = pd; |
| srq->real_srq = real_srq; |
| |
| real_srq->srq_context = srq; |
| |
| return srq; |
| } |
| symver(__ibv_create_srq_1_0, ibv_create_srq, IBVERBS_1.0); |
| |
| int __ibv_modify_srq_1_0(struct ibv_srq_1_0 *srq, |
| struct ibv_srq_attr *srq_attr, |
| int srq_attr_mask) |
| { |
| return ibv_modify_srq(srq->real_srq, srq_attr, srq_attr_mask); |
| } |
| symver(__ibv_modify_srq_1_0, ibv_modify_srq, IBVERBS_1.0); |
| |
| int __ibv_query_srq_1_0(struct ibv_srq_1_0 *srq, struct ibv_srq_attr *srq_attr) |
| { |
| return ibv_query_srq(srq->real_srq, srq_attr); |
| } |
| symver(__ibv_query_srq_1_0, ibv_query_srq, IBVERBS_1.0); |
| |
| int __ibv_destroy_srq_1_0(struct ibv_srq_1_0 *srq) |
| { |
| int ret; |
| |
| ret = ibv_destroy_srq(srq->real_srq); |
| if (ret) |
| return ret; |
| |
| free(srq); |
| return 0; |
| } |
| symver(__ibv_destroy_srq_1_0, ibv_destroy_srq, IBVERBS_1.0); |
| |
| struct ibv_qp_1_0 *__ibv_create_qp_1_0(struct ibv_pd_1_0 *pd, |
| struct ibv_qp_init_attr_1_0 *qp_init_attr) |
| { |
| struct ibv_qp *real_qp; |
| struct ibv_qp_1_0 *qp; |
| struct ibv_qp_init_attr real_init_attr; |
| |
| qp = malloc(sizeof *qp); |
| if (!qp) |
| return NULL; |
| |
| real_init_attr.qp_context = qp_init_attr->qp_context; |
| real_init_attr.send_cq = qp_init_attr->send_cq->real_cq; |
| real_init_attr.recv_cq = qp_init_attr->recv_cq->real_cq; |
| real_init_attr.srq = qp_init_attr->srq ? |
| qp_init_attr->srq->real_srq : NULL; |
| real_init_attr.cap = qp_init_attr->cap; |
| real_init_attr.qp_type = qp_init_attr->qp_type; |
| real_init_attr.sq_sig_all = qp_init_attr->sq_sig_all; |
| |
| real_qp = ibv_create_qp(pd->real_pd, &real_init_attr); |
| if (!real_qp) { |
| free(qp); |
| return NULL; |
| } |
| |
| qp->context = pd->context; |
| qp->qp_context = qp_init_attr->qp_context; |
| qp->pd = pd; |
| qp->send_cq = qp_init_attr->send_cq; |
| qp->recv_cq = qp_init_attr->recv_cq; |
| qp->srq = qp_init_attr->srq; |
| qp->qp_type = qp_init_attr->qp_type; |
| qp->qp_num = real_qp->qp_num; |
| qp->real_qp = real_qp; |
| |
| qp_init_attr->cap = real_init_attr.cap; |
| |
| real_qp->qp_context = qp; |
| |
| return qp; |
| } |
| symver(__ibv_create_qp_1_0, ibv_create_qp, IBVERBS_1.0); |
| |
| int __ibv_query_qp_1_0(struct ibv_qp_1_0 *qp, struct ibv_qp_attr *attr, |
| int attr_mask, |
| struct ibv_qp_init_attr_1_0 *init_attr) |
| { |
| struct ibv_qp_init_attr real_init_attr; |
| int ret; |
| |
| ret = ibv_query_qp(qp->real_qp, attr, attr_mask, &real_init_attr); |
| if (ret) |
| return ret; |
| |
| init_attr->qp_context = qp->qp_context; |
| init_attr->send_cq = real_init_attr.send_cq->cq_context; |
| init_attr->recv_cq = real_init_attr.recv_cq->cq_context; |
| init_attr->srq = real_init_attr.srq->srq_context; |
| init_attr->qp_type = real_init_attr.qp_type; |
| init_attr->cap = real_init_attr.cap; |
| init_attr->sq_sig_all = real_init_attr.sq_sig_all; |
| |
| return 0; |
| } |
| symver(__ibv_query_qp_1_0, ibv_query_qp, IBVERBS_1.0); |
| |
| int __ibv_modify_qp_1_0(struct ibv_qp_1_0 *qp, struct ibv_qp_attr *attr, |
| int attr_mask) |
| { |
| return ibv_modify_qp(qp->real_qp, attr, attr_mask); |
| } |
| symver(__ibv_modify_qp_1_0, ibv_modify_qp, IBVERBS_1.0); |
| |
| int __ibv_destroy_qp_1_0(struct ibv_qp_1_0 *qp) |
| { |
| int ret; |
| |
| ret = ibv_destroy_qp(qp->real_qp); |
| if (ret) |
| return ret; |
| |
| free(qp); |
| return 0; |
| } |
| symver(__ibv_destroy_qp_1_0, ibv_destroy_qp, IBVERBS_1.0); |
| |
| struct ibv_ah_1_0 *__ibv_create_ah_1_0(struct ibv_pd_1_0 *pd, |
| struct ibv_ah_attr *attr) |
| { |
| struct ibv_ah *real_ah; |
| struct ibv_ah_1_0 *ah; |
| |
| ah = malloc(sizeof *ah); |
| if (!ah) |
| return NULL; |
| |
| real_ah = ibv_create_ah(pd->real_pd, attr); |
| if (!real_ah) { |
| free(ah); |
| return NULL; |
| } |
| |
| ah->context = pd->context; |
| ah->pd = pd; |
| ah->real_ah = real_ah; |
| |
| return ah; |
| } |
| symver(__ibv_create_ah_1_0, ibv_create_ah, IBVERBS_1.0); |
| |
| int __ibv_destroy_ah_1_0(struct ibv_ah_1_0 *ah) |
| { |
| int ret; |
| |
| ret = ibv_destroy_ah(ah->real_ah); |
| if (ret) |
| return ret; |
| |
| free(ah); |
| return 0; |
| } |
| symver(__ibv_destroy_ah_1_0, ibv_destroy_ah, IBVERBS_1.0); |
| |
| int __ibv_attach_mcast_1_0(struct ibv_qp_1_0 *qp, union ibv_gid *gid, uint16_t lid) |
| { |
| return ibv_attach_mcast(qp->real_qp, gid, lid); |
| } |
| symver(__ibv_attach_mcast_1_0, ibv_attach_mcast, IBVERBS_1.0); |
| |
| int __ibv_detach_mcast_1_0(struct ibv_qp_1_0 *qp, union ibv_gid *gid, uint16_t lid) |
| { |
| return ibv_detach_mcast(qp->real_qp, gid, lid); |
| } |
| symver(__ibv_detach_mcast_1_0, ibv_detach_mcast, IBVERBS_1.0); |