From patchwork Thu Nov 22 23:24:13 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jason Gunthorpe X-Patchwork-Id: 10694987 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id A304E1709 for ; Thu, 22 Nov 2018 23:24:28 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 903A52C3A1 for ; Thu, 22 Nov 2018 23:24:28 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 8463F2C3A7; Thu, 22 Nov 2018 23:24:28 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.0 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,MAILING_LIST_MULTI,RCVD_IN_DNSWL_HI autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 0797A2BF0F for ; Thu, 22 Nov 2018 23:24:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2407893AbeKWKGI (ORCPT ); Fri, 23 Nov 2018 05:06:08 -0500 Received: from mail-pf1-f194.google.com ([209.85.210.194]:46329 "EHLO mail-pf1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2407881AbeKWKGH (ORCPT ); Fri, 23 Nov 2018 05:06:07 -0500 Received: by mail-pf1-f194.google.com with SMTP id c73so2474129pfe.13 for ; Thu, 22 Nov 2018 15:24:24 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ziepe.ca; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=xzHexJ6Ur7XvY0W2gTAkHyYzBmymt3jh3E9HkE5ZgDI=; b=eemZzske53/y9Yh0kvu4UM96mdcbdYZqdCsVAyPA6DtwtPREHnxXY6VHrreBjPjyJ/ YaDyhHp04oCMZSclfhylughs2jNt66XKaltciiFTZPlNGMiRqCvOQXki4TuIETlCdc85 lh3l08klDhAigpydwBYRrbW7OFdq28MT+jj4fdTlEVKHtY57AcTvbC+CkyJWP1b/xSzW uFfZc8Kh051Mg0dVjRRkPYBAqaVYqHbqPfFsb/aAJG8SRxvlR2vndxReLuBkJBTTdCU6 lrFaLAHqZcVnux+y+/0i0no4Z7UCzsT0lc68JecAjBHCxpBxRp978qzo3ruz2DNxwA6z 3wJQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=xzHexJ6Ur7XvY0W2gTAkHyYzBmymt3jh3E9HkE5ZgDI=; b=uVaK2l4VMJiiSXI3JEotU3xFbi8kd/E7YwdWOZN7+PAes6yEM++1EDtfOzU2iqj8wV Yto7fkNTNLtPID+NDwRBZKD8VEBCPkELNwAzBOlY9iPno09XAIbzKtAVXA8mLi2xcDMc 26oKoiEtC++8eJenFweNe2F/0DcTL1JDgV5xqjRmlLtD2PvGGkaMhYA/YQ0qWdFy0mca EVSFIsh8ZllF7E6Xj7BA/2eITy7hb8FNtYfNNY+OM2/5L98UkTXE7aPxxOG7vxseCD96 sufgzL2wPgLGFkG9Cnxs/w5ZdOzDxwSGCiBVvXVeJWMwc3XubsL8+cu0n6VJYI4J17f5 sMzA== X-Gm-Message-State: AA+aEWYa5kkc3dSwmroOTMgQizDgAO1PStunl+6L7J4jj26/8AG05g8A D+A6qGDqnOo2H/0n8jVjMCh/rWwTGRk= X-Google-Smtp-Source: AFSGD/U9ohiJp/dhOpagX5k9Nhu94jWzMBWeD0LnGtbr+58FLvylw84/6VXGj7VrNDfhBbKBEeEsIQ== X-Received: by 2002:a62:2c4d:: with SMTP id s74mr11138007pfs.6.1542929063936; Thu, 22 Nov 2018 15:24:23 -0800 (PST) Received: from ziepe.ca (S010614cc2056d97f.ed.shawcable.net. [174.3.196.123]) by smtp.gmail.com with ESMTPSA id g190sm51868812pgc.28.2018.11.22.15.24.19 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Thu, 22 Nov 2018 15:24:19 -0800 (PST) Received: from jgg by mlx.ziepe.ca with local (Exim 4.90_1) (envelope-from ) id 1gPyKY-0007sz-HN; Thu, 22 Nov 2018 16:24:18 -0700 From: Jason Gunthorpe To: linux-rdma@vger.kernel.org Cc: Jason Gunthorpe Subject: [PATCH rdma-core 07/10] verbs: Replace IBV_INIT_CMD_RESP_EX*() with execute_cmd_write_ex Date: Thu, 22 Nov 2018 16:24:13 -0700 Message-Id: <20181122232416.30132-8-jgg@ziepe.ca> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20181122232416.30132-1-jgg@ziepe.ca> References: <20181122232416.30132-1-jgg@ziepe.ca> MIME-Version: 1.0 Sender: linux-rdma-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-rdma@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP From: Jason Gunthorpe Replace the entire IBV_INIT_CMD_RESP_EX*(); write(); VALGRIND_MAKE_MEM_DEFINED(); Sequence with a single function call. This signature has enough information for the execute call to compute the location of all 5 components of a write command. This also eliminates the legacy cmd/resp_core_size parameters. These existed to provide some limited compatibility for providers built against a different version of verbs, which is not supported any more. Signed-off-by: Jason Gunthorpe --- libibverbs/cmd.c | 159 ++++++++++++-------------------------- libibverbs/cmd_fallback.c | 36 +++++++++ libibverbs/cmd_ioctl.c | 1 + libibverbs/cmd_write.h | 30 +++++++ libibverbs/driver.h | 13 +--- libibverbs/ibverbs.h | 34 -------- providers/mlx4/verbs.c | 24 ++---- providers/mlx5/verbs.c | 48 ++++-------- 8 files changed, 146 insertions(+), 199 deletions(-) diff --git a/libibverbs/cmd.c b/libibverbs/cmd.c index d759ec89c843cc..d45082eea0cab3 100644 --- a/libibverbs/cmd.c +++ b/libibverbs/cmd.c @@ -135,10 +135,8 @@ int ibv_cmd_query_device_ex(struct ibv_context *context, struct ibv_device_attr_ex *attr, size_t attr_size, uint64_t *raw_fw_ver, struct ibv_query_device_ex *cmd, - size_t cmd_core_size, size_t cmd_size, struct ib_uverbs_ex_query_device_resp *resp, - size_t resp_core_size, size_t resp_size) { int err; @@ -150,23 +148,16 @@ int ibv_cmd_query_device_ex(struct ibv_context *context, sizeof(attr->comp_mask)) return EINVAL; - if (resp_core_size < offsetof(struct ib_uverbs_ex_query_device_resp, - response_length) + - sizeof(resp->response_length)) - return EINVAL; - - IBV_INIT_CMD_RESP_EX_V(cmd, cmd_core_size, cmd_size, - QUERY_DEVICE, resp, resp_core_size, - resp_size); cmd->comp_mask = 0; cmd->reserved = 0; memset(attr->orig_attr.fw_ver, 0, sizeof(attr->orig_attr.fw_ver)); memset(&attr->comp_mask, 0, attr_size - sizeof(attr->orig_attr)); - err = write(context->cmd_fd, cmd, cmd_size); - if (err != cmd_size) - return errno; - (void)VALGRIND_MAKE_MEM_DEFINED(resp, resp_size); + err = execute_cmd_write_ex(context, IB_USER_VERBS_EX_CMD_QUERY_DEVICE, + cmd, cmd_size, resp, resp_size); + if (err) + return err; + copy_query_dev_fields(&attr->orig_attr, &resp->base, raw_fw_ver); /* Report back supported comp_mask bits. For now no comp_mask bit is * defined */ @@ -886,10 +877,8 @@ int ibv_cmd_create_qp_ex2(struct ibv_context *context, struct verbs_qp *qp, int vqp_sz, struct ibv_qp_init_attr_ex *qp_attr, struct ibv_create_qp_ex *cmd, - size_t cmd_core_size, size_t cmd_size, struct ib_uverbs_ex_create_qp_resp *resp, - size_t resp_core_size, size_t resp_size) { struct verbs_xrcd *vxrcd = NULL; @@ -898,15 +887,7 @@ int ibv_cmd_create_qp_ex2(struct ibv_context *context, if (qp_attr->comp_mask >= IBV_QP_INIT_ATTR_RESERVED) return EINVAL; - if (resp_core_size < - offsetof(struct ib_uverbs_ex_create_qp_resp, response_length) + - sizeof(resp->response_length)) - return EINVAL; - - memset(cmd, 0, cmd_core_size); - - IBV_INIT_CMD_RESP_EX_V(cmd, cmd_core_size, cmd_size, CREATE_QP, resp, - resp_core_size, resp_size); + memset(&cmd->core_payload, 0, sizeof(cmd->core_payload)); err = create_qp_ex_common(qp, qp_attr, vxrcd, ibv_create_qp_ex_to_reg(cmd)); @@ -916,9 +897,6 @@ int ibv_cmd_create_qp_ex2(struct ibv_context *context, if (qp_attr->comp_mask & IBV_QP_INIT_ATTR_CREATE_FLAGS) { if (qp_attr->create_flags & ~CREATE_QP_EX2_SUP_CREATE_FLAGS) return EINVAL; - if (cmd_core_size < offsetof(struct ibv_create_qp_ex, create_flags) + - sizeof(qp_attr->create_flags)) - return EINVAL; cmd->create_flags = qp_attr->create_flags; if (qp_attr->create_flags & IBV_QP_CREATE_SOURCE_QPN) @@ -926,18 +904,14 @@ int ibv_cmd_create_qp_ex2(struct ibv_context *context, } if (qp_attr->comp_mask & IBV_QP_INIT_ATTR_IND_TABLE) { - if (cmd_core_size < offsetof(struct ibv_create_qp_ex, rwq_ind_tbl_handle) + - sizeof(cmd->rwq_ind_tbl_handle)) - return EINVAL; cmd->rwq_ind_tbl_handle = qp_attr->rwq_ind_tbl->ind_tbl_handle; cmd->comp_mask = IB_UVERBS_CREATE_QP_MASK_IND_TABLE; } - err = write(context->cmd_fd, cmd, cmd_size); - if (err != cmd_size) - return errno; - - (void)VALGRIND_MAKE_MEM_DEFINED(resp, resp_size); + err = execute_cmd_write_ex(context, IB_USER_VERBS_EX_CMD_CREATE_QP, + cmd, cmd_size, resp, resp_size); + if (err) + return err; create_qp_handle_resp_common(context, qp, qp_attr, &resp->base, vxrcd, vqp_sz); @@ -1288,17 +1262,10 @@ int ibv_cmd_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr, int ibv_cmd_modify_qp_ex(struct ibv_qp *qp, struct ibv_qp_attr *attr, int attr_mask, struct ibv_modify_qp_ex *cmd, - size_t cmd_core_size, size_t cmd_size, + size_t cmd_size, struct ib_uverbs_ex_modify_qp_resp *resp, - size_t resp_core_size, size_t resp_size) + size_t resp_size) { - if (resp_core_size < offsetof(struct ib_uverbs_ex_modify_qp_resp, - response_length) + sizeof(resp->response_length)) - return EINVAL; - - IBV_INIT_CMD_RESP_EX_V(cmd, cmd_core_size, cmd_size, MODIFY_QP, - resp, resp_core_size, resp_size); - copy_modify_qp_fields(qp, attr, attr_mask, &cmd->base); if (attr_mask & IBV_QP_RATE_LIMIT) { @@ -1309,12 +1276,8 @@ int ibv_cmd_modify_qp_ex(struct ibv_qp *qp, struct ibv_qp_attr *attr, return EINVAL; } - if (write(qp->context->cmd_fd, cmd, cmd_size) != cmd_size) - return errno; - - (void)VALGRIND_MAKE_MEM_DEFINED(resp, resp_size); - - return 0; + return execute_cmd_write_ex(qp->context, IB_USER_VERBS_EX_CMD_MODIFY_QP, + cmd, cmd_size, resp, resp_size); } int ibv_cmd_post_send(struct ibv_qp *ibqp, struct ibv_send_wr *wr, @@ -1847,7 +1810,7 @@ int ibv_cmd_create_flow(struct ibv_qp *qp, err = ib_spec_to_kern_spec(ib_spec, kern_spec); if (err) { errno = err; - goto err; + return err; } cmd->flow_attr.size += ((struct ibv_kern_spec *)kern_spec)->hdr.size; @@ -1861,19 +1824,16 @@ int ibv_cmd_create_flow(struct ibv_qp *qp, written_size += ucmd_size; } - IBV_INIT_CMD_RESP_EX_VCMD(cmd, written_size - ucmd_size, - written_size, CREATE_FLOW, - &resp, sizeof(resp)); - if (write(qp->context->cmd_fd, cmd, written_size) != written_size) - goto err; - - (void) VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof(resp)); + err = execute_cmd_write_ex_full(qp->context, + IB_USER_VERBS_EX_CMD_CREATE_FLOW, cmd, + written_size - ucmd_size, written_size, + &resp, sizeof(resp), sizeof(resp)); + if (err) + return err; flow_id->context = qp->context; flow_id->handle = resp.flow_handle; return 0; -err: - return errno; } int ibv_cmd_destroy_flow(struct ibv_flow *flow_id) @@ -1895,10 +1855,8 @@ int ibv_cmd_create_wq(struct ibv_context *context, struct ibv_wq_init_attr *wq_init_attr, struct ibv_wq *wq, struct ibv_create_wq *cmd, - size_t cmd_core_size, size_t cmd_size, struct ib_uverbs_ex_create_wq_resp *resp, - size_t resp_core_size, size_t resp_size) { int err; @@ -1906,10 +1864,6 @@ int ibv_cmd_create_wq(struct ibv_context *context, if (wq_init_attr->comp_mask >= IBV_WQ_INIT_ATTR_RESERVED) return EINVAL; - IBV_INIT_CMD_RESP_EX_V(cmd, cmd_core_size, cmd_size, - CREATE_WQ, resp, - resp_core_size, resp_size); - cmd->user_handle = (uintptr_t)wq; cmd->pd_handle = wq_init_attr->pd->handle; cmd->cq_handle = wq_init_attr->cq->handle; @@ -1918,22 +1872,18 @@ int ibv_cmd_create_wq(struct ibv_context *context, cmd->max_wr = wq_init_attr->max_wr; cmd->comp_mask = 0; - if (cmd_core_size >= offsetof(struct ibv_create_wq, create_flags) + - sizeof(cmd->create_flags)) { - if (wq_init_attr->comp_mask & IBV_WQ_INIT_ATTR_FLAGS) { - if (wq_init_attr->create_flags & ~(IBV_WQ_FLAGS_RESERVED - 1)) - return EOPNOTSUPP; - cmd->create_flags = wq_init_attr->create_flags; - } + if (wq_init_attr->comp_mask & IBV_WQ_INIT_ATTR_FLAGS) { + if (wq_init_attr->create_flags & ~(IBV_WQ_FLAGS_RESERVED - 1)) + return EOPNOTSUPP; + cmd->create_flags = wq_init_attr->create_flags; } - err = write(context->cmd_fd, cmd, cmd_size); - if (err != cmd_size) - return errno; - - (void) VALGRIND_MAKE_MEM_DEFINED(resp, resp_size); + err = execute_cmd_write_ex(context, IB_USER_VERBS_EX_CMD_CREATE_WQ, + cmd, cmd_size, resp, resp_size); + if (err) + return err; - if (resp->response_length < resp_core_size) + if (resp->response_length < sizeof(*resp)) return EINVAL; wq->handle = resp->wq_handle; @@ -1949,31 +1899,30 @@ int ibv_cmd_create_wq(struct ibv_context *context, } int ibv_cmd_modify_wq(struct ibv_wq *wq, struct ibv_wq_attr *attr, - struct ibv_modify_wq *cmd, size_t cmd_core_size, - size_t cmd_size) + struct ibv_modify_wq *cmd, size_t cmd_size) { + int err; + if (attr->attr_mask >= IBV_WQ_ATTR_RESERVED) return EINVAL; - memset(cmd, 0, cmd_core_size); - IBV_INIT_CMD_EX(cmd, cmd_size, MODIFY_WQ); + memset(cmd, 0, sizeof(*cmd)); cmd->curr_wq_state = attr->curr_wq_state; cmd->wq_state = attr->wq_state; - if (cmd_core_size >= offsetof(struct ibv_modify_wq, flags_mask) + - sizeof(cmd->flags_mask)) { - if (attr->attr_mask & IBV_WQ_ATTR_FLAGS) { - if (attr->flags_mask & ~(IBV_WQ_FLAGS_RESERVED - 1)) - return EOPNOTSUPP; - cmd->flags = attr->flags; - cmd->flags_mask = attr->flags_mask; - } + if (attr->attr_mask & IBV_WQ_ATTR_FLAGS) { + if (attr->flags_mask & ~(IBV_WQ_FLAGS_RESERVED - 1)) + return EOPNOTSUPP; + cmd->flags = attr->flags; + cmd->flags_mask = attr->flags_mask; } cmd->wq_handle = wq->handle; cmd->attr_mask = attr->attr_mask; - if (write(wq->context->cmd_fd, cmd, cmd_size) != cmd_size) - return errno; + err = execute_cmd_write_ex_req( + wq->context, IB_USER_VERBS_EX_CMD_MODIFY_WQ, cmd, cmd_size); + if (err) + return err; if (attr->attr_mask & IBV_WQ_ATTR_STATE) wq->state = attr->wq_state; @@ -2030,17 +1979,15 @@ int ibv_cmd_create_rwq_ind_table(struct ibv_context *context, for (i = 0; i < num_tbl_entries; i++) cmd->wq_handles[i] = init_attr->ind_tbl[i]->handle; - IBV_INIT_CMD_RESP_EX_V(cmd, cmd_size, cmd_size, - CREATE_RWQ_IND_TBL, resp, - sizeof(*resp), resp_size); cmd->log_ind_tbl_size = init_attr->log_ind_tbl_size; cmd->comp_mask = 0; - err = write(context->cmd_fd, cmd, cmd_size); - if (err != cmd_size) - return errno; - - (void) VALGRIND_MAKE_MEM_DEFINED(resp, resp_size); + err = execute_cmd_write_ex_full(context, + IB_USER_VERBS_EX_CMD_CREATE_RWQ_IND_TBL, + cmd, cmd_size, cmd_size, resp, + sizeof(*resp), resp_size); + if (err) + return err; if (resp->response_length < sizeof(*resp)) return EINVAL; @@ -2076,16 +2023,12 @@ int ibv_cmd_modify_cq(struct ibv_cq *cq, if (attr->attr_mask >= IBV_CQ_ATTR_RESERVED) return EINVAL; - IBV_INIT_CMD_EX(cmd, cmd_size, MODIFY_CQ); - cmd->cq_handle = cq->handle; cmd->attr_mask = attr->attr_mask; cmd->attr.cq_count = attr->moderate.cq_count; cmd->attr.cq_period = attr->moderate.cq_period; cmd->reserved = 0; - if (write(cq->context->cmd_fd, cmd, cmd_size) != cmd_size) - return errno; - - return 0; + return execute_cmd_write_ex_req( + cq->context, IB_USER_VERBS_EX_CMD_MODIFY_CQ, cmd, cmd_size); } diff --git a/libibverbs/cmd_fallback.c b/libibverbs/cmd_fallback.c index 3a43a0c569776f..cad8b21756a6a6 100644 --- a/libibverbs/cmd_fallback.c +++ b/libibverbs/cmd_fallback.c @@ -38,6 +38,7 @@ #include #include +#include /* * Check if the command buffer provided by the driver includes anything that @@ -285,3 +286,38 @@ int _execute_write_raw_ex(struct ibv_context *ctx, struct ex_hdr *hdr) return 0; } + +/* + * req_size is the total length of the ex_hdr, core payload and driver data. + * core_req_size is the total length of the ex_hdr and core_payload. + */ +int _execute_cmd_write_ex(struct ibv_context *ctx, unsigned int write_method, + struct ex_hdr *req, size_t core_req_size, + size_t req_size, void *resp, size_t core_resp_size, + size_t resp_size) +{ + req->hdr.command = IB_USER_VERBS_CMD_FLAG_EXTENDED | write_method; + req->hdr.in_words = + __check_divide(core_req_size - sizeof(struct ex_hdr), 8); + req->hdr.out_words = __check_divide(core_resp_size, 8); + req->ex_hdr.provider_in_words = + __check_divide(req_size - core_req_size, 8); + req->ex_hdr.provider_out_words = + __check_divide(resp_size - core_resp_size, 8); + req->ex_hdr.response = ioctl_ptr_to_u64(resp); + req->ex_hdr.cmd_hdr_reserved = 0; + + /* + * Users assumes the stack buffer is zeroed before passing to the + * kernel for writing. + */ + if (resp) + memset(resp, 0, resp_size); + + if (write(ctx->cmd_fd, req, req_size) != req_size) + return errno; + + if (resp) + VALGRIND_MAKE_MEM_DEFINED(resp, resp_size); + return 0; +} diff --git a/libibverbs/cmd_ioctl.c b/libibverbs/cmd_ioctl.c index c12442f319a570..bb6ab45ebba96e 100644 --- a/libibverbs/cmd_ioctl.c +++ b/libibverbs/cmd_ioctl.c @@ -38,6 +38,7 @@ #include #include +#include /* Number of attrs in this and all the link'd buffers */ unsigned int __ioctl_final_num_attrs(unsigned int num_attrs, diff --git a/libibverbs/cmd_write.h b/libibverbs/cmd_write.h index 7ae26359b25f29..2a3c50aa62015c 100644 --- a/libibverbs/cmd_write.h +++ b/libibverbs/cmd_write.h @@ -256,6 +256,36 @@ int _execute_cmd_write(struct ibv_context *ctx, unsigned int write_method, resp_size, resp_size); \ }) +/* + * For write() commands that use the _ex protocol. _full allows the caller to + * specify all 4 sizes directly. This version is used when the core structs + * end in a flex array. The normal and req versions are similar to write() and + * deduce the length of the core struct from the enum. + */ +int _execute_cmd_write_ex(struct ibv_context *ctx, unsigned int write_method, + struct ex_hdr *req, size_t core_req_size, + size_t req_size, void *resp, size_t core_resp_size, + size_t resp_size); +#define execute_cmd_write_ex_full(ctx, enum, cmd, core_cmd_size, cmd_size, \ + resp, core_resp_size, resp_size) \ + _execute_cmd_write_ex( \ + ctx, enum, &(cmd)->hdr + check_type(cmd, IBV_ABI_REQ(enum) *), \ + core_cmd_size, cmd_size, \ + resp + check_type(resp, IBV_KABI_RESP(enum) *), \ + core_resp_size, resp_size) +#define execute_cmd_write_ex(ctx, enum, cmd, cmd_size, resp, resp_size) \ + execute_cmd_write_ex_full(ctx, enum, cmd, sizeof(*(cmd)), cmd_size, \ + resp, sizeof(*(resp)), resp_size) +#define execute_cmd_write_ex_req(ctx, enum, cmd, cmd_size) \ + ({ \ + static_assert(sizeof(IBV_KABI_RESP(enum)) == 0, \ + "Method has a response!"); \ + _execute_cmd_write_ex( \ + ctx, enum, \ + &(cmd)->hdr + check_type(cmd, IBV_ABI_REQ(enum) *), \ + sizeof(*(cmd)), cmd_size, NULL, 0, 0); \ + }) + /* * These two macros are used only with execute_ioctl_fallback - they allow the * IOCTL code to be elided by the compiler when disabled. diff --git a/libibverbs/driver.h b/libibverbs/driver.h index cc879fb61335c7..9030dc81d37ca4 100644 --- a/libibverbs/driver.h +++ b/libibverbs/driver.h @@ -413,10 +413,8 @@ int ibv_cmd_query_device_ex(struct ibv_context *context, struct ibv_device_attr_ex *attr, size_t attr_size, uint64_t *raw_fw_ver, struct ibv_query_device_ex *cmd, - size_t cmd_core_size, size_t cmd_size, struct ib_uverbs_ex_query_device_resp *resp, - size_t resp_core_size, size_t resp_size); int ibv_cmd_query_port(struct ibv_context *context, uint8_t port_num, struct ibv_port_attr *port_attr, @@ -501,10 +499,8 @@ int ibv_cmd_create_qp_ex2(struct ibv_context *context, struct verbs_qp *qp, int vqp_sz, struct ibv_qp_init_attr_ex *qp_attr, struct ibv_create_qp_ex *cmd, - size_t cmd_core_size, size_t cmd_size, struct ib_uverbs_ex_create_qp_resp *resp, - size_t resp_core_size, size_t resp_size); int ibv_cmd_open_qp(struct ibv_context *context, struct verbs_qp *qp, int vqp_sz, @@ -520,9 +516,9 @@ int ibv_cmd_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr, struct ibv_modify_qp *cmd, size_t cmd_size); int ibv_cmd_modify_qp_ex(struct ibv_qp *qp, struct ibv_qp_attr *attr, int attr_mask, struct ibv_modify_qp_ex *cmd, - size_t cmd_core_size, size_t cmd_size, + size_t cmd_size, struct ib_uverbs_ex_modify_qp_resp *resp, - size_t resp_core_size, size_t resp_size); + size_t resp_size); int ibv_cmd_destroy_qp(struct ibv_qp *qp); int ibv_cmd_post_send(struct ibv_qp *ibqp, struct ibv_send_wr *wr, struct ibv_send_wr **bad_wr); @@ -548,16 +544,13 @@ int ibv_cmd_create_wq(struct ibv_context *context, struct ibv_wq_init_attr *wq_init_attr, struct ibv_wq *wq, struct ibv_create_wq *cmd, - size_t cmd_core_size, size_t cmd_size, struct ib_uverbs_ex_create_wq_resp *resp, - size_t resp_core_size, size_t resp_size); int ibv_cmd_destroy_flow_action(struct verbs_flow_action *action); int ibv_cmd_modify_wq(struct ibv_wq *wq, struct ibv_wq_attr *attr, - struct ibv_modify_wq *cmd, size_t cmd_core_size, - size_t cmd_size); + struct ibv_modify_wq *cmd, size_t cmd_size); int ibv_cmd_destroy_wq(struct ibv_wq *wq); int ibv_cmd_create_rwq_ind_table(struct ibv_context *context, struct ibv_rwq_ind_table_init_attr *init_attr, diff --git a/libibverbs/ibverbs.h b/libibverbs/ibverbs.h index c70114f11e9bad..24843b49fdb3c7 100644 --- a/libibverbs/ibverbs.h +++ b/libibverbs/ibverbs.h @@ -37,9 +37,6 @@ #include #include - -#include - #include #define INIT __attribute__((constructor)) @@ -86,35 +83,4 @@ static inline const struct verbs_context_ops *get_ops(struct ibv_context *ctx) return &get_priv(ctx)->ops; } -static inline uint32_t _cmd_ex(uint32_t cmd) -{ - return IB_USER_VERBS_CMD_FLAG_EXTENDED | cmd; -} - -#define IBV_INIT_CMD_RESP_EX_V(cmd, cmd_size, size, opcode, out, resp_size,\ - outsize) \ - do { \ - size_t c_size = cmd_size - sizeof(struct ex_hdr); \ - (cmd)->hdr.hdr.command = \ - _cmd_ex(IB_USER_VERBS_EX_CMD_##opcode); \ - (cmd)->hdr.hdr.in_words = ((c_size) / 8); \ - (cmd)->hdr.hdr.out_words = ((resp_size) / 8); \ - (cmd)->hdr.ex_hdr.provider_in_words = (((size) - (cmd_size))/8);\ - (cmd)->hdr.ex_hdr.provider_out_words = \ - (((outsize) - (resp_size)) / 8); \ - (cmd)->hdr.ex_hdr.response = (uintptr_t) (out); \ - (cmd)->hdr.ex_hdr.cmd_hdr_reserved = 0; \ - } while (0) - -#define IBV_INIT_CMD_RESP_EX_VCMD(cmd, cmd_size, size, opcode, out, outsize) \ - IBV_INIT_CMD_RESP_EX_V(cmd, cmd_size, size, opcode, out, \ - sizeof(*(out)), outsize) - -#define IBV_INIT_CMD_RESP_EX(cmd, size, opcode, out, outsize) \ - IBV_INIT_CMD_RESP_EX_V(cmd, sizeof(*(cmd)), size, opcode, out, \ - sizeof(*(out)), outsize) - -#define IBV_INIT_CMD_EX(cmd, size, opcode) \ - IBV_INIT_CMD_RESP_EX_V(cmd, sizeof(*(cmd)), size, opcode, NULL, 0, 0) - #endif /* IB_VERBS_H */ diff --git a/providers/mlx4/verbs.c b/providers/mlx4/verbs.c index a88454e405c717..7a357b5da2759f 100644 --- a/providers/mlx4/verbs.c +++ b/providers/mlx4/verbs.c @@ -80,10 +80,8 @@ int mlx4_query_device_ex(struct ibv_context *context, int err; err = ibv_cmd_query_device_ex(context, input, attr, attr_size, - &raw_fw_ver, - &cmd.ibv_cmd, sizeof(cmd.ibv_cmd), sizeof(cmd), - &resp.ibv_resp, sizeof(resp.ibv_resp), - sizeof(resp)); + &raw_fw_ver, &cmd.ibv_cmd, sizeof(cmd), + &resp.ibv_resp, sizeof(resp)); if (err) return err; @@ -785,10 +783,9 @@ static int mlx4_cmd_create_qp_ex_rss(struct ibv_context *context, sizeof(cmd_ex.rx_hash_key)); ret = ibv_cmd_create_qp_ex2(context, &qp->verbs_qp, - sizeof(qp->verbs_qp), attr, - &cmd_ex.ibv_cmd, sizeof(cmd_ex.ibv_cmd), + sizeof(qp->verbs_qp), attr, &cmd_ex.ibv_cmd, sizeof(cmd_ex), &resp.ibv_resp, - sizeof(resp.ibv_resp), sizeof(resp)); + sizeof(resp)); return ret; } @@ -841,10 +838,9 @@ static int mlx4_cmd_create_qp_ex(struct ibv_context *context, cmd_ex.drv_payload = cmd->drv_payload; ret = ibv_cmd_create_qp_ex2(context, &qp->verbs_qp, - sizeof(qp->verbs_qp), attr, - &cmd_ex.ibv_cmd, sizeof(cmd_ex.ibv_cmd), + sizeof(qp->verbs_qp), attr, &cmd_ex.ibv_cmd, sizeof(cmd_ex), &resp.ibv_resp, - sizeof(resp.ibv_resp), sizeof(resp)); + sizeof(resp)); return ret; } @@ -1479,10 +1475,7 @@ struct ibv_wq *mlx4_create_wq(struct ibv_context *context, pthread_mutex_lock(&to_mctx(context)->qp_table_mutex); ret = ibv_cmd_create_wq(context, attr, &qp->wq, &cmd.ibv_cmd, - sizeof(cmd.ibv_cmd), - sizeof(cmd), - &resp, sizeof(resp), - sizeof(resp)); + sizeof(cmd), &resp, sizeof(resp)); if (ret) goto err_rq_db; @@ -1529,8 +1522,7 @@ int mlx4_modify_wq(struct ibv_wq *ibwq, struct ibv_wq_attr *attr) struct mlx4_modify_wq cmd = {}; int ret; - ret = ibv_cmd_modify_wq(ibwq, attr, &cmd.ibv_cmd, sizeof(cmd.ibv_cmd), - sizeof(cmd)); + ret = ibv_cmd_modify_wq(ibwq, attr, &cmd.ibv_cmd, sizeof(cmd)); if (!ret && (attr->attr_mask & IBV_WQ_ATTR_STATE) && (ibwq->state == IBV_WQS_RESET)) { diff --git a/providers/mlx5/verbs.c b/providers/mlx5/verbs.c index 22a3b9ff23c98c..9378c07e1ee2ba 100644 --- a/providers/mlx5/verbs.c +++ b/providers/mlx5/verbs.c @@ -1557,10 +1557,9 @@ static int mlx5_cmd_create_rss_qp(struct ibv_context *context, attr->rx_hash_conf.rx_hash_key_len); ret = ibv_cmd_create_qp_ex2(context, &qp->verbs_qp, - sizeof(qp->verbs_qp), attr, - &cmd_ex_rss.ibv_cmd, sizeof(cmd_ex_rss.ibv_cmd), - sizeof(cmd_ex_rss), &resp.ibv_resp, - sizeof(resp.ibv_resp), sizeof(resp)); + sizeof(qp->verbs_qp), attr, + &cmd_ex_rss.ibv_cmd, sizeof(cmd_ex_rss), + &resp.ibv_resp, sizeof(resp)); if (ret) return ret; @@ -1588,10 +1587,9 @@ static int mlx5_cmd_create_qp_ex(struct ibv_context *context, cmd_ex.drv_payload = cmd->drv_payload; ret = ibv_cmd_create_qp_ex2(context, &qp->verbs_qp, - sizeof(qp->verbs_qp), attr, - &cmd_ex.ibv_cmd, sizeof(cmd_ex.ibv_cmd), + sizeof(qp->verbs_qp), attr, &cmd_ex.ibv_cmd, sizeof(cmd_ex), &resp->ibv_resp, - sizeof(resp->ibv_resp), sizeof(*resp)); + sizeof(*resp)); return ret; } @@ -2154,11 +2152,8 @@ static int modify_dct(struct ibv_qp *qp, struct ibv_qp_attr *attr, bool dct_create; int ret; - ret = ibv_cmd_modify_qp_ex(qp, attr, attr_mask, - &cmd_ex, - sizeof(cmd_ex), sizeof(cmd_ex), - &resp.ibv_resp, - sizeof(resp.ibv_resp), sizeof(resp)); + ret = ibv_cmd_modify_qp_ex(qp, attr, attr_mask, &cmd_ex, sizeof(cmd_ex), + &resp.ibv_resp, sizeof(resp)); if (ret) return ret; @@ -2249,11 +2244,8 @@ int mlx5_modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr, } if (attr_mask & MLX5_MODIFY_QP_EX_ATTR_MASK) - ret = ibv_cmd_modify_qp_ex(qp, attr, attr_mask, - &cmd_ex, - sizeof(cmd_ex), sizeof(cmd_ex), - &resp, - sizeof(resp), sizeof(resp)); + ret = ibv_cmd_modify_qp_ex(qp, attr, attr_mask, &cmd_ex, + sizeof(cmd_ex), &resp, sizeof(resp)); else ret = ibv_cmd_modify_qp(qp, attr, attr_mask, &cmd, sizeof(cmd)); @@ -2320,10 +2312,8 @@ int mlx5_modify_qp_rate_limit(struct ibv_qp *qp, qp_attr.rate_limit = attr->rate_limit; ret = ibv_cmd_modify_qp_ex(qp, &qp_attr, IBV_QP_RATE_LIMIT, - &cmd.ibv_cmd, - sizeof(cmd.ibv_cmd), sizeof(cmd), - &resp, - sizeof(resp), sizeof(resp)); + &cmd.ibv_cmd, sizeof(cmd), &resp, + sizeof(resp)); return ret; } @@ -2816,11 +2806,10 @@ int mlx5_query_device_ex(struct ibv_context *context, memset(&cmd, 0, sizeof(cmd)); memset(&resp, 0, sizeof(resp)); - err = ibv_cmd_query_device_ex(context, input, attr, attr_size, - &raw_fw_ver, - &cmd.ibv_cmd, sizeof(cmd.ibv_cmd), sizeof(cmd), - &resp.ibv_resp, sizeof(resp.ibv_resp), - cmd_supp_uhw ? sizeof(resp) : sizeof(resp.ibv_resp)); + err = ibv_cmd_query_device_ex( + context, input, attr, attr_size, &raw_fw_ver, &cmd.ibv_cmd, + sizeof(cmd), &resp.ibv_resp, + cmd_supp_uhw ? sizeof(resp) : sizeof(resp.ibv_resp)); if (err) return err; @@ -3018,10 +3007,7 @@ static struct ibv_wq *create_wq(struct ibv_context *context, } err = ibv_cmd_create_wq(context, attr, &rwq->wq, &cmd.ibv_cmd, - sizeof(cmd.ibv_cmd), - sizeof(cmd), - &resp.ibv_resp, sizeof(resp.ibv_resp), - sizeof(resp)); + sizeof(cmd), &resp.ibv_resp, sizeof(resp)); if (err) goto err_create; @@ -3077,7 +3063,7 @@ int mlx5_modify_wq(struct ibv_wq *wq, struct ibv_wq_attr *attr) } } - return ibv_cmd_modify_wq(wq, attr, &cmd.ibv_cmd, sizeof(cmd.ibv_cmd), sizeof(cmd)); + return ibv_cmd_modify_wq(wq, attr, &cmd.ibv_cmd, sizeof(cmd)); } int mlx5_destroy_wq(struct ibv_wq *wq)