/*
- * Copyright (c) 2005-2006 Intel Corporation. All rights reserved.
+ * Copyright (c) 2005-2011 Intel Corporation. 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
* 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.
- *
- * $Id: cm.c 3453 2005-09-15 21:43:21Z sean.hefty $
*/
#if HAVE_CONFIG_H
#include <rdma/rdma_verbs.h>
#include <infiniband/ib.h>
-#define CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, type, size) \
-do { \
- struct ucma_abi_cmd_hdr *hdr; \
- \
- size = sizeof(*hdr) + sizeof(*cmd); \
- msg = alloca(size); \
- if (!msg) \
- return ERR(ENOMEM); \
- hdr = msg; \
- cmd = msg + sizeof(*hdr); \
- hdr->cmd = type; \
- hdr->in = sizeof(*cmd); \
- hdr->out = sizeof(*resp); \
- memset(cmd, 0, sizeof(*cmd)); \
- resp = alloca(sizeof(*resp)); \
- if (!resp) \
- return ERR(ENOMEM); \
- cmd->response = (uintptr_t)resp;\
+#define CMA_INIT_CMD(req, req_size, op) \
+do { \
+ memset(req, 0, req_size); \
+ (req)->cmd = UCMA_CMD_##op; \
+ (req)->in = req_size - sizeof(struct ucma_abi_cmd_hdr); \
} while (0)
-#define CMA_CREATE_MSG_CMD(msg, cmd, type, size) \
-do { \
- struct ucma_abi_cmd_hdr *hdr; \
- \
- size = sizeof(*hdr) + sizeof(*cmd); \
- msg = alloca(size); \
- if (!msg) \
- return ERR(ENOMEM); \
- hdr = msg; \
- cmd = msg + sizeof(*hdr); \
- hdr->cmd = type; \
- hdr->in = sizeof(*cmd); \
- hdr->out = 0; \
- memset(cmd, 0, sizeof(*cmd)); \
+#define CMA_INIT_CMD_RESP(req, req_size, op, resp, resp_size) \
+do { \
+ CMA_INIT_CMD(req, req_size, op); \
+ (req)->out = resp_size; \
+ (req)->response = (uintptr_t) (resp); \
} while (0)
struct cma_device {
struct rdma_cm_id **id, void *context,
enum rdma_port_space ps, enum ibv_qp_type qp_type)
{
- struct ucma_abi_create_id_resp *resp;
- struct ucma_abi_create_id *cmd;
+ struct ucma_abi_create_id_resp resp;
+ struct ucma_abi_create_id cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
ret = ucma_init();
if (ret)
if (!id_priv)
return ERR(ENOMEM);
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_CREATE_ID, size);
- cmd->uid = (uintptr_t) id_priv;
- cmd->ps = ps;
- cmd->qp_type = qp_type;
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, CREATE_ID, &resp, sizeof resp);
+ cmd.uid = (uintptr_t) id_priv;
+ cmd.ps = ps;
+ cmd.qp_type = qp_type;
- ret = write(id_priv->id.channel->fd, msg, size);
- if (ret != size)
+ ret = write(id_priv->id.channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
goto err;
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
- id_priv->handle = resp->id;
+ id_priv->handle = resp.id;
*id = &id_priv->id;
return 0;
static int ucma_destroy_kern_id(int fd, uint32_t handle)
{
- struct ucma_abi_destroy_id_resp *resp;
- struct ucma_abi_destroy_id *cmd;
- void *msg;
- int ret, size;
+ struct ucma_abi_destroy_id_resp resp;
+ struct ucma_abi_destroy_id cmd;
+ int ret;
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_DESTROY_ID, size);
- cmd->id = handle;
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, DESTROY_ID, &resp, sizeof resp);
+ cmd.id = handle;
- ret = write(fd, msg, size);
- if (ret != size)
+ ret = write(fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
- return resp->events_reported;
+ return resp.events_reported;
}
int rdma_destroy_id(struct rdma_cm_id *id)
static int ucma_query_addr(struct rdma_cm_id *id)
{
- struct ucma_abi_query_addr_resp *resp;
- struct ucma_abi_query *cmd;
+ struct ucma_abi_query_addr_resp resp;
+ struct ucma_abi_query cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_QUERY, size);
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, QUERY, &resp, sizeof resp);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- cmd->option = UCMA_QUERY_ADDR;
+ cmd.id = id_priv->handle;
+ cmd.option = UCMA_QUERY_ADDR;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
- memcpy(&id->route.addr.src_addr, &resp->src_addr, resp->src_size);
- memcpy(&id->route.addr.dst_addr, &resp->dst_addr, resp->dst_size);
+ memcpy(&id->route.addr.src_addr, &resp.src_addr, resp.src_size);
+ memcpy(&id->route.addr.dst_addr, &resp.dst_addr, resp.dst_size);
- if (!id_priv->cma_dev && resp->node_guid) {
- ret = ucma_get_device(id_priv, resp->node_guid);
+ if (!id_priv->cma_dev && resp.node_guid) {
+ ret = ucma_get_device(id_priv, resp.node_guid);
if (ret)
return ret;
- id->port_num = resp->port_num;
- id->route.addr.addr.ibaddr.pkey = resp->pkey;
+ id->port_num = resp.port_num;
+ id->route.addr.addr.ibaddr.pkey = resp.pkey;
}
return 0;
static int ucma_query_gid(struct rdma_cm_id *id)
{
- struct ucma_abi_query_addr_resp *resp;
- struct ucma_abi_query *cmd;
+ struct ucma_abi_query_addr_resp resp;
+ struct ucma_abi_query cmd;
struct cma_id_private *id_priv;
struct sockaddr_ib *sib;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_QUERY, size);
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, QUERY, &resp, sizeof resp);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- cmd->option = UCMA_QUERY_GID;
+ cmd.id = id_priv->handle;
+ cmd.option = UCMA_QUERY_GID;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
- sib = (struct sockaddr_ib *) &resp->src_addr;
+ sib = (struct sockaddr_ib *) &resp.src_addr;
memcpy(id->route.addr.addr.ibaddr.sgid.raw, sib->sib_addr.sib_raw,
sizeof id->route.addr.addr.ibaddr.sgid);
- sib = (struct sockaddr_ib *) &resp->dst_addr;
+ sib = (struct sockaddr_ib *) &resp.dst_addr;
memcpy(id->route.addr.addr.ibaddr.dgid.raw, sib->sib_addr.sib_raw,
sizeof id->route.addr.addr.ibaddr.dgid);
static int ucma_query_path(struct rdma_cm_id *id)
{
struct ucma_abi_query_path_resp *resp;
- struct ucma_abi_query *cmd;
- struct ucma_abi_cmd_hdr *hdr;
+ struct ucma_abi_query cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size, i;
-
- size = sizeof(*hdr) + sizeof(*cmd);
- msg = alloca(size);
- if (!msg)
- return ERR(ENOMEM);
-
- hdr = msg;
- cmd = msg + sizeof(*hdr);
-
- hdr->cmd = UCMA_CMD_QUERY;
- hdr->in = sizeof(*cmd);
- hdr->out = sizeof(*resp) + sizeof(struct ibv_path_data) * 6;
-
- memset(cmd, 0, sizeof(*cmd));
+ int ret, i, size;
- resp = alloca(hdr->out);
+ size = sizeof(*resp) + sizeof(struct ibv_path_data) * 6;
+ resp = alloca(size);
if (!resp)
return ERR(ENOMEM);
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, QUERY, resp, size);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->response = (uintptr_t) resp;
- cmd->id = id_priv->handle;
- cmd->option = UCMA_QUERY_PATH;
+ cmd.id = id_priv->handle;
+ cmd.option = UCMA_QUERY_PATH;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
- VALGRIND_MAKE_MEM_DEFINED(resp, hdr->out);
+ VALGRIND_MAKE_MEM_DEFINED(resp, size);
if (resp->num_paths) {
id->route.path_rec = malloc(sizeof(*id->route.path_rec) *
static int ucma_query_route(struct rdma_cm_id *id)
{
- struct ucma_abi_query_route_resp *resp;
- struct ucma_abi_query *cmd;
+ struct ucma_abi_query_route_resp resp;
+ struct ucma_abi_query cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size, i;
+ int ret, i;
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_QUERY_ROUTE, size);
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, QUERY_ROUTE, &resp, sizeof resp);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
+ cmd.id = id_priv->handle;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
- if (resp->num_paths) {
+ if (resp.num_paths) {
id->route.path_rec = malloc(sizeof *id->route.path_rec *
- resp->num_paths);
+ resp.num_paths);
if (!id->route.path_rec)
return ERR(ENOMEM);
- id->route.num_paths = resp->num_paths;
- for (i = 0; i < resp->num_paths; i++)
+ id->route.num_paths = resp.num_paths;
+ for (i = 0; i < resp.num_paths; i++)
ibv_copy_path_rec_from_kern(&id->route.path_rec[i],
- &resp->ib_route[i]);
+ &resp.ib_route[i]);
}
- memcpy(id->route.addr.addr.ibaddr.sgid.raw, resp->ib_route[0].sgid,
+ memcpy(id->route.addr.addr.ibaddr.sgid.raw, resp.ib_route[0].sgid,
sizeof id->route.addr.addr.ibaddr.sgid);
- memcpy(id->route.addr.addr.ibaddr.dgid.raw, resp->ib_route[0].dgid,
+ memcpy(id->route.addr.addr.ibaddr.dgid.raw, resp.ib_route[0].dgid,
sizeof id->route.addr.addr.ibaddr.dgid);
- id->route.addr.addr.ibaddr.pkey = resp->ib_route[0].pkey;
- memcpy(&id->route.addr.src_addr, &resp->src_addr,
- sizeof resp->src_addr);
- memcpy(&id->route.addr.dst_addr, &resp->dst_addr,
- sizeof resp->dst_addr);
-
- if (!id_priv->cma_dev && resp->node_guid) {
- ret = ucma_get_device(id_priv, resp->node_guid);
+ id->route.addr.addr.ibaddr.pkey = resp.ib_route[0].pkey;
+ memcpy(&id->route.addr.src_addr, &resp.src_addr,
+ sizeof resp.src_addr);
+ memcpy(&id->route.addr.dst_addr, &resp.dst_addr,
+ sizeof resp.dst_addr);
+
+ if (!id_priv->cma_dev && resp.node_guid) {
+ ret = ucma_get_device(id_priv, resp.node_guid);
if (ret)
return ret;
- id_priv->id.port_num = resp->port_num;
+ id_priv->id.port_num = resp.port_num;
}
return 0;
static int rdma_bind_addr2(struct rdma_cm_id *id, struct sockaddr *addr,
socklen_t addrlen)
{
- struct ucma_abi_bind *cmd;
+ struct ucma_abi_bind cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_BIND, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, BIND);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- cmd->addr_size = addrlen;
- cmd->reserved = 0;
- memcpy(&cmd->addr, addr, addrlen);
+ cmd.id = id_priv->handle;
+ cmd.addr_size = addrlen;
+ memcpy(&cmd.addr, addr, addrlen);
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
return ucma_query_addr(id);
int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr)
{
- struct ucma_abi_bind_ip *cmd;
+ struct ucma_abi_bind_ip cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size, addrlen;
+ int ret, addrlen;
addrlen = ucma_addrlen(addr);
if (!addrlen)
if (af_ib_support)
return rdma_bind_addr2(id, addr, addrlen);
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_BIND_IP, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, BIND_IP);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- memcpy(&cmd->addr, addr, addrlen);
+ cmd.id = id_priv->handle;
+ memcpy(&cmd.addr, addr, addrlen);
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
return ucma_query_route(id);
socklen_t src_len, struct sockaddr *dst_addr,
socklen_t dst_len, int timeout_ms)
{
- struct ucma_abi_resolve_addr *cmd;
+ struct ucma_abi_resolve_addr cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_RESOLVE_ADDR, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, RESOLVE_ADDR);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- if ((cmd->src_size = src_len))
- memcpy(&cmd->src_addr, src_addr, src_len);
- memcpy(&cmd->dst_addr, dst_addr, dst_len);
- cmd->dst_size = dst_len;
- cmd->timeout_ms = timeout_ms;
- cmd->reserved = 0;
-
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ cmd.id = id_priv->handle;
+ if ((cmd.src_size = src_len))
+ memcpy(&cmd.src_addr, src_addr, src_len);
+ memcpy(&cmd.dst_addr, dst_addr, dst_len);
+ cmd.dst_size = dst_len;
+ cmd.timeout_ms = timeout_ms;
+
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
memcpy(&id->route.addr.dst_addr, dst_addr, dst_len);
int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
struct sockaddr *dst_addr, int timeout_ms)
{
- struct ucma_abi_resolve_ip *cmd;
+ struct ucma_abi_resolve_ip cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size, dst_len, src_len;
+ int ret, dst_len, src_len;
dst_len = ucma_addrlen(dst_addr);
if (!dst_len)
return rdma_resolve_addr2(id, src_addr, src_len, dst_addr,
dst_len, timeout_ms);
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_RESOLVE_IP, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, RESOLVE_IP);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
+ cmd.id = id_priv->handle;
if (src_addr)
- memcpy(&cmd->src_addr, src_addr, src_len);
- memcpy(&cmd->dst_addr, dst_addr, dst_len);
- cmd->timeout_ms = timeout_ms;
+ memcpy(&cmd.src_addr, src_addr, src_len);
+ memcpy(&cmd.dst_addr, dst_addr, dst_len);
+ cmd.timeout_ms = timeout_ms;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
memcpy(&id->route.addr.dst_addr, dst_addr, dst_len);
int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms)
{
- struct ucma_abi_resolve_route *cmd;
+ struct ucma_abi_resolve_route cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
id_priv = container_of(id, struct cma_id_private, id);
if (id->verbs->device->transport_type == IBV_TRANSPORT_IB) {
goto out;
}
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_RESOLVE_ROUTE, size);
- cmd->id = id_priv->handle;
- cmd->timeout_ms = timeout_ms;
+ CMA_INIT_CMD(&cmd, sizeof cmd, RESOLVE_ROUTE);
+ cmd.id = id_priv->handle;
+ cmd.timeout_ms = timeout_ms;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
out:
static int rdma_init_qp_attr(struct rdma_cm_id *id, struct ibv_qp_attr *qp_attr,
int *qp_attr_mask)
{
- struct ucma_abi_init_qp_attr *cmd;
- struct ibv_kern_qp_attr *resp;
+ struct ucma_abi_init_qp_attr cmd;
+ struct ibv_kern_qp_attr resp;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_INIT_QP_ATTR, size);
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, INIT_QP_ATTR, &resp, sizeof resp);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- cmd->qp_state = qp_attr->qp_state;
+ cmd.id = id_priv->handle;
+ cmd.qp_state = qp_attr->qp_state;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
- ibv_copy_qp_attr_from_kern(qp_attr, resp);
- *qp_attr_mask = resp->qp_attr_mask;
+ ibv_copy_qp_attr_from_kern(qp_attr, &resp);
+ *qp_attr_mask = resp.qp_attr_mask;
return 0;
}
int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
{
- struct ucma_abi_connect *cmd;
+ struct ucma_abi_connect cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
id_priv = container_of(id, struct cma_id_private, id);
ret = ucma_valid_param(id_priv, conn_param);
else
id_priv->responder_resources = id_priv->cma_dev->max_responder_resources;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_CONNECT, size);
- cmd->id = id_priv->handle;
+ CMA_INIT_CMD(&cmd, sizeof cmd, CONNECT);
+ cmd.id = id_priv->handle;
if (id->qp) {
- ucma_copy_conn_param_to_kern(id_priv, &cmd->conn_param,
+ ucma_copy_conn_param_to_kern(id_priv, &cmd.conn_param,
conn_param, id->qp->qp_num,
(id->qp->srq != NULL));
} else if (conn_param) {
- ucma_copy_conn_param_to_kern(id_priv, &cmd->conn_param,
+ ucma_copy_conn_param_to_kern(id_priv, &cmd.conn_param,
conn_param, conn_param->qp_num,
conn_param->srq);
} else {
- ucma_copy_conn_param_to_kern(id_priv, &cmd->conn_param,
+ ucma_copy_conn_param_to_kern(id_priv, &cmd.conn_param,
conn_param, 0, 0);
}
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
if (id_priv->connect) {
int rdma_listen(struct rdma_cm_id *id, int backlog)
{
- struct ucma_abi_listen *cmd;
+ struct ucma_abi_listen cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_LISTEN, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, LISTEN);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- cmd->backlog = backlog;
+ cmd.id = id_priv->handle;
+ cmd.backlog = backlog;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
if (af_ib_support)
int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
{
- struct ucma_abi_accept *cmd;
+ struct ucma_abi_accept cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
id_priv = container_of(id, struct cma_id_private, id);
ret = ucma_valid_param(id_priv, conn_param);
return ret;
}
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_ACCEPT, size);
- cmd->id = id_priv->handle;
- cmd->uid = (uintptr_t) id_priv;
+ CMA_INIT_CMD(&cmd, sizeof cmd, ACCEPT);
+ cmd.id = id_priv->handle;
+ cmd.uid = (uintptr_t) id_priv;
if (id->qp)
- ucma_copy_conn_param_to_kern(id_priv, &cmd->conn_param,
+ ucma_copy_conn_param_to_kern(id_priv, &cmd.conn_param,
conn_param, id->qp->qp_num,
(id->qp->srq != NULL));
else
- ucma_copy_conn_param_to_kern(id_priv, &cmd->conn_param,
+ ucma_copy_conn_param_to_kern(id_priv, &cmd.conn_param,
conn_param, conn_param->qp_num,
conn_param->srq);
- ret = write(id->channel->fd, msg, size);
- if (ret != size) {
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd) {
ucma_modify_qp_err(id);
return (ret >= 0) ? ERR(ENODATA) : -1;
}
int rdma_reject(struct rdma_cm_id *id, const void *private_data,
uint8_t private_data_len)
{
- struct ucma_abi_reject *cmd;
+ struct ucma_abi_reject cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_REJECT, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, REJECT);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
+ cmd.id = id_priv->handle;
if (private_data && private_data_len) {
- memcpy(cmd->private_data, private_data, private_data_len);
- cmd->private_data_len = private_data_len;
- } else
- cmd->private_data_len = 0;
+ memcpy(cmd.private_data, private_data, private_data_len);
+ cmd.private_data_len = private_data_len;
+ }
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
return 0;
int rdma_notify(struct rdma_cm_id *id, enum ibv_event_type event)
{
- struct ucma_abi_notify *cmd;
+ struct ucma_abi_notify cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_NOTIFY, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, NOTIFY);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- cmd->event = event;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ cmd.id = id_priv->handle;
+ cmd.event = event;
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
return 0;
int rdma_disconnect(struct rdma_cm_id *id)
{
- struct ucma_abi_disconnect *cmd;
+ struct ucma_abi_disconnect cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
switch (id->verbs->device->transport_type) {
case IBV_TRANSPORT_IB:
if (ret)
return ret;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_DISCONNECT, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, DISCONNECT);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
+ cmd.id = id_priv->handle;
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
return ucma_complete(id_priv);
static int rdma_join_multicast2(struct rdma_cm_id *id, struct sockaddr *addr,
socklen_t addrlen, void *context)
{
- struct ucma_abi_create_id_resp *resp;
+ struct ucma_abi_create_id_resp resp;
struct cma_id_private *id_priv;
struct cma_multicast *mc, **pos;
- void *msg;
- int ret, size;
+ int ret;
id_priv = container_of(id, struct cma_id_private, id);
mc = calloc(1, sizeof *mc);
pthread_mutex_unlock(&id_priv->mut);
if (af_ib_support) {
- struct ucma_abi_join_mcast *cmd;
-
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_JOIN_MCAST, size);
- cmd->id = id_priv->handle;
- memcpy(&cmd->addr, addr, addrlen);
- cmd->addr_size = addrlen;
- cmd->uid = (uintptr_t) mc;
- cmd->reserved = 0;
+ struct ucma_abi_join_mcast cmd;
+
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, JOIN_MCAST, &resp, sizeof resp);
+ cmd.id = id_priv->handle;
+ memcpy(&cmd.addr, addr, addrlen);
+ cmd.addr_size = addrlen;
+ cmd.uid = (uintptr_t) mc;
+ cmd.reserved = 0;
+
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd) {
+ ret = (ret >= 0) ? ERR(ENODATA) : -1;
+ goto err2;
+ }
} else {
- struct ucma_abi_join_ip_mcast *cmd;
+ struct ucma_abi_join_ip_mcast cmd;
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_JOIN_IP_MCAST, size);
- cmd->id = id_priv->handle;
- memcpy(&cmd->addr, addr, addrlen);
- cmd->uid = (uintptr_t) mc;
- }
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, JOIN_IP_MCAST, &resp, sizeof resp);
+ cmd.id = id_priv->handle;
+ memcpy(&cmd.addr, addr, addrlen);
+ cmd.uid = (uintptr_t) mc;
- ret = write(id->channel->fd, msg, size);
- if (ret != size) {
- ret = (ret >= 0) ? ERR(ENODATA) : -1;
- goto err2;
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd) {
+ ret = (ret >= 0) ? ERR(ENODATA) : -1;
+ goto err2;
+ }
}
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
- mc->handle = resp->id;
+ mc->handle = resp.id;
return ucma_complete(id_priv);
err2:
int rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr)
{
- struct ucma_abi_destroy_id *cmd;
- struct ucma_abi_destroy_id_resp *resp;
+ struct ucma_abi_destroy_id cmd;
+ struct ucma_abi_destroy_id_resp resp;
struct cma_id_private *id_priv;
struct cma_multicast *mc, **pos;
- void *msg;
- int ret, size, addrlen;
+ int ret, addrlen;
addrlen = ucma_addrlen(addr);
if (!addrlen)
if (id->qp)
ibv_detach_mcast(id->qp, &mc->mgid, mc->mlid);
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_LEAVE_MCAST, size);
- cmd->id = mc->handle;
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, LEAVE_MCAST, &resp, sizeof resp);
+ cmd.id = mc->handle;
- ret = write(id->channel->fd, msg, size);
- if (ret != size) {
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd) {
ret = (ret >= 0) ? ERR(ENODATA) : -1;
goto free;
}
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
pthread_mutex_lock(&id_priv->mut);
- while (mc->events_completed < resp->events_reported)
+ while (mc->events_completed < resp.events_reported)
pthread_cond_wait(&mc->cond, &id_priv->mut);
pthread_mutex_unlock(&id_priv->mut);
static int ucma_process_conn_resp(struct cma_id_private *id_priv)
{
- struct ucma_abi_accept *cmd;
- void *msg;
- int ret, size;
+ struct ucma_abi_accept cmd;
+ int ret;
ret = ucma_modify_qp_rtr(&id_priv->id, RDMA_MAX_RESP_RES);
if (ret)
if (ret)
goto err;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_ACCEPT, size);
- cmd->id = id_priv->handle;
+ CMA_INIT_CMD(&cmd, sizeof cmd, ACCEPT);
+ cmd.id = id_priv->handle;
- ret = write(id_priv->id.channel->fd, msg, size);
- if (ret != size) {
+ ret = write(id_priv->id.channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd) {
ret = (ret >= 0) ? ERR(ENODATA) : -1;
goto err;
}
int rdma_get_cm_event(struct rdma_event_channel *channel,
struct rdma_cm_event **event)
{
- struct ucma_abi_event_resp *resp;
- struct ucma_abi_get_event *cmd;
+ struct ucma_abi_event_resp resp;
+ struct ucma_abi_get_event cmd;
struct cma_event *evt;
- void *msg;
- int ret, size;
+ int ret;
ret = ucma_init();
if (ret)
retry:
memset(evt, 0, sizeof *evt);
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_GET_EVENT, size);
- ret = write(channel->fd, msg, size);
- if (ret != size) {
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, GET_EVENT, &resp, sizeof resp);
+ ret = write(channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd) {
free(evt);
return (ret >= 0) ? ERR(ENODATA) : -1;
}
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
- evt->event.event = resp->event;
- evt->id_priv = (void *) (uintptr_t) resp->uid;
+ evt->event.event = resp.event;
+ evt->id_priv = (void *) (uintptr_t) resp.uid;
evt->event.id = &evt->id_priv->id;
- evt->event.status = resp->status;
+ evt->event.status = resp.status;
- switch (resp->event) {
+ switch (resp.event) {
case RDMA_CM_EVENT_ADDR_RESOLVED:
ucma_process_addr_resolved(evt);
break;
ucma_process_route_resolved(evt);
break;
case RDMA_CM_EVENT_CONNECT_REQUEST:
- evt->id_priv = (void *) (uintptr_t) resp->uid;
+ evt->id_priv = (void *) (uintptr_t) resp.uid;
if (ucma_is_ud_qp(evt->id_priv->id.qp_type))
- ucma_copy_ud_event(evt, &resp->param.ud);
+ ucma_copy_ud_event(evt, &resp.param.ud);
else
- ucma_copy_conn_event(evt, &resp->param.conn);
+ ucma_copy_conn_event(evt, &resp.param.conn);
- ret = ucma_process_conn_req(evt, resp->id);
+ ret = ucma_process_conn_req(evt, resp.id);
if (ret)
goto retry;
break;
case RDMA_CM_EVENT_CONNECT_RESPONSE:
- ucma_copy_conn_event(evt, &resp->param.conn);
+ ucma_copy_conn_event(evt, &resp.param.conn);
evt->event.status = ucma_process_conn_resp(evt->id_priv);
if (!evt->event.status)
evt->event.event = RDMA_CM_EVENT_ESTABLISHED;
break;
case RDMA_CM_EVENT_ESTABLISHED:
if (ucma_is_ud_qp(evt->id_priv->id.qp_type)) {
- ucma_copy_ud_event(evt, &resp->param.ud);
+ ucma_copy_ud_event(evt, &resp.param.ud);
break;
}
- ucma_copy_conn_event(evt, &resp->param.conn);
+ ucma_copy_conn_event(evt, &resp.param.conn);
break;
case RDMA_CM_EVENT_REJECTED:
if (evt->id_priv->connect_error) {
ucma_complete_event(evt->id_priv);
goto retry;
}
- ucma_copy_conn_event(evt, &resp->param.conn);
+ ucma_copy_conn_event(evt, &resp.param.conn);
ucma_modify_qp_err(evt->event.id);
break;
case RDMA_CM_EVENT_DISCONNECTED:
ucma_complete_event(evt->id_priv);
goto retry;
}
- ucma_copy_conn_event(evt, &resp->param.conn);
+ ucma_copy_conn_event(evt, &resp.param.conn);
break;
case RDMA_CM_EVENT_MULTICAST_JOIN:
- evt->mc = (void *) (uintptr_t) resp->uid;
+ evt->mc = (void *) (uintptr_t) resp.uid;
evt->id_priv = evt->mc->id_priv;
evt->event.id = &evt->id_priv->id;
- ucma_copy_ud_event(evt, &resp->param.ud);
+ ucma_copy_ud_event(evt, &resp.param.ud);
evt->event.param.ud.private_data = evt->mc->context;
evt->event.status = ucma_process_join(evt);
if (evt->event.status)
evt->event.event = RDMA_CM_EVENT_MULTICAST_ERROR;
break;
case RDMA_CM_EVENT_MULTICAST_ERROR:
- evt->mc = (void *) (uintptr_t) resp->uid;
+ evt->mc = (void *) (uintptr_t) resp.uid;
evt->id_priv = evt->mc->id_priv;
evt->event.id = &evt->id_priv->id;
evt->event.param.ud.private_data = evt->mc->context;
break;
default:
- evt->id_priv = (void *) (uintptr_t) resp->uid;
+ evt->id_priv = (void *) (uintptr_t) resp.uid;
evt->event.id = &evt->id_priv->id;
- evt->event.status = resp->status;
+ evt->event.status = resp.status;
if (ucma_is_ud_qp(evt->id_priv->id.qp_type))
- ucma_copy_ud_event(evt, &resp->param.ud);
+ ucma_copy_ud_event(evt, &resp.param.ud);
else
- ucma_copy_conn_event(evt, &resp->param.conn);
+ ucma_copy_conn_event(evt, &resp.param.conn);
break;
}
int rdma_set_option(struct rdma_cm_id *id, int level, int optname,
void *optval, size_t optlen)
{
- struct ucma_abi_set_option *cmd;
+ struct ucma_abi_set_option cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size;
+ int ret;
- CMA_CREATE_MSG_CMD(msg, cmd, UCMA_CMD_SET_OPTION, size);
+ CMA_INIT_CMD(&cmd, sizeof cmd, SET_OPTION);
id_priv = container_of(id, struct cma_id_private, id);
- cmd->id = id_priv->handle;
- cmd->optval = (uintptr_t) optval;
- cmd->level = level;
- cmd->optname = optname;
- cmd->optlen = optlen;
-
- ret = write(id->channel->fd, msg, size);
- if (ret != size)
+ cmd.id = id_priv->handle;
+ cmd.optval = (uintptr_t) optval;
+ cmd.level = level;
+ cmd.optname = optname;
+ cmd.optlen = optlen;
+
+ ret = write(id->channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
return 0;
int rdma_migrate_id(struct rdma_cm_id *id, struct rdma_event_channel *channel)
{
- struct ucma_abi_migrate_resp *resp;
- struct ucma_abi_migrate_id *cmd;
+ struct ucma_abi_migrate_resp resp;
+ struct ucma_abi_migrate_id cmd;
struct cma_id_private *id_priv;
- void *msg;
- int ret, size, sync;
+ int ret, sync;
id_priv = container_of(id, struct cma_id_private, id);
if (id_priv->sync && !channel)
return -1;
}
- CMA_CREATE_MSG_CMD_RESP(msg, cmd, resp, UCMA_CMD_MIGRATE_ID, size);
- cmd->id = id_priv->handle;
- cmd->fd = id->channel->fd;
+ CMA_INIT_CMD_RESP(&cmd, sizeof cmd, MIGRATE_ID, &resp, sizeof resp);
+ cmd.id = id_priv->handle;
+ cmd.fd = id->channel->fd;
- ret = write(channel->fd, msg, size);
- if (ret != size)
+ ret = write(channel->fd, &cmd, sizeof cmd);
+ if (ret != sizeof cmd)
return (ret >= 0) ? ERR(ENODATA) : -1;
- VALGRIND_MAKE_MEM_DEFINED(resp, sizeof *resp);
+ VALGRIND_MAKE_MEM_DEFINED(&resp, sizeof resp);
if (id_priv->sync) {
if (id->event) {
pthread_mutex_lock(&id_priv->mut);
id_priv->sync = sync;
id->channel = channel;
- while (id_priv->events_completed < resp->events_reported)
+ while (id_priv->events_completed < resp.events_reported)
pthread_cond_wait(&id_priv->cond, &id_priv->mut);
pthread_mutex_unlock(&id_priv->mut);