[openib-general] [RFC] [PATCH 2/7] ibrdmaverbs src files

Krishna Kumar krkumar2 at in.ibm.com
Mon Jul 10 03:22:25 PDT 2006


This library provides equivalent functionality to
libibverbs, but changes the data types and verb
API's to be transport neutral. This patch contains
the source files.

Signed-of-by: Krishna Kumar <krkumar2 at in.ibm.com>

diff -ruNp ORG/librdmaverbs/src/cmd.c NEW/librdmaverbs/src/cmd.c
--- ORG/librdmaverbs/src/cmd.c	1969-12-31 16:00:00.000000000 -0800
+++ NEW/librdmaverbs/src/cmd.c	2006-07-10 18:07:47.000000000 -0700
@@ -0,0 +1,1060 @@
+/*
+ * Copyright (c) 2005 Topspin Communications.  All rights reserved.
+ * Copyright (c) 2005 PathScale, Inc.  All rights reserved.
+ * Copyright (c) 2006 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.
+ *
+ * $Id: cmd.c 7631 2006-06-02 19:53:25Z swise $
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <alloca.h>
+#include <string.h>
+
+#include "rdmaverbs.h"
+
+static int rdma_cmd_get_context_v2(struct rdma_context *context,
+				  struct rdma_get_context *new_cmd,
+				  size_t new_cmd_size,
+				  struct rdma_get_context_resp *resp,
+				  size_t resp_size)
+{
+	struct rdma_abi_compat_v2 *t;
+	struct rdma_get_context_v2 *cmd;
+	size_t cmd_size;
+	uint32_t cq_fd;
+
+	t = malloc(sizeof *t);
+	if (!t)
+		return ENOMEM;
+	pthread_mutex_init(&t->in_use, NULL);
+
+	cmd_size = sizeof *cmd + new_cmd_size - sizeof *new_cmd;
+	cmd      = alloca(cmd_size);
+	memcpy(cmd->driver_data, new_cmd->driver_data, new_cmd_size - sizeof
*new_cmd);
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, GET_CONTEXT, resp, resp_size);
+	cmd->cq_fd_tab = (uintptr_t) &cq_fd;
+
+	if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	context->async_fd         = resp->async_fd;
+	context->num_comp_vectors = 1;
+	t->channel.fd		  = cq_fd;
+	context->abi_compat       = t;
+
+	return 0;
+}
+
+int rdma_cmd_get_context(struct rdma_context *context, struct
rdma_get_context *cmd,
+			size_t cmd_size, struct rdma_get_context_resp *resp,
+			size_t resp_size)
+{
+	if (abi_ver <= 2)
+		return rdma_cmd_get_context_v2(context, cmd, cmd_size, resp,
resp_size);
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, GET_CONTEXT, resp, resp_size);
+
+	if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	context->async_fd         = resp->async_fd;
+	context->num_comp_vectors = resp->num_comp_vectors;
+
+	return 0;
+}
+
+int rdma_cmd_query_device(struct rdma_context *context,
+			 struct rdma_device_attr *device_attr,
+			 uint64_t *raw_fw_ver,
+			 struct rdma_query_device *cmd, size_t cmd_size)
+{
+	struct rdma_query_device_resp resp;
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, QUERY_DEVICE, &resp, sizeof resp);
+
+	if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	memset(device_attr->fw_ver, 0, sizeof device_attr->fw_ver);
+	*raw_fw_ver			       = resp.fw_ver;
+	device_attr->node_guid 		       = resp.node_guid;
+	device_attr->sys_image_guid 	       = resp.sys_image_guid;
+	device_attr->max_mr_size 	       = resp.max_mr_size;
+	device_attr->page_size_cap 	       = resp.page_size_cap;
+	device_attr->vendor_id 		       = resp.vendor_id;
+	device_attr->vendor_part_id 	       = resp.vendor_part_id;
+	device_attr->hw_ver 		       = resp.hw_ver;
+	device_attr->max_qp 		       = resp.max_qp;
+	device_attr->max_qp_wr 		       = resp.max_qp_wr;
+	device_attr->device_cap_flags 	       = resp.device_cap_flags;
+	device_attr->max_sge 		       = resp.max_sge;
+	device_attr->max_sge_rd 	       = resp.max_sge_rd;
+	device_attr->max_cq 		       = resp.max_cq;
+	device_attr->max_cqe 		       = resp.max_cqe;
+	device_attr->max_mr 		       = resp.max_mr;
+	device_attr->max_pd 		       = resp.max_pd;
+	device_attr->max_qp_rd_atom 	       = resp.max_qp_rd_atom;
+	device_attr->max_ee_rd_atom 	       = resp.max_ee_rd_atom;
+	device_attr->max_res_rd_atom 	       = resp.max_res_rd_atom;
+	device_attr->max_qp_init_rd_atom       = resp.max_qp_init_rd_atom;
+	device_attr->max_ee_init_rd_atom       = resp.max_ee_init_rd_atom;
+	device_attr->atomic_cap 	       = resp.atomic_cap;
+	device_attr->max_ee 		       = resp.max_ee;
+	device_attr->max_rdd 		       = resp.max_rdd;
+	device_attr->max_mw 		       = resp.max_mw;
+	device_attr->max_raw_ipv6_qp 	       = resp.max_raw_ipv6_qp;
+	device_attr->max_raw_ethy_qp 	       = resp.max_raw_ethy_qp;
+	device_attr->max_mcast_grp 	       = resp.max_mcast_grp;
+	device_attr->max_mcast_qp_attach       = resp.max_mcast_qp_attach;
+	device_attr->max_total_mcast_qp_attach =
resp.max_total_mcast_qp_attach;
+	device_attr->max_ah 		       = resp.max_ah;
+	device_attr->max_fmr 		       = resp.max_fmr;
+	device_attr->max_map_per_fmr 	       = resp.max_map_per_fmr;
+	device_attr->max_srq 		       = resp.max_srq;
+	device_attr->max_srq_wr 	       = resp.max_srq_wr;
+	device_attr->max_srq_sge 	       = resp.max_srq_sge;
+	device_attr->max_pkeys 		       = resp.max_pkeys;
+	device_attr->local_ca_ack_delay        = resp.local_ca_ack_delay;
+	device_attr->phys_port_cnt	       = resp.phys_port_cnt;
+
+	return 0;
+}
+
+int rdma_cmd_query_port(struct rdma_context *context, uint8_t port_num,
+		       struct rdma_port_attr *port_attr,
+		       struct rdma_query_port *cmd, size_t cmd_size)
+{
+	struct rdma_query_port_resp resp;
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, QUERY_PORT, &resp, sizeof resp);
+	cmd->port_num = port_num;
+
+	if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	port_attr->state      	   = resp.state;
+	port_attr->max_mtu         = resp.max_mtu;
+	port_attr->active_mtu      = resp.active_mtu;
+	port_attr->gid_tbl_len     = resp.gid_tbl_len;
+	port_attr->port_cap_flags  = resp.port_cap_flags;
+	port_attr->max_msg_sz      = resp.max_msg_sz;
+	port_attr->bad_pkey_cntr   = resp.bad_pkey_cntr;
+	port_attr->qkey_viol_cntr  = resp.qkey_viol_cntr;
+	port_attr->pkey_tbl_len    = resp.pkey_tbl_len;
+	port_attr->lid 	      	   = resp.lid;
+	port_attr->sm_lid 	   = resp.sm_lid;
+	port_attr->lmc 	      	   = resp.lmc;
+	port_attr->max_vl_num      = resp.max_vl_num;
+	port_attr->sm_sl      	   = resp.sm_sl;
+	port_attr->subnet_timeout  = resp.subnet_timeout;
+	port_attr->init_type_reply = resp.init_type_reply;
+	port_attr->active_width    = resp.active_width;
+	port_attr->active_speed    = resp.active_speed;
+	port_attr->phys_state      = resp.phys_state;
+
+	return 0;
+}
+
+int rdma_cmd_alloc_pd(struct rdma_context *context, struct rdma_pd *pd,
+		     struct rdma_alloc_pd *cmd, size_t cmd_size,
+		     struct rdma_alloc_pd_resp *resp, size_t resp_size)
+{
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, ALLOC_PD, resp, resp_size);
+
+	if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	pd->handle = resp->pd_handle;
+
+	return 0;
+}
+
+int rdma_cmd_dealloc_pd(struct rdma_pd *pd)
+{
+	struct rdma_dealloc_pd cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, DEALLOC_PD);
+	cmd.pd_handle = pd->handle;
+
+	if (write(pd->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_reg_mr(struct rdma_pd *pd, void *addr, size_t length,
+		   uint64_t hca_va, enum rdma_access_flags access,
+		   struct rdma_mr *mr, struct rdma_reg_mr *cmd,
+		   size_t cmd_size)
+{
+	struct rdma_reg_mr_resp resp;
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, REG_MR, &resp, sizeof resp);
+
+	cmd->start 	  = (uintptr_t) addr;
+	cmd->length 	  = length;
+	cmd->hca_va 	  = hca_va;
+	cmd->pd_handle 	  = pd->handle;
+	cmd->access_flags = access;
+
+	if (write(pd->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	mr->handle  = resp.mr_handle;
+	mr->lkey    = resp.lkey;
+	mr->rkey    = resp.rkey;
+
+	return 0;
+}
+
+int rdma_cmd_dereg_mr(struct rdma_mr *mr)
+{
+	struct rdma_dereg_mr cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, DEREG_MR);
+	cmd.mr_handle = mr->handle;
+
+	if (write(mr->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
+
+static int rdma_cmd_create_cq_v2(struct rdma_context *context, int cqe,
+				struct rdma_cq *cq,
+				struct rdma_create_cq *new_cmd, size_t new_cmd_size,
+				struct rdma_create_cq_resp *resp, size_t resp_size)
+{
+	struct rdma_create_cq_v2 *cmd;
+	size_t cmd_size;
+
+	cmd_size = sizeof *cmd + new_cmd_size - sizeof *new_cmd;
+	cmd      = alloca(cmd_size);
+	memcpy(cmd->driver_data, new_cmd->driver_data, new_cmd_size - sizeof
*new_cmd);
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, CREATE_CQ, resp, resp_size);
+	cmd->user_handle   = (uintptr_t) cq;
+	cmd->cqe           = cqe;
+	cmd->event_handler = 0;
+
+	if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	cq->handle = resp->cq_handle;
+	cq->cqe    = resp->cqe;
+
+	return 0;
+}
+
+int rdma_cmd_create_cq(struct rdma_context *context, int cqe,
+		      struct rdma_comp_channel *channel,
+		      int comp_vector, struct rdma_cq *cq,
+		      struct rdma_create_cq *cmd, size_t cmd_size,
+		      struct rdma_create_cq_resp *resp, size_t resp_size)
+{
+	if (abi_ver <= 2)
+		return rdma_cmd_create_cq_v2(context, cqe, cq,
+					    cmd, cmd_size, resp, resp_size);
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, CREATE_CQ, resp, resp_size);
+	cmd->user_handle   = (uintptr_t) cq;
+	cmd->cqe           = cqe;
+	cmd->comp_vector   = comp_vector;
+	cmd->comp_channel  = channel ? channel->fd : -1;
+	cmd->reserved      = 0;
+
+	if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	cq->handle = resp->cq_handle;
+	cq->cqe    = resp->cqe;
+
+	return 0;
+}
+
+int rdma_cmd_poll_cq(struct rdma_cq *ibcq, int ne, struct rdma_wc *wc)
+{
+	struct rdma_poll_cq       cmd;
+	struct rdma_poll_cq_resp *resp;
+	int                      i;
+	int                      rsize;
+	int                      ret;
+
+	rsize = sizeof *resp + ne * sizeof(struct rdma_kern_wc);
+	resp  = malloc(rsize);
+	if (!resp)
+		return -1;
+
+	RDMA_INIT_CMD_RESP(&cmd, sizeof cmd, POLL_CQ, resp, rsize);
+	cmd.cq_handle = ibcq->handle;
+	cmd.ne        = ne;
+
+	if (write(ibcq->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd) {
+		ret = -1;
+		goto out;
+	}
+
+	for (i = 0; i < resp->count; i++) {
+		wc[i].wr_id 	     = resp->wc[i].wr_id;
+		wc[i].status 	     = resp->wc[i].status;
+		wc[i].opcode 	     = resp->wc[i].opcode;
+		wc[i].vendor_err     = resp->wc[i].vendor_err;
+		wc[i].byte_len 	     = resp->wc[i].byte_len;
+		wc[i].imm_data 	     = resp->wc[i].imm_data;
+		wc[i].qp_num 	     = resp->wc[i].qp_num;
+		wc[i].src_qp 	     = resp->wc[i].src_qp;
+		wc[i].wc_flags 	     = resp->wc[i].wc_flags;
+		wc[i].pkey_index     = resp->wc[i].pkey_index;
+		wc[i].slid 	     = resp->wc[i].slid;
+		wc[i].sl 	     = resp->wc[i].sl;
+		wc[i].dlid_path_bits = resp->wc[i].dlid_path_bits;
+	}
+
+	ret = resp->count;
+
+out:
+	free(resp);
+	return ret;
+}
+
+int rdma_cmd_req_notify_cq(struct rdma_cq *ibcq, int solicited_only)
+{
+	struct rdma_req_notify_cq cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, REQ_NOTIFY_CQ);
+	cmd.cq_handle = ibcq->handle;
+	cmd.solicited = !!solicited_only;
+
+	if (write(ibcq->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_resize_cq(struct rdma_cq *cq, int cqe,
+		      struct rdma_resize_cq *cmd, size_t cmd_size)
+{
+	struct rdma_resize_cq_resp resp;
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, RESIZE_CQ, &resp, sizeof resp);
+	cmd->cq_handle = cq->handle;
+	cmd->cqe       = cqe;
+
+	if (write(cq->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	cq->cqe = resp.cqe;
+
+	return 0;
+}
+
+static int rdma_cmd_destroy_cq_v1(struct rdma_cq *cq)
+{
+	struct rdma_destroy_cq_v1 cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, DESTROY_CQ);
+	cmd.cq_handle = cq->handle;
+
+	if (write(cq->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_destroy_cq(struct rdma_cq *cq)
+{
+	struct rdma_destroy_cq      cmd;
+	struct rdma_destroy_cq_resp resp;
+
+	if (abi_ver == 1)
+		return rdma_cmd_destroy_cq_v1(cq);
+
+	RDMA_INIT_CMD_RESP(&cmd, sizeof cmd, DESTROY_CQ, &resp, sizeof resp);
+	cmd.cq_handle = cq->handle;
+
+	if (write(cq->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	pthread_mutex_lock(&cq->mutex);
+	while (cq->comp_events_completed  != resp.comp_events_reported ||
+	       cq->async_events_completed != resp.async_events_reported)
+		pthread_cond_wait(&cq->cond, &cq->mutex);
+	pthread_mutex_unlock(&cq->mutex);
+
+	return 0;
+}
+
+int rdma_cmd_create_srq(struct rdma_pd *pd,
+		       struct rdma_srq *srq, struct rdma_srq_init_attr *attr,
+		       struct rdma_create_srq *cmd, size_t cmd_size,
+		       struct rdma_create_srq_resp *resp, size_t resp_size)
+{
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, CREATE_SRQ, resp, resp_size);
+	cmd->user_handle = (uintptr_t) srq;
+	cmd->pd_handle 	 = pd->handle;
+	cmd->max_wr      = attr->attr.max_wr;
+	cmd->max_sge     = attr->attr.max_sge;
+	cmd->srq_limit   = attr->attr.srq_limit;
+
+	if (write(pd->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	srq->handle = resp->srq_handle;
+
+	if (abi_ver > 5) {
+		attr->attr.max_wr = resp->max_wr;
+		attr->attr.max_sge = resp->max_sge;
+	} else {
+		struct rdma_create_srq_resp_v5 *resp_v5 =
+			(struct rdma_create_srq_resp_v5 *) resp;
+
+		memmove((void *) resp + sizeof *resp,
+			(void *) resp_v5 + sizeof *resp_v5,
+			resp_size - sizeof *resp);
+	}
+
+	return 0;
+}
+
+static int rdma_cmd_modify_srq_v3(struct rdma_srq *srq,
+				 struct rdma_srq_attr *srq_attr,
+				 enum rdma_srq_attr_mask srq_attr_mask,
+				 struct rdma_modify_srq *new_cmd,
+				 size_t new_cmd_size)
+{
+	struct rdma_modify_srq_v3 *cmd;
+	size_t cmd_size;
+
+	cmd_size = sizeof *cmd + new_cmd_size - sizeof *new_cmd;
+	cmd      = alloca(cmd_size);
+	memcpy(cmd->driver_data, new_cmd->driver_data, new_cmd_size - sizeof
*new_cmd);
+
+	RDMA_INIT_CMD(cmd, cmd_size, MODIFY_SRQ);
+
+	cmd->srq_handle	= srq->handle;
+	cmd->attr_mask	= srq_attr_mask;
+	cmd->max_wr	= srq_attr->max_wr;
+	cmd->srq_limit	= srq_attr->srq_limit;
+	cmd->max_sge	= 0;
+	cmd->reserved	= 0;
+
+	if (write(srq->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_modify_srq(struct rdma_srq *srq,
+		       struct rdma_srq_attr *srq_attr,
+		       enum rdma_srq_attr_mask srq_attr_mask,
+		       struct rdma_modify_srq *cmd, size_t cmd_size)
+{
+	if (abi_ver == 3)
+		return rdma_cmd_modify_srq_v3(srq, srq_attr, srq_attr_mask,
+					     cmd, cmd_size);
+
+	RDMA_INIT_CMD(cmd, cmd_size, MODIFY_SRQ);
+
+	cmd->srq_handle	= srq->handle;
+	cmd->attr_mask	= srq_attr_mask;
+	cmd->max_wr	= srq_attr->max_wr;
+	cmd->srq_limit	= srq_attr->srq_limit;
+
+	if (write(srq->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_query_srq(struct rdma_srq *srq, struct rdma_srq_attr
*srq_attr,
+		      struct rdma_query_srq *cmd, size_t cmd_size)
+{
+	struct rdma_query_srq_resp resp;
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, QUERY_SRQ, &resp, sizeof resp);
+	cmd->srq_handle = srq->handle;
+
+	if (write(srq->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	srq_attr->max_wr    = resp.max_wr;
+	srq_attr->max_sge   = resp.max_sge;
+	srq_attr->srq_limit = resp.srq_limit;
+
+	return 0;
+}
+
+static int rdma_cmd_destroy_srq_v1(struct rdma_srq *srq)
+{
+	struct rdma_destroy_srq_v1 cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, DESTROY_SRQ);
+	cmd.srq_handle = srq->handle;
+
+	if (write(srq->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_destroy_srq(struct rdma_srq *srq)
+{
+	struct rdma_destroy_srq      cmd;
+	struct rdma_destroy_srq_resp resp;
+
+	if (abi_ver == 1)
+		return rdma_cmd_destroy_srq_v1(srq);
+
+	RDMA_INIT_CMD_RESP(&cmd, sizeof cmd, DESTROY_SRQ, &resp, sizeof resp);
+	cmd.srq_handle = srq->handle;
+
+	if (write(srq->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	pthread_mutex_lock(&srq->mutex);
+	while (srq->events_completed != resp.events_reported)
+		pthread_cond_wait(&srq->cond, &srq->mutex);
+	pthread_mutex_unlock(&srq->mutex);
+
+	return 0;
+}
+
+int rdma_cmd_create_qp(struct rdma_pd *pd,
+		      struct rdma_qp *qp, struct rdma_qp_init_attr *attr,
+		      struct rdma_create_qp *cmd, size_t cmd_size,
+		      struct rdma_create_qp_resp *resp, size_t resp_size)
+{
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, CREATE_QP, resp, resp_size);
+
+	cmd->user_handle     = (uintptr_t) qp;
+	cmd->pd_handle 	     = pd->handle;
+	cmd->send_cq_handle  = attr->send_cq->handle;
+	cmd->recv_cq_handle  = attr->recv_cq->handle;
+	cmd->srq_handle      = attr->srq ? attr->srq->handle : 0;
+	cmd->max_send_wr     = attr->cap.max_send_wr;
+	cmd->max_recv_wr     = attr->cap.max_recv_wr;
+	cmd->max_send_sge    = attr->cap.max_send_sge;
+	cmd->max_recv_sge    = attr->cap.max_recv_sge;
+	cmd->max_inline_data = attr->cap.max_inline_data;
+	cmd->sq_sig_all	     = attr->sq_sig_all;
+	cmd->qp_type 	     = attr->qp_type;
+	cmd->is_srq 	     = !!attr->srq;
+
+	if (write(pd->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	qp->handle 		  = resp->qp_handle;
+	qp->qp_num 		  = resp->qpn;
+
+	if (abi_ver > 3) {
+		attr->cap.max_recv_sge    = resp->max_recv_sge;
+		attr->cap.max_send_sge    = resp->max_send_sge;
+		attr->cap.max_recv_wr     = resp->max_recv_wr;
+		attr->cap.max_send_wr     = resp->max_send_wr;
+		attr->cap.max_inline_data = resp->max_inline_data;
+	}
+
+	if (abi_ver == 4) {
+		struct rdma_create_qp_resp_v4 *resp_v4 =
+			(struct rdma_create_qp_resp_v4 *) resp;
+
+		memmove((void *) resp + sizeof *resp,
+			(void *) resp_v4 + sizeof *resp_v4,
+			resp_size - sizeof *resp);
+	} else if (abi_ver <= 3) {
+		struct rdma_create_qp_resp_v3 *resp_v3 =
+			(struct rdma_create_qp_resp_v3 *) resp;
+
+		memmove((void *) resp + sizeof *resp,
+			(void *) resp_v3 + sizeof *resp_v3,
+			resp_size - sizeof *resp);
+	}
+
+	return 0;
+}
+
+int rdma_cmd_query_qp(struct rdma_qp *qp, struct rdma_qp_attr *attr,
+		     enum rdma_qp_attr_mask attr_mask,
+		     struct rdma_qp_init_attr *init_attr,
+		     struct rdma_query_qp *cmd, size_t cmd_size)
+{
+	struct rdma_query_qp_resp resp;
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, QUERY_QP, &resp, sizeof resp);
+	cmd->qp_handle = qp->handle;
+	cmd->attr_mask = attr_mask;
+
+	if (write(qp->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	attr->qkey                          = resp.qkey;
+	attr->rq_psn                        = resp.rq_psn;
+	attr->sq_psn                        = resp.sq_psn;
+	attr->dest_qp_num                   = resp.dest_qp_num;
+	attr->qp_access_flags               = resp.qp_access_flags;
+	attr->pkey_index                    = resp.pkey_index;
+	attr->alt_pkey_index                = resp.alt_pkey_index;
+	attr->qp_state                      = resp.qp_state;
+	attr->cur_qp_state                  = resp.cur_qp_state;
+	attr->path_mtu                      = resp.path_mtu;
+	attr->path_mig_state                = resp.path_mig_state;
+	attr->en_sqd_async_notify           = resp.en_sqd_async_notify;
+	attr->max_rd_atomic                 = resp.max_rd_atomic;
+	attr->max_dest_rd_atomic            = resp.max_dest_rd_atomic;
+	attr->min_rnr_timer                 = resp.min_rnr_timer;
+	attr->port_num                      = resp.port_num;
+	attr->timeout                       = resp.timeout;
+	attr->retry_cnt                     = resp.retry_cnt;
+	attr->rnr_retry                     = resp.rnr_retry;
+	attr->alt_port_num                  = resp.alt_port_num;
+	attr->alt_timeout                   = resp.alt_timeout;
+	attr->cap.max_send_wr               = resp.max_send_wr;
+	attr->cap.max_recv_wr               = resp.max_recv_wr;
+	attr->cap.max_send_sge              = resp.max_send_sge;
+	attr->cap.max_recv_sge              = resp.max_recv_sge;
+	attr->cap.max_inline_data           = resp.max_inline_data;
+
+	memcpy(attr->ah_attr.grh.dgid.raw, resp.dest.dgid, 16);
+	attr->ah_attr.grh.flow_label        = resp.dest.flow_label;
+	attr->ah_attr.dlid                  = resp.dest.dlid;
+	attr->ah_attr.grh.sgid_index        = resp.dest.sgid_index;
+	attr->ah_attr.grh.hop_limit         = resp.dest.hop_limit;
+	attr->ah_attr.grh.traffic_class     = resp.dest.traffic_class;
+	attr->ah_attr.sl                    = resp.dest.sl;
+	attr->ah_attr.src_path_bits         = resp.dest.src_path_bits;
+	attr->ah_attr.static_rate           = resp.dest.static_rate;
+	attr->ah_attr.is_global             = resp.dest.is_global;
+	attr->ah_attr.port_num              = resp.dest.port_num;
+
+	memcpy(attr->alt_ah_attr.grh.dgid.raw, resp.alt_dest.dgid, 16);
+	attr->alt_ah_attr.grh.flow_label    = resp.alt_dest.flow_label;
+	attr->alt_ah_attr.dlid              = resp.alt_dest.dlid;
+	attr->alt_ah_attr.grh.sgid_index    = resp.alt_dest.sgid_index;
+	attr->alt_ah_attr.grh.hop_limit     = resp.alt_dest.hop_limit;
+	attr->alt_ah_attr.grh.traffic_class = resp.alt_dest.traffic_class;
+	attr->alt_ah_attr.sl                = resp.alt_dest.sl;
+	attr->alt_ah_attr.src_path_bits     = resp.alt_dest.src_path_bits;
+	attr->alt_ah_attr.static_rate       = resp.alt_dest.static_rate;
+	attr->alt_ah_attr.is_global         = resp.alt_dest.is_global;
+	attr->alt_ah_attr.port_num          = resp.alt_dest.port_num;
+
+	init_attr->qp_context               = qp->qp_context;
+	init_attr->send_cq                  = qp->send_cq;
+	init_attr->recv_cq                  = qp->recv_cq;
+	init_attr->srq                      = qp->srq;
+	init_attr->qp_type                  = qp->qp_type;
+	init_attr->cap.max_send_wr          = resp.max_send_wr;
+	init_attr->cap.max_recv_wr          = resp.max_recv_wr;
+	init_attr->cap.max_send_sge         = resp.max_send_sge;
+	init_attr->cap.max_recv_sge         = resp.max_recv_sge;
+	init_attr->cap.max_inline_data      = resp.max_inline_data;
+	init_attr->sq_sig_all               = resp.sq_sig_all;
+
+	return 0;
+}
+
+int rdma_cmd_modify_qp(struct rdma_qp *qp, struct rdma_qp_attr *attr,
+		      enum rdma_qp_attr_mask attr_mask,
+		      struct rdma_modify_qp *cmd, size_t cmd_size)
+{
+	RDMA_INIT_CMD(cmd, cmd_size, MODIFY_QP);
+
+	cmd->qp_handle 		 = qp->handle;
+	cmd->attr_mask 		 = attr_mask;
+	cmd->qkey 		 = attr->qkey;
+	cmd->rq_psn 		 = attr->rq_psn;
+	cmd->sq_psn 		 = attr->sq_psn;
+	cmd->dest_qp_num 	 = attr->dest_qp_num;
+	cmd->qp_access_flags 	 = attr->qp_access_flags;
+	cmd->pkey_index		 = attr->pkey_index;
+	cmd->alt_pkey_index 	 = attr->alt_pkey_index;
+	cmd->qp_state 		 = attr->qp_state;
+	cmd->cur_qp_state 	 = attr->cur_qp_state;
+	cmd->path_mtu 		 = attr->path_mtu;
+	cmd->path_mig_state 	 = attr->path_mig_state;
+	cmd->en_sqd_async_notify = attr->en_sqd_async_notify;
+	cmd->max_rd_atomic 	 = attr->max_rd_atomic;
+	cmd->max_dest_rd_atomic  = attr->max_dest_rd_atomic;
+	cmd->min_rnr_timer 	 = attr->min_rnr_timer;
+	cmd->port_num 		 = attr->port_num;
+	cmd->timeout 		 = attr->timeout;
+	cmd->retry_cnt 		 = attr->retry_cnt;
+	cmd->rnr_retry 		 = attr->rnr_retry;
+	cmd->alt_port_num 	 = attr->alt_port_num;
+	cmd->alt_timeout 	 = attr->alt_timeout;
+
+	memcpy(cmd->dest.dgid, attr->ah_attr.grh.dgid.raw, 16);
+	cmd->dest.flow_label 	    = attr->ah_attr.grh.flow_label;
+	cmd->dest.dlid 		    = attr->ah_attr.dlid;
+	cmd->dest.sgid_index 	    = attr->ah_attr.grh.sgid_index;
+	cmd->dest.hop_limit 	    = attr->ah_attr.grh.hop_limit;
+	cmd->dest.traffic_class     = attr->ah_attr.grh.traffic_class;
+	cmd->dest.sl 		    = attr->ah_attr.sl;
+	cmd->dest.src_path_bits     = attr->ah_attr.src_path_bits;
+	cmd->dest.static_rate 	    = attr->ah_attr.static_rate;
+	cmd->dest.is_global 	    = attr->ah_attr.is_global;
+	cmd->dest.port_num 	    = attr->ah_attr.port_num;
+
+	memcpy(cmd->alt_dest.dgid, attr->alt_ah_attr.grh.dgid.raw, 16);
+	cmd->alt_dest.flow_label    = attr->alt_ah_attr.grh.flow_label;
+	cmd->alt_dest.dlid 	    = attr->alt_ah_attr.dlid;
+	cmd->alt_dest.sgid_index    = attr->alt_ah_attr.grh.sgid_index;
+	cmd->alt_dest.hop_limit     = attr->alt_ah_attr.grh.hop_limit;
+	cmd->alt_dest.traffic_class = attr->alt_ah_attr.grh.traffic_class;
+	cmd->alt_dest.sl 	    = attr->alt_ah_attr.sl;
+	cmd->alt_dest.src_path_bits = attr->alt_ah_attr.src_path_bits;
+	cmd->alt_dest.static_rate   = attr->alt_ah_attr.static_rate;
+	cmd->alt_dest.is_global     = attr->alt_ah_attr.is_global;
+	cmd->alt_dest.port_num 	    = attr->alt_ah_attr.port_num;
+
+	if (write(qp->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		return errno;
+
+	return 0;
+}
+
+static int rdma_cmd_destroy_qp_v1(struct rdma_qp *qp)
+{
+	struct rdma_destroy_qp_v1 cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, DESTROY_QP);
+	cmd.qp_handle = qp->handle;
+
+	if (write(qp->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_post_send(struct rdma_qp *ibqp, struct rdma_send_wr *wr,
+		      struct rdma_send_wr **bad_wr)
+{
+	struct rdma_post_send     *cmd;
+	struct rdma_post_send_resp resp;
+	struct rdma_send_wr       *i;
+	struct rdma_kern_send_wr  *n, *tmp;
+	struct rdma_sge           *s;
+	unsigned                  wr_count = 0;
+	unsigned                  sge_count = 0;
+	int                       cmd_size;
+	int                       ret = 0;
+
+	for (i = wr; i; i = i->next) {
+		wr_count++;
+		sge_count += i->num_sge;
+	}
+
+	cmd_size = sizeof *cmd + wr_count * sizeof *n + sge_count * sizeof *s;
+	cmd  = alloca(cmd_size);
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, POST_SEND, &resp, sizeof resp);
+	cmd->qp_handle = ibqp->handle;
+	cmd->wr_count  = wr_count;
+	cmd->sge_count = sge_count;
+	cmd->wqe_size  = sizeof *n;
+
+	n = (struct rdma_kern_send_wr *) ((void *) cmd + sizeof *cmd);
+	s = (struct rdma_sge *) (n + wr_count);
+
+	tmp = n;
+	for (i = wr; i; i = i->next) {
+		tmp->wr_id 	= i->wr_id;
+		tmp->num_sge 	= i->num_sge;
+		tmp->opcode 	= i->opcode;
+		tmp->send_flags = i->send_flags;
+		tmp->imm_data 	= i->imm_data;
+		if (ibqp->qp_type == RDMA_QPT_UD) {
+			tmp->wr.ud.ah 	       = i->wr.ud.ah->handle;
+			tmp->wr.ud.remote_qpn  = i->wr.ud.remote_qpn;
+			tmp->wr.ud.remote_qkey = i->wr.ud.remote_qkey;
+		} else {
+			switch(i->opcode) {
+			case RDMA_WR_RDMA_WRITE:
+			case RDMA_WR_RDMA_WRITE_WITH_IMM:
+			case RDMA_WR_RDMA_READ:
+				tmp->wr.rdma.remote_addr =
+					i->wr.rdma.remote_addr;
+				tmp->wr.rdma.rkey = i->wr.rdma.rkey;
+				break;
+			case RDMA_WR_ATOMIC_CMP_AND_SWP:
+			case RDMA_WR_ATOMIC_FETCH_AND_ADD:
+				tmp->wr.atomic.remote_addr =
+					i->wr.atomic.remote_addr;
+				tmp->wr.atomic.compare_add =
+					i->wr.atomic.compare_add;
+				tmp->wr.atomic.swap = i->wr.atomic.swap;
+				tmp->wr.atomic.rkey = i->wr.atomic.rkey;
+				break;
+			default:
+				break;
+			}
+		}
+
+		if (tmp->num_sge) {
+			memcpy(s, i->sg_list, tmp->num_sge * sizeof *s);
+			s += tmp->num_sge;
+		}
+
+		tmp++;
+	}
+
+	resp.bad_wr = 0;
+	if (write(ibqp->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		ret = errno;
+
+	wr_count = resp.bad_wr;
+	if (wr_count) {
+		i = wr;
+		while (--wr_count)
+			i = i->next;
+		*bad_wr = i;
+	}
+
+	return ret;
+}
+
+int rdma_cmd_post_recv(struct rdma_qp *ibqp, struct rdma_recv_wr *wr,
+		      struct rdma_recv_wr **bad_wr)
+{
+	struct rdma_post_recv     *cmd;
+	struct rdma_post_recv_resp resp;
+	struct rdma_recv_wr       *i;
+	struct rdma_kern_recv_wr  *n, *tmp;
+	struct rdma_sge           *s;
+	unsigned                  wr_count = 0;
+	unsigned                  sge_count = 0;
+	int                       cmd_size;
+	int                       ret = 0;
+
+	for (i = wr; i; i = i->next) {
+		wr_count++;
+		sge_count += i->num_sge;
+	}
+
+	cmd_size = sizeof *cmd + wr_count * sizeof *n + sge_count * sizeof *s;
+	cmd  = alloca(cmd_size);
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, POST_RECV, &resp, sizeof resp);
+	cmd->qp_handle = ibqp->handle;
+	cmd->wr_count  = wr_count;
+	cmd->sge_count = sge_count;
+	cmd->wqe_size  = sizeof *n;
+
+	n = (struct rdma_kern_recv_wr *) ((void *) cmd + sizeof *cmd);
+	s = (struct rdma_sge *) (n + wr_count);
+
+	tmp = n;
+	for (i = wr; i; i = i->next) {
+		tmp->wr_id   = i->wr_id;
+		tmp->num_sge = i->num_sge;
+
+		if (tmp->num_sge) {
+			memcpy(s, i->sg_list, tmp->num_sge * sizeof *s);
+			s += tmp->num_sge;
+		}
+
+		tmp++;
+	}
+
+	resp.bad_wr = 0;
+	if (write(ibqp->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		ret = errno;
+
+	wr_count = resp.bad_wr;
+	if (wr_count) {
+		i = wr;
+		while (--wr_count)
+			i = i->next;
+		*bad_wr = i;
+	}
+
+	return ret;
+}
+
+int rdma_cmd_post_srq_recv(struct rdma_srq *srq, struct rdma_recv_wr
*wr,
+		      struct rdma_recv_wr **bad_wr)
+{
+	struct rdma_post_srq_recv *cmd;
+	struct rdma_post_srq_recv_resp resp;
+	struct rdma_recv_wr       *i;
+	struct rdma_kern_recv_wr  *n, *tmp;
+	struct rdma_sge           *s;
+	unsigned                  wr_count = 0;
+	unsigned                  sge_count = 0;
+	int                       cmd_size;
+	int                       ret = 0;
+
+	for (i = wr; i; i = i->next) {
+		wr_count++;
+		sge_count += i->num_sge;
+	}
+
+	cmd_size = sizeof *cmd + wr_count * sizeof *n + sge_count * sizeof *s;
+	cmd  = alloca(cmd_size);
+
+	RDMA_INIT_CMD_RESP(cmd, cmd_size, POST_SRQ_RECV, &resp, sizeof resp);
+	cmd->srq_handle = srq->handle;
+	cmd->wr_count  = wr_count;
+	cmd->sge_count = sge_count;
+	cmd->wqe_size  = sizeof *n;
+
+	n = (struct rdma_kern_recv_wr *) ((void *) cmd + sizeof *cmd);
+	s = (struct rdma_sge *) (n + wr_count);
+
+	tmp = n;
+	for (i = wr; i; i = i->next) {
+		tmp->wr_id = i->wr_id;
+		tmp->num_sge = i->num_sge;
+
+		if (tmp->num_sge) {
+			memcpy(s, i->sg_list, tmp->num_sge * sizeof *s);
+			s += tmp->num_sge;
+		}
+
+		tmp++;
+	}
+
+	resp.bad_wr = 0;
+	if (write(srq->context->cmd_fd, cmd, cmd_size) != cmd_size)
+		ret = errno;
+
+	wr_count = resp.bad_wr;
+	if (wr_count) {
+		i = wr;
+		while (--wr_count)
+			i = i->next;
+		*bad_wr = i;
+	}
+
+	return ret;
+}
+
+int rdma_cmd_create_ah(struct rdma_pd *pd, struct rdma_ah *ah,
+		      struct rdma_ah_attr *attr)
+{
+	struct rdma_create_ah      cmd;
+	struct rdma_create_ah_resp resp;
+
+	RDMA_INIT_CMD_RESP(&cmd, sizeof cmd, CREATE_AH, &resp, sizeof resp);
+	cmd.user_handle            = (uintptr_t) ah;
+	cmd.pd_handle              = pd->handle;
+	cmd.attr.dlid              = attr->dlid;
+	cmd.attr.sl                = attr->sl;
+	cmd.attr.src_path_bits     = attr->src_path_bits;
+	cmd.attr.static_rate       = attr->static_rate;
+	cmd.attr.is_global         = attr->is_global;
+	cmd.attr.port_num          = attr->port_num;
+	cmd.attr.grh.flow_label    = attr->grh.flow_label;
+	cmd.attr.grh.sgid_index    = attr->grh.sgid_index;
+	cmd.attr.grh.hop_limit     = attr->grh.hop_limit;
+	cmd.attr.grh.traffic_class = attr->grh.traffic_class;
+	memcpy(cmd.attr.grh.dgid, attr->grh.dgid.raw, 16);
+
+	if (write(pd->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	ah->handle = resp.handle;
+
+	return 0;
+}
+
+int rdma_cmd_destroy_ah(struct rdma_ah *ah)
+{
+	struct rdma_destroy_ah cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, DESTROY_AH);
+	cmd.ah_handle = ah->handle;
+
+	if (write(ah->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_destroy_qp(struct rdma_qp *qp)
+{
+	struct rdma_destroy_qp      cmd;
+	struct rdma_destroy_qp_resp resp;
+
+	if (abi_ver == 1)
+		return rdma_cmd_destroy_qp_v1(qp);
+
+	RDMA_INIT_CMD_RESP(&cmd, sizeof cmd, DESTROY_QP, &resp, sizeof resp);
+	cmd.qp_handle = qp->handle;
+
+	if (write(qp->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	pthread_mutex_lock(&qp->mutex);
+	while (qp->events_completed != resp.events_reported)
+		pthread_cond_wait(&qp->cond, &qp->mutex);
+	pthread_mutex_unlock(&qp->mutex);
+
+	return 0;
+}
+
+int rdma_cmd_attach_mcast(struct rdma_qp *qp, union rdma_gid *gid,
uint16_t lid)
+{
+	struct rdma_attach_mcast cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, ATTACH_MCAST);
+	memcpy(cmd.gid, gid->raw, sizeof cmd.gid);
+	cmd.qp_handle = qp->handle;
+	cmd.mlid      = lid;
+
+	if (write(qp->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
+
+int rdma_cmd_detach_mcast(struct rdma_qp *qp, union rdma_gid *gid,
uint16_t lid)
+{
+	struct rdma_detach_mcast cmd;
+
+	RDMA_INIT_CMD(&cmd, sizeof cmd, DETACH_MCAST);
+	memcpy(cmd.gid, gid->raw, sizeof cmd.gid);
+	cmd.qp_handle = qp->handle;
+	cmd.mlid      = lid;
+
+	if (write(qp->context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd)
+		return errno;
+
+	return 0;
+}
diff -ruNp ORG/librdmaverbs/src/device.c NEW/librdmaverbs/src/device.c
--- ORG/librdmaverbs/src/device.c	1969-12-31 16:00:00.000000000 -0800
+++ NEW/librdmaverbs/src/device.c	2006-07-10 18:07:47.000000000 -0700
@@ -0,0 +1,270 @@
+/*
+ * Copyright (c) 2004, 2005 Topspin Communications.  All rights
reserved.
+ * Copyright (c) 2006 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.
+ *
+ * $Id: device.c 7631 2006-06-02 19:53:25Z swise $
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <alloca.h>
+
+#include <rdma/arch.h>
+
+#include "rdmaverbs.h"
+
+static pthread_mutex_t device_list_lock = PTHREAD_MUTEX_INITIALIZER;
+static int num_devices;
+static struct rdma_device **device_list;
+
+struct rdma_device **rdma_get_device_list(int *num)
+{
+	struct rdma_device **l;
+	int i;
+
+	pthread_mutex_lock(&device_list_lock);
+
+	if (!num_devices)
+		num_devices = rdmaverbs_init(&device_list);
+
+	l = calloc(num_devices + 1, sizeof (struct rdma_device *));
+	for (i = 0; i < num_devices; ++i)
+		l[i] = device_list[i];
+
+	pthread_mutex_unlock(&device_list_lock);
+
+	if (num)
+		*num = l ? num_devices : 0;
+
+	return l;
+}
+
+void rdma_free_device_list(struct rdma_device **list)
+{
+	free(list);
+}
+
+const char *rdma_get_device_name(struct rdma_device *device)
+{
+	return device->name;
+}
+
+uint64_t rdma_get_device_guid(struct rdma_device *device)
+{
+	char attr[24];
+	uint64_t guid = 0;
+	uint16_t parts[4];
+	int i;
+
+	if (rdma_read_sysfs_file(device->ibdev_path, "node_guid",
+				attr, sizeof attr) < 0)
+		return 0;
+
+	if (sscanf(attr, "%hx:%hx:%hx:%hx",
+		   parts, parts + 1, parts + 2, parts + 3) != 4)
+		return 0;
+
+	for (i = 0; i < 4; ++i)
+		guid = (guid << 16) | parts[i];
+
+	return htonll(guid);
+}
+
+static enum rdma_node_type query_node_type(struct rdma_device *device)
+{
+	char node_desc[24];
+	char node_str[24];
+	int node_type;
+
+	if (rdma_read_sysfs_file(device->ibdev_path, "node_type",
+				node_desc, sizeof(node_desc)) < 0)
+		return RDMA_NODE_UNKNOWN;
+
+	sscanf(node_desc, "%d: %s\n", (int*)&node_type, node_str);
+	return (enum rdma_node_type) node_type;
+}
+
+struct rdma_context *rdma_open_device(struct rdma_device *device)
+{
+	char *devpath;
+	int cmd_fd;
+	struct rdma_context *context;
+
+	asprintf(&devpath, "/dev/infiniband/%s", device->dev_name);
+
+	/*
+	 * We'll only be doing writes, but we need O_RDWR in case the
+	 * provider needs to mmap() the file.
+	 */
+	cmd_fd = open(devpath, O_RDWR);
+	free(devpath);
+
+	if (cmd_fd < 0)
+		return NULL;
+
+	device->node_type = query_node_type(device);
+
+	context = device->ops.alloc_context(device, cmd_fd);
+	if (!context)
+		goto err;
+
+	context->device = device;
+	context->cmd_fd = cmd_fd;
+
+	return context;
+
+err:
+	close(cmd_fd);
+
+	return NULL;
+}
+
+int rdma_close_device(struct rdma_context *context)
+{
+	int async_fd = context->async_fd;
+	int cmd_fd   = context->cmd_fd;
+	int cq_fd    = -1;
+
+	if (abi_ver <= 2) {
+		struct rdma_abi_compat_v2 *t = context->abi_compat;
+		cq_fd = t->channel.fd;
+		free(context->abi_compat);
+	}
+
+	context->device->ops.free_context(context);
+
+	close(async_fd);
+	close(cmd_fd);
+	if (abi_ver <= 2)
+		close(cq_fd);
+
+	return 0;
+}
+
+int rdma_get_async_event(struct rdma_context *context,
+			struct rdma_async_event *event)
+{
+	struct rdma_kern_async_event ev;
+
+	if (read(context->async_fd, &ev, sizeof ev) != sizeof ev)
+		return -1;
+
+	event->event_type = ev.event_type;
+
+	switch (event->event_type) {
+	case RDMA_EVENT_CQ_ERR:
+		event->element.cq = (void *) (uintptr_t) ev.element;
+		break;
+
+	case RDMA_EVENT_QP_FATAL:
+	case RDMA_EVENT_QP_REQ_ERR:
+	case RDMA_EVENT_QP_ACCESS_ERR:
+	case RDMA_EVENT_COMM_EST:
+	case RDMA_EVENT_SQ_DRAINED:
+	case RDMA_EVENT_PATH_MIG:
+	case RDMA_EVENT_PATH_MIG_ERR:
+	case RDMA_EVENT_QP_LAST_WQE_REACHED:
+		event->element.qp = (void *) (uintptr_t) ev.element;
+		break;
+
+	case RDMA_EVENT_SRQ_ERR:
+	case RDMA_EVENT_SRQ_LIMIT_REACHED:
+		event->element.srq = (void *) (uintptr_t) ev.element;
+		break;
+
+	default:
+		event->element.port_num = ev.element;
+		break;
+	}
+
+	return 0;
+}
+
+void rdma_ack_async_event(struct rdma_async_event *event)
+{
+	switch (event->event_type) {
+	case RDMA_EVENT_CQ_ERR:
+	{
+		struct rdma_cq *cq = event->element.cq;
+
+		pthread_mutex_lock(&cq->mutex);
+		++cq->async_events_completed;
+		pthread_cond_signal(&cq->cond);
+		pthread_mutex_unlock(&cq->mutex);
+
+		return;
+	}
+
+	case RDMA_EVENT_QP_FATAL:
+	case RDMA_EVENT_QP_REQ_ERR:
+	case RDMA_EVENT_QP_ACCESS_ERR:
+	case RDMA_EVENT_COMM_EST:
+	case RDMA_EVENT_SQ_DRAINED:
+	case RDMA_EVENT_PATH_MIG:
+	case RDMA_EVENT_PATH_MIG_ERR:
+	case RDMA_EVENT_QP_LAST_WQE_REACHED:
+	{
+		struct rdma_qp *qp = event->element.qp;
+
+		pthread_mutex_lock(&qp->mutex);
+		++qp->events_completed;
+		pthread_cond_signal(&qp->cond);
+		pthread_mutex_unlock(&qp->mutex);
+
+		return;
+	}
+
+	case RDMA_EVENT_SRQ_ERR:
+	case RDMA_EVENT_SRQ_LIMIT_REACHED:
+	{
+		struct rdma_srq *srq = event->element.srq;
+
+		pthread_mutex_lock(&srq->mutex);
+		++srq->events_completed;
+		pthread_cond_signal(&srq->cond);
+		pthread_mutex_unlock(&srq->mutex);
+
+		return;
+	}
+
+	default:
+		return;
+	}
+}
diff -ruNp ORG/librdmaverbs/src/init.c NEW/librdmaverbs/src/init.c
--- ORG/librdmaverbs/src/init.c	1969-12-31 16:00:00.000000000 -0800
+++ NEW/librdmaverbs/src/init.c	2006-07-10 18:07:47.000000000 -0700
@@ -0,0 +1,274 @@
+/*
+ * Copyright (c) 2004, 2005 Topspin Communications.  All rights
reserved.
+ * Copyright (c) 2006 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.
+ *
+ * $Id: init.c 7631 2006-06-02 19:53:25Z swise $
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+#include <string.h>
+#include <glob.h>
+#include <stdio.h>
+#include <dlfcn.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <dirent.h>
+
+#include "rdmaverbs.h"
+
+#ifndef OPENRDMA_DRIVER_PATH_ENV
+#  define OPENRDMA_DRIVER_PATH_ENV "OPENRDMA_DRIVER_PATH"
+#endif
+
+HIDDEN int abi_ver;
+
+static char default_path[] = DRIVER_PATH;
+static const char *user_path;
+
+static struct rdma_driver *driver_list;
+
+static void load_driver(char *so_path)
+{
+	void *dlhandle;
+	rdma_driver_init_func init_func;
+	struct rdma_driver *driver;
+
+	dlhandle = dlopen(so_path, RTLD_NOW);
+	if (!dlhandle) {
+		fprintf(stderr, PFX "Warning: couldn't load driver %s: %s\n",
+			so_path, dlerror());
+		return;
+	}
+
+	dlerror();
+	init_func = dlsym(dlhandle, "rdma_driver_init");
+	if (dlerror() != NULL || !init_func) {
+		dlclose(dlhandle);
+		return;
+	}
+
+	driver = malloc(sizeof *driver);
+	if (!driver) {
+		fprintf(stderr, PFX "Fatal: couldn't allocate driver for %s\n",
so_path);
+		dlclose(dlhandle);
+		return;
+	}
+
+	driver->init_func = init_func;
+	driver->next      = driver_list;
+	driver_list       = driver;
+}
+
+static void find_drivers(char *dir)
+{
+	size_t len = strlen(dir);
+	glob_t so_glob;
+	char *pat;
+	int ret;
+	int i;
+
+	if (!len)
+		return;
+
+	while (len && dir[len - 1] == '/')
+		dir[--len] = '\0';
+
+	asprintf(&pat, "%s/*.so", dir);
+
+	ret = glob(pat, 0, NULL, &so_glob);
+	free(pat);
+
+	if (ret) {
+		if (ret != GLOB_NOMATCH)
+			fprintf(stderr, PFX "Warning: couldn't search %s\n", pat);
+		return;
+	}
+
+	for (i = 0; i < so_glob.gl_pathc; ++i)
+		load_driver(so_glob.gl_pathv[i]);
+
+	globfree(&so_glob);
+}
+
+static struct rdma_device *init_drivers(const char *class_path,
+				       const char *dev_name)
+{
+	struct rdma_driver *driver;
+	struct rdma_device *dev;
+	int abi_ver = 0;
+	char sys_path[RDMA_SYSFS_PATH_MAX];
+	char ibdev_name[RDMA_SYSFS_NAME_MAX];
+	char value[8];
+
+	snprintf(sys_path, sizeof sys_path, "%s/%s",
+		 class_path, dev_name);
+
+	if (rdma_read_sysfs_file(sys_path, "abi_version", value, sizeof value)
> 0)
+		abi_ver = strtol(value, NULL, 10);
+
+	if (rdma_read_sysfs_file(sys_path, "ibdev", ibdev_name, sizeof
ibdev_name) < 0) {
+		fprintf(stderr, PFX "Warning: no ibdev class attr for %s\n",
+			sys_path);
+		return NULL;
+	}
+
+	for (driver = driver_list; driver; driver = driver->next) {
+		dev = driver->init_func(sys_path, abi_ver);
+		if (!dev)
+			continue;
+
+		dev->driver = driver;
+		strcpy(dev->dev_path, sys_path);
+		snprintf(dev->ibdev_path, RDMA_SYSFS_PATH_MAX, "%s/class/infiniband/%
s",
+			 rdma_get_sysfs_path(), ibdev_name);
+		strcpy(dev->dev_name, dev_name);
+		strcpy(dev->name, ibdev_name);
+
+		return dev;
+	}
+
+	fprintf(stderr, PFX "Warning: no userspace device-specific driver
found for %s\n"
+		"	driver search path: ", dev_name);
+	if (user_path)
+		fprintf(stderr, "%s:", user_path);
+	fprintf(stderr, "%s\n", default_path);
+
+	return NULL;
+}
+
+static int check_abi_version(const char *path)
+{
+	char value[8];
+
+	if (rdma_read_sysfs_file(path, "class/infiniband_verbs/abi_version",
+				value, sizeof value) < 0) {
+		fprintf(stderr, PFX "Fatal: couldn't read uverbs ABI version.\n");
+		return -1;
+	}
+
+	abi_ver = strtol(value, NULL, 10);
+
+	if (abi_ver < RDMA_USER_VERBS_MIN_ABI_VERSION ||
+	    abi_ver > RDMA_USER_VERBS_MAX_ABI_VERSION) {
+		fprintf(stderr, PFX "Fatal: kernel ABI version %d "
+			"doesn't match library version %d.\n",
+			abi_ver, RDMA_USER_VERBS_MAX_ABI_VERSION);
+		return -1;
+	}
+
+	return 0;
+}
+
+HIDDEN int rdmaverbs_init(struct rdma_device ***list)
+{
+	const char *sysfs_path;
+	char *wr_path, *dir;
+	char class_path[RDMA_SYSFS_PATH_MAX];
+	DIR *class_dir;
+	struct dirent *dent;
+	struct rdma_device *device;
+	struct rdma_device **new_list;
+	int num_devices = 0;
+	int list_size = 0;
+
+	*list = NULL;
+
+	if (rdma_init_mem_map())
+		return 0;
+
+	find_drivers(default_path);
+
+	/*
+	 * Only follow use path passed in through the calling user's
+	 * environment if we're not running SUID.
+	 */
+	if (getuid() == geteuid()) {
+		user_path = getenv(OPENRDMA_DRIVER_PATH_ENV);
+		if (user_path) {
+			wr_path = strdupa(user_path);
+			while ((dir = strsep(&wr_path, ";:")))
+				find_drivers(dir);
+		}
+	}
+
+	/*
+	 * Now check if a driver is statically linked.  Since we push
+	 * drivers onto our driver list, the last driver we find will
+	 * be the first one we try.
+	 */
+	load_driver(NULL);
+
+	sysfs_path = rdma_get_sysfs_path();
+	if (!sysfs_path) {
+		fprintf(stderr, PFX "Fatal: couldn't find sysfs mount.\n");
+		return 0;
+	}
+
+	if (check_abi_version(sysfs_path))
+		return 0;
+
+	snprintf(class_path, sizeof class_path, "%s/class/infiniband_verbs",
+		 sysfs_path);
+	class_dir = opendir(class_path);
+	if (!class_dir) {
+		fprintf(stderr, PFX "Fatal: couldn't open sysfs class "
+			"directory '%s'.\n", class_path);
+		return 0;
+	}
+
+	while ((dent = readdir(class_dir))) {
+		if (dent->d_name[0] == '.' || dent->d_type == DT_REG)
+			continue;
+
+		device = init_drivers(class_path, dent->d_name);
+		if (!device)
+			continue;
+
+		if (list_size <= num_devices) {
+			list_size = list_size ? list_size * 2 : 1;
+			new_list = realloc(*list, list_size * sizeof (struct rdma_device
*));
+			if (!new_list)
+				goto out;
+			*list = new_list;
+		}
+
+		(*list)[num_devices++] = device;
+	}
+
+	closedir(class_dir);
+
+out:
+	return num_devices;
+}
diff -ruNp ORG/librdmaverbs/src/librdmaverbs.map
NEW/librdmaverbs/src/librdmaverbs.map
--- ORG/librdmaverbs/src/librdmaverbs.map	1969-12-31 16:00:00.000000000
-0800
+++ NEW/librdmaverbs/src/librdmaverbs.map	2006-07-10 18:07:47.000000000
-0700
@@ -0,0 +1,76 @@
+IBVERBS_1.0 {
+	global:
+		rdma_get_device_list;
+		rdma_free_device_list;
+		rdma_get_device_name;
+		rdma_get_device_guid;
+		rdma_open_device;
+		rdma_close_device;
+		rdma_get_async_event;
+		rdma_ack_async_event;
+		rdma_query_device;
+		rdma_query_port;
+		rdma_query_gid;
+		rdma_query_pkey;
+		rdma_alloc_pd;
+		rdma_dealloc_pd;
+		rdma_reg_mr;
+		rdma_dereg_mr;
+		rdma_create_comp_channel;
+		rdma_destroy_comp_channel;
+		rdma_create_cq;
+		rdma_resize_cq;
+		rdma_destroy_cq;
+		rdma_get_cq_event;
+		rdma_ack_cq_events;
+		rdma_create_srq;
+		rdma_modify_srq;
+		rdma_query_srq;
+		rdma_destroy_srq;
+		rdmav_create_qp;
+		rdma_query_qp;
+		rdma_modify_qp;
+		rdmav_destroy_qp;
+		rdma_create_ah;
+		rdma_destroy_ah;
+		rdma_attach_mcast;
+		rdma_detach_mcast;
+		rdma_cmd_get_context;
+		rdma_cmd_query_device;
+		rdma_cmd_query_port;
+		rdma_cmd_query_gid;
+		rdma_cmd_query_pkey;
+		rdma_cmd_alloc_pd;
+		rdma_cmd_dealloc_pd;
+		rdma_cmd_reg_mr;
+		rdma_cmd_dereg_mr;
+		rdma_cmd_create_cq;
+		rdma_cmd_poll_cq;
+		rdma_cmd_req_notify_cq;
+		rdma_cmd_resize_cq;
+		rdma_cmd_destroy_cq;
+		rdma_cmd_create_srq;
+		rdma_cmd_modify_srq;
+		rdma_cmd_query_srq;
+		rdma_cmd_destroy_srq;
+		rdma_cmd_create_qp;
+		rdma_cmd_query_qp;
+		rdma_cmd_modify_qp;
+		rdma_cmd_destroy_qp;
+		rdma_cmd_post_send;
+		rdma_cmd_post_recv;
+		rdma_cmd_post_srq_recv;
+		rdma_cmd_create_ah;
+		rdma_cmd_destroy_ah;
+		rdma_cmd_attach_mcast;
+		rdma_cmd_detach_mcast;
+		rdma_copy_qp_attr_from_kern;
+		rdma_copy_path_rec_from_kern;
+		rdma_copy_path_rec_to_kern;
+		rdma_rate_to_mult;
+		mult_to_rdma_rate;
+		rdma_get_sysfs_path;
+		rdma_read_sysfs_file;
+
+	local: *;
+};
diff -ruNp ORG/librdmaverbs/src/marshall.c
NEW/librdmaverbs/src/marshall.c
--- ORG/librdmaverbs/src/marshall.c	1969-12-31 16:00:00.000000000 -0800
+++ NEW/librdmaverbs/src/marshall.c	2006-07-10 18:07:47.000000000 -0700
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2005 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
+ * 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 <rdma/marshall.h>
+
+static void rdma_copy_ah_attr_from_kern(struct rdma_ah_attr *dst,
+				       struct rdma_kern_ah_attr *src)
+{
+	memcpy(dst->grh.dgid.raw, src->grh.dgid, sizeof dst->grh.dgid);
+	dst->grh.flow_label = src->grh.flow_label;
+	dst->grh.sgid_index = src->grh.sgid_index;
+	dst->grh.hop_limit = src->grh.hop_limit;
+	dst->grh.traffic_class = src->grh.traffic_class;
+
+	dst->dlid = src->dlid;
+	dst->sl = src->sl;
+	dst->src_path_bits = src->src_path_bits;
+	dst->static_rate = src->static_rate;
+	dst->is_global = src->is_global;
+	dst->port_num = src->port_num;
+}
+
+void rdma_copy_qp_attr_from_kern(struct rdma_qp_attr *dst,
+				struct rdma_kern_qp_attr *src)
+{
+	dst->cur_qp_state = src->cur_qp_state;
+	dst->path_mtu = src->path_mtu;
+	dst->path_mig_state = src->path_mig_state;
+	dst->qkey = src->qkey;
+	dst->rq_psn = src->rq_psn;
+	dst->sq_psn = src->sq_psn;
+	dst->dest_qp_num = src->dest_qp_num;
+	dst->qp_access_flags = src->qp_access_flags;
+
+	dst->cap.max_send_wr = src->max_send_wr;
+	dst->cap.max_recv_wr = src->max_recv_wr;
+	dst->cap.max_send_sge = src->max_send_sge;
+	dst->cap.max_recv_sge = src->max_recv_sge;
+	dst->cap.max_inline_data = src->max_inline_data;
+
+	rdma_copy_ah_attr_from_kern(&dst->ah_attr, &src->ah_attr);
+	rdma_copy_ah_attr_from_kern(&dst->alt_ah_attr, &src->alt_ah_attr);
+
+	dst->pkey_index = src->pkey_index;
+	dst->alt_pkey_index = src->alt_pkey_index;
+	dst->en_sqd_async_notify = src->en_sqd_async_notify;
+	dst->sq_draining = src->sq_draining;
+	dst->max_rd_atomic = src->max_rd_atomic;
+	dst->max_dest_rd_atomic = src->max_dest_rd_atomic;
+	dst->min_rnr_timer = src->min_rnr_timer;
+	dst->port_num = src->port_num;
+	dst->timeout = src->timeout;
+	dst->retry_cnt = src->retry_cnt;
+	dst->rnr_retry = src->rnr_retry;
+	dst->alt_port_num = src->alt_port_num;
+	dst->alt_timeout = src->alt_timeout;
+}
+
+void rdma_copy_path_rec_from_kern(struct rdma_sa_path_rec *dst,
+				 struct rdma_kern_path_rec *src)
+{
+	memcpy(dst->dgid.raw, src->dgid, sizeof dst->dgid);
+	memcpy(dst->sgid.raw, src->sgid, sizeof dst->sgid);
+
+	dst->dlid		= src->dlid;
+	dst->slid		= src->slid;
+	dst->raw_traffic	= src->raw_traffic;
+	dst->flow_label		= src->flow_label;
+	dst->hop_limit		= src->hop_limit;
+	dst->traffic_class	= src->traffic_class;
+	dst->reversible		= src->reversible;
+	dst->numb_path		= src->numb_path;
+	dst->pkey		= src->pkey;
+	dst->sl			= src->sl;
+	dst->mtu_selector	= src->mtu_selector;
+	dst->mtu		= src->mtu;
+	dst->rate_selector	= src->rate_selector;
+	dst->rate		= src->rate;
+	dst->packet_life_time	= src->packet_life_time;
+	dst->preference		= src->preference;
+	dst->packet_life_time_selector = src->packet_life_time_selector;
+}
+
+void rdma_copy_path_rec_to_kern(struct rdma_kern_path_rec *dst,
+			       struct rdma_sa_path_rec *src)
+{
+	memcpy(dst->dgid, src->dgid.raw, sizeof src->dgid);
+	memcpy(dst->sgid, src->sgid.raw, sizeof src->sgid);
+
+	dst->dlid		= src->dlid;
+	dst->slid		= src->slid;
+	dst->raw_traffic	= src->raw_traffic;
+	dst->flow_label		= src->flow_label;
+	dst->hop_limit		= src->hop_limit;
+	dst->traffic_class	= src->traffic_class;
+	dst->reversible		= src->reversible;
+	dst->numb_path		= src->numb_path;
+	dst->pkey		= src->pkey;
+	dst->sl			= src->sl;
+	dst->mtu_selector	= src->mtu_selector;
+	dst->mtu		= src->mtu;
+	dst->rate_selector	= src->rate_selector;
+	dst->rate		= src->rate;
+	dst->packet_life_time	= src->packet_life_time;
+	dst->preference		= src->preference;
+	dst->packet_life_time_selector = src->packet_life_time_selector;
+}
diff -ruNp ORG/librdmaverbs/src/memory.c NEW/librdmaverbs/src/memory.c
--- ORG/librdmaverbs/src/memory.c	1969-12-31 16:00:00.000000000 -0800
+++ NEW/librdmaverbs/src/memory.c	2006-07-10 18:07:47.000000000 -0700
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2004, 2005 Topspin Communications.  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.
+ *
+ * $Id: memory.c 6987 2006-05-08 15:18:51Z tom $
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <sys/mman.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "rdmaverbs.h"
+
+/*
+ * We keep a linked list of page ranges that have been locked along
with a
+ * reference count to manage overlapping registrations, etc.
+ *
+ * Eventually we should turn this into an RB-tree or something similar
+ * to avoid the O(n) cost of registering/unregistering memory.
+ */
+
+struct rdma_mem_node {
+	struct rdma_mem_node *prev, *next;
+	uintptr_t            start, end;
+	int                  refcnt;
+};
+
+static struct {
+	struct rdma_mem_node *first;
+	pthread_mutex_t      mutex;
+	uintptr_t            page_size;
+} mem_map;
+
+int rdma_init_mem_map(void)
+{
+	struct rdma_mem_node *node = NULL;
+
+	node = malloc(sizeof *node);
+	if (!node)
+		goto fail;
+
+	node->prev   = node->next = NULL;
+	node->start  = 0;
+	node->end    = UINTPTR_MAX;
+	node->refcnt = 0;
+
+	mem_map.first = node;
+
+	mem_map.page_size = sysconf(_SC_PAGESIZE);
+	if (mem_map.page_size < 0)
+		goto fail;
+
+	if (pthread_mutex_init(&mem_map.mutex, NULL))
+		goto fail;
+
+	return 0;
+
+fail:
+	if (node)
+		free(node);
+
+	return -1;
+}
+
+static struct rdma_mem_node *__mm_find_first(uintptr_t start, uintptr_t
end)
+{
+	struct rdma_mem_node *node = mem_map.first;
+
+	while (node) {
+		if ((node->start <= start && node->end >= start) ||
+		    (node->start <= end   && node->end >= end))
+			break;
+		node = node->next;
+	}
+
+	return node;
+}
+
+static struct rdma_mem_node *__mm_prev(struct rdma_mem_node *node)
+{
+	return node->prev;
+}
+
+static struct rdma_mem_node *__mm_next(struct rdma_mem_node *node)
+{
+	return node->next;
+}
+
+static void __mm_add(struct rdma_mem_node *node,
+		     struct rdma_mem_node *new)
+{
+	new->prev  = node;
+	new->next  = node->next;
+	node->next = new;
+	if (new->next)
+		new->next->prev = new;
+}
+
+static void __mm_remove(struct rdma_mem_node *node)
+{
+	/* Never have to remove the first node, so we can use prev */
+	node->prev->next = node->next;
+	if (node->next)
+		node->next->prev = node->prev;
+}
+
+int rdma_lock_range(void *base, size_t size)
+{
+	uintptr_t start, end;
+	struct rdma_mem_node *node, *tmp;
+	int ret = 0;
+
+	if (!size)
+		return 0;
+
+	start = (uintptr_t) base & ~(mem_map.page_size - 1);
+	end   = ((uintptr_t) (base + size + mem_map.page_size - 1) &
+		 ~(mem_map.page_size - 1)) - 1;
+
+	pthread_mutex_lock(&mem_map.mutex);
+
+	node = __mm_find_first(start, end);
+
+	if (node->start < start) {
+		tmp = malloc(sizeof *tmp);
+		if (!tmp) {
+			ret = -1;
+			goto out;
+		}
+
+		tmp->start  = start;
+		tmp->end    = node->end;
+		tmp->refcnt = node->refcnt;
+		node->end   = start - 1;
+
+		__mm_add(node, tmp);
+		node = tmp;
+	}
+
+	while (node->start <= end) {
+		if (node->end > end) {
+			tmp = malloc(sizeof *tmp);
+			if (!tmp) {
+				ret = -1;
+				goto out;
+			}
+
+			tmp->start  = end + 1;
+			tmp->end    = node->end;
+			tmp->refcnt = node->refcnt;
+			node->end   = end;
+
+			__mm_add(node, tmp);
+		}
+
+
+		if (node->refcnt++ == 0) {
+			ret = mlock((void *) node->start,
+				    node->end - node->start + 1);
+			if (ret)
+				goto out;
+		}
+
+		node = __mm_next(node);
+	}
+
+out:
+	pthread_mutex_unlock(&mem_map.mutex);
+
+	return ret;
+}
+
+int rdma_unlock_range(void *base, size_t size)
+{
+	uintptr_t start, end;
+	struct rdma_mem_node *node, *tmp;
+	int ret = 0;
+
+	if (!size)
+		return 0;
+
+	start = (uintptr_t) base & ~(mem_map.page_size - 1);
+	end   = ((uintptr_t) (base + size + mem_map.page_size - 1) &
+		 ~(mem_map.page_size - 1)) - 1;
+
+	pthread_mutex_lock(&mem_map.mutex);
+
+	node = __mm_find_first(start, end);
+
+	if (node->start != start) {
+		ret = -1;
+		goto out;
+	}
+
+	while (node && node->end <= end) {
+		if (--node->refcnt == 0) {
+			ret = munlock((void *) node->start,
+				      node->end - node->start + 1);
+		}
+
+		if (__mm_prev(node) && node->refcnt == __mm_prev(node)->refcnt) {
+			__mm_prev(node)->end = node->end;
+			tmp = __mm_prev(node);
+			__mm_remove(node);
+			node = tmp;
+		}
+
+		node = __mm_next(node);
+	}
+
+	if (node && node->refcnt == __mm_prev(node)->refcnt) {
+		__mm_prev(node)->end = node->end;
+		tmp = __mm_prev(node);
+		__mm_remove(node);
+	}
+
+	if (node->end != end) {
+		ret = -1;
+		goto out;
+	}
+
+out:
+	pthread_mutex_unlock(&mem_map.mutex);
+
+	return ret;
+}
diff -ruNp ORG/librdmaverbs/src/rdmaverbs.h
NEW/librdmaverbs/src/rdmaverbs.h
--- ORG/librdmaverbs/src/rdmaverbs.h	1969-12-31 16:00:00.000000000 -0800
+++ NEW/librdmaverbs/src/rdmaverbs.h	2006-07-10 18:07:47.000000000 -0700
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2004, 2005 Topspin Communications.  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.
+ *
+ */
+
+#ifndef RDMA_VERBS_H
+#define RDMA_VERBS_H
+
+#include <pthread.h>
+
+#include <rdma/driver.h>
+
+#define HIDDEN		__attribute__((visibility ("hidden")))
+
+#define INIT		__attribute__((constructor))
+#define FINI		__attribute__((destructor))
+
+#define PFX		"librdmaverbs: "
+
+struct rdma_driver {
+	rdma_driver_init_func	init_func;
+	struct rdma_driver      *next;
+};
+
+struct rdma_abi_compat_v2 {
+	struct rdma_comp_channel	channel;
+	pthread_mutex_t		in_use;
+};
+
+extern HIDDEN int abi_ver;
+
+extern HIDDEN int rdmaverbs_init(struct rdma_device ***list);
+
+extern HIDDEN int rdma_init_mem_map(void);
+extern HIDDEN int rdma_lock_range(void *base, size_t size);
+extern HIDDEN int rdma_unlock_range(void *base, size_t size);
+
+#define RDMA_INIT_CMD(cmd, size, opcode)					\
+	do {								\
+		if (abi_ver > 2)					\
+			(cmd)->command = RDMA_USER_VERBS_CMD_##opcode;	\
+		else							\
+			(cmd)->command = RDMA_USER_VERBS_CMD_##opcode##_V2; \
+		(cmd)->in_words  = (size) / 4;				\
+		(cmd)->out_words = 0;					\
+	} while (0)
+
+#define RDMA_INIT_CMD_RESP(cmd, size, opcode, out, outsize)		\
+	do {								\
+		if (abi_ver > 2)					\
+			(cmd)->command = RDMA_USER_VERBS_CMD_##opcode;	\
+		else							\
+			(cmd)->command = RDMA_USER_VERBS_CMD_##opcode##_V2; \
+		(cmd)->in_words  = (size) / 4;				\
+		(cmd)->out_words = (outsize) / 4;			\
+		(cmd)->response  = (uintptr_t) (out);			\
+	} while (0)
+
+#endif /* RDMA_VERBS_H */
diff -ruNp ORG/librdmaverbs/src/sysfs.c NEW/librdmaverbs/src/sysfs.c
--- ORG/librdmaverbs/src/sysfs.c	1969-12-31 16:00:00.000000000 -0800
+++ NEW/librdmaverbs/src/sysfs.c	2006-07-10 18:07:47.000000000 -0700
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2006 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.
+ *
+ * $Id$
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "rdmaverbs.h"
+
+static char *sysfs_path;
+
+const char *rdma_get_sysfs_path(void)
+{
+	char *env = NULL;
+
+	if (sysfs_path)
+		return sysfs_path;
+
+	/*
+	 * Only follow use path passed in through the calling user's
+	 * environment if we're not running SUID.
+	 */
+	if (getuid() == geteuid())
+		env = getenv("SYSFS_PATH");
+
+	if (env) {
+		int len;
+
+		sysfs_path = strndup(env, RDMA_SYSFS_PATH_MAX);
+		len = strlen(sysfs_path);
+		while (len > 0 && sysfs_path[len - 1] == '/') {
+			--len;
+			sysfs_path[len] = '\0';
+		}
+	} else
+		sysfs_path = "/sys";
+
+	return sysfs_path;
+}
+
+int rdma_read_sysfs_file(const char *dir, const char *file,
+			char *buf, size_t size)
+{
+	char *path;
+	int fd;
+	int len;
+
+	asprintf(&path, "%s/%s", dir, file);
+
+	fd = open(path, O_RDONLY);
+	if (fd < 0) {
+		free(path);
+		return -1;
+	}
+
+	len = read(fd, buf, size);
+
+	close(fd);
+	free(path);
+
+	if (len > 0 && buf[len - 1] == '\n')
+		buf[--len] = '\0';
+
+	return len;
+}
diff -ruNp ORG/librdmaverbs/src/verbs.c NEW/librdmaverbs/src/verbs.c
--- ORG/librdmaverbs/src/verbs.c	1969-12-31 16:00:00.000000000 -0800
+++ NEW/librdmaverbs/src/verbs.c	2006-07-10 18:07:47.000000000 -0700
@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) 2005 Topspin Communications.  All rights reserved.
+ * Copyright (c) 2006 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.
+ *
+ * $Id: verbs.c 7631 2006-06-02 19:53:25Z swise $
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include "rdmaverbs.h"
+
+int rdma_rate_to_mult(enum rdma_rate rate)
+{
+	switch (rate) {
+	case RDMA_RATE_2_5_GBPS: return  1;
+	case RDMA_RATE_5_GBPS:   return  2;
+	case RDMA_RATE_10_GBPS:  return  4;
+	case RDMA_RATE_20_GBPS:  return  8;
+	case RDMA_RATE_30_GBPS:  return 12;
+	case RDMA_RATE_40_GBPS:  return 16;
+	case RDMA_RATE_60_GBPS:  return 24;
+	case RDMA_RATE_80_GBPS:  return 32;
+	case RDMA_RATE_120_GBPS: return 48;
+	default:           return -1;
+	}
+}
+
+enum rdma_rate mult_to_rdma_rate(int mult)
+{
+	switch (mult) {
+	case 1:  return RDMA_RATE_2_5_GBPS;
+	case 2:  return RDMA_RATE_5_GBPS;
+	case 4:  return RDMA_RATE_10_GBPS;
+	case 8:  return RDMA_RATE_20_GBPS;
+	case 12: return RDMA_RATE_30_GBPS;
+	case 16: return RDMA_RATE_40_GBPS;
+	case 24: return RDMA_RATE_60_GBPS;
+	case 32: return RDMA_RATE_80_GBPS;
+	case 48: return RDMA_RATE_120_GBPS;
+	default: return RDMA_RATE_MAX;
+	}
+}
+
+int rdma_query_device(struct rdma_context *context,
+		     struct rdma_device_attr *device_attr)
+{
+	return context->ops.query_device(context, device_attr);
+}
+
+int rdma_query_port(struct rdma_context *context, uint8_t port_num,
+		   struct rdma_port_attr *port_attr)
+{
+	return context->ops.query_port(context, port_num, port_attr);
+}
+
+int rdma_query_gid(struct rdma_context *context, uint8_t port_num,
+		  int index, union rdma_gid *gid)
+{
+	char name[24];
+	char attr[41];
+	uint16_t val;
+	int i;
+
+	snprintf(name, sizeof name, "ports/%d/gids/%d", port_num, index);
+
+	if (rdma_read_sysfs_file(context->device->ibdev_path, name,
+				attr, sizeof attr) < 0)
+		return -1;
+
+	for (i = 0; i < 8; ++i) {
+		if (sscanf(attr + i * 5, "%hx", &val) != 1)
+			return -1;
+		gid->raw[i * 2    ] = val >> 8;
+		gid->raw[i * 2 + 1] = val & 0xff;
+	}
+
+	return 0;
+}
+
+int rdma_query_pkey(struct rdma_context *context, uint8_t port_num,
+		   int index, uint16_t *pkey)
+{
+	char name[24];
+	char attr[8];
+	uint16_t val;
+
+	snprintf(name, sizeof name, "ports/%d/pkeys/%d", port_num, index);
+
+	if (rdma_read_sysfs_file(context->device->ibdev_path, name,
+				attr, sizeof attr) < 0)
+		return -1;
+
+	if (sscanf(attr, "%hx", &val) != 1)
+		return -1;
+
+	*pkey = htons(val);
+	return 0;
+}
+
+struct rdma_pd *rdma_alloc_pd(struct rdma_context *context)
+{
+	struct rdma_pd *pd;
+
+	pd = context->ops.alloc_pd(context);
+	if (pd)
+		pd->context = context;
+
+	return pd;
+}
+
+int rdma_dealloc_pd(struct rdma_pd *pd)
+{
+	return pd->context->ops.dealloc_pd(pd);
+}
+
+struct rdma_mr *rdma_reg_mr(struct rdma_pd *pd, void *addr,
+			  size_t length, enum rdma_access_flags access)
+{
+	struct rdma_mr *mr;
+
+	mr = pd->context->ops.reg_mr(pd, addr, length, access);
+	if (mr) {
+		mr->context = pd->context;
+		mr->pd      = pd;
+	}
+
+	return mr;
+}
+
+int rdma_dereg_mr(struct rdma_mr *mr)
+{
+	return mr->context->ops.dereg_mr(mr);
+}
+
+static struct rdma_comp_channel *rdma_create_comp_channel_v2(struct
rdma_context *context)
+{
+	struct rdma_abi_compat_v2 *t = context->abi_compat;
+	static int warned;
+
+	if (!pthread_mutex_trylock(&t->in_use))
+		return &t->channel;
+
+	if (!warned) {
+		fprintf(stderr, PFX "Warning: kernel's ABI version %d limits
capacity.\n"
+			"    Only one completion channel can be created per context.\n",
+			abi_ver);
+		++warned;
+	}
+
+	return NULL;
+}
+
+struct rdma_comp_channel *rdma_create_comp_channel(struct rdma_context
*context)
+{
+	struct rdma_comp_channel            *channel;
+	struct rdma_create_comp_channel      cmd;
+	struct rdma_create_comp_channel_resp resp;
+
+	if (abi_ver <= 2)
+		return rdma_create_comp_channel_v2(context);
+
+	channel = malloc(sizeof *channel);
+	if (!channel)
+		return NULL;
+
+	RDMA_INIT_CMD_RESP(&cmd, sizeof cmd, CREATE_COMP_CHANNEL, &resp,
sizeof resp);
+	if (write(context->cmd_fd, &cmd, sizeof cmd) != sizeof cmd) {
+		free(channel);
+		return NULL;
+	}
+
+	channel->fd = resp.fd;
+
+	return channel;
+}
+
+static int rdma_destroy_comp_channel_v2(struct rdma_comp_channel
*channel)
+{
+	struct rdma_abi_compat_v2 *t = (struct rdma_abi_compat_v2 *) channel;
+	pthread_mutex_unlock(&t->in_use);
+	return 0;
+}
+
+int rdma_destroy_comp_channel(struct rdma_comp_channel *channel)
+{
+	if (abi_ver <= 2)
+		return rdma_destroy_comp_channel_v2(channel);
+
+	close(channel->fd);
+	free(channel);
+
+	return 0;
+}
+
+struct rdma_cq *rdma_create_cq(struct rdma_context *context, int cqe,
void *cq_context,
+			     struct rdma_comp_channel *channel, int comp_vector)
+{
+	struct rdma_cq *cq = context->ops.create_cq(context, cqe, channel,
+						   comp_vector);
+
+	if (cq) {
+		cq->context    	     	   = context;
+		cq->cq_context 	     	   = cq_context;
+		cq->comp_events_completed  = 0;
+		cq->async_events_completed = 0;
+		pthread_mutex_init(&cq->mutex, NULL);
+		pthread_cond_init(&cq->cond, NULL);
+	}
+
+	return cq;
+}
+
+int rdma_resize_cq(struct rdma_cq *cq, int cqe)
+{
+	if (!cq->context->ops.resize_cq)
+		return ENOSYS;
+
+	return cq->context->ops.resize_cq(cq, cqe);
+}
+
+int rdma_destroy_cq(struct rdma_cq *cq)
+{
+	return cq->context->ops.destroy_cq(cq);
+}
+
+
+int rdma_get_cq_event(struct rdma_comp_channel *channel,
+		     struct rdma_cq **cq, void **cq_context)
+{
+	struct rdma_comp_event ev;
+
+	if (read(channel->fd, &ev, sizeof ev) != sizeof ev)
+		return -1;
+
+	*cq         = (struct rdma_cq *) (uintptr_t) ev.cq_handle;
+	*cq_context = (*cq)->cq_context;
+
+	if ((*cq)->context->ops.cq_event)
+		(*cq)->context->ops.cq_event(*cq);
+
+	return 0;
+}
+
+void rdma_ack_cq_events(struct rdma_cq *cq, unsigned int nevents)
+{
+	pthread_mutex_lock(&cq->mutex);
+	cq->comp_events_completed += nevents;
+	pthread_cond_signal(&cq->cond);
+	pthread_mutex_unlock(&cq->mutex);
+}
+
+struct rdma_srq *rdma_create_srq(struct rdma_pd *pd,
+			       struct rdma_srq_init_attr *srq_init_attr)
+{
+	struct rdma_srq *srq;
+
+	if (!pd->context->ops.create_srq)
+		return NULL;
+
+	srq = pd->context->ops.create_srq(pd, srq_init_attr);
+	if (srq) {
+		srq->context          = pd->context;
+		srq->srq_context      = srq_init_attr->srq_context;
+		srq->pd               = pd;
+		srq->events_completed = 0;
+		pthread_mutex_init(&srq->mutex, NULL);
+		pthread_cond_init(&srq->cond, NULL);
+	}
+
+	return srq;
+}
+
+int rdma_modify_srq(struct rdma_srq *srq,
+		   struct rdma_srq_attr *srq_attr,
+		   enum rdma_srq_attr_mask srq_attr_mask)
+{
+	return srq->context->ops.modify_srq(srq, srq_attr, srq_attr_mask);
+}
+
+int rdma_query_srq(struct rdma_srq *srq, struct rdma_srq_attr
*srq_attr)
+{
+	return srq->context->ops.query_srq(srq, srq_attr);
+}
+
+int rdma_destroy_srq(struct rdma_srq *srq)
+{
+	return srq->context->ops.destroy_srq(srq);
+}
+
+struct rdma_qp *rdmav_create_qp(struct rdma_pd *pd,
+			     struct rdma_qp_init_attr *qp_init_attr)
+{
+	struct rdma_qp *qp = pd->context->ops.create_qp(pd, qp_init_attr);
+
+	if (qp) {
+		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->events_completed = 0;
+		pthread_mutex_init(&qp->mutex, NULL);
+		pthread_cond_init(&qp->cond, NULL);
+	}
+
+	return qp;
+}
+
+int rdma_query_qp(struct rdma_qp *qp, struct rdma_qp_attr *attr,
+		 enum rdma_qp_attr_mask attr_mask,
+		 struct rdma_qp_init_attr *init_attr)
+{
+	int ret;
+
+	ret = qp->context->ops.query_qp(qp, attr, attr_mask, init_attr);
+	if (ret)
+		return ret;
+
+	if (attr_mask & RDMA_QP_STATE)
+		qp->state = attr->qp_state;
+
+	return 0;
+}
+
+int rdma_modify_qp(struct rdma_qp *qp, struct rdma_qp_attr *attr,
+		  enum rdma_qp_attr_mask attr_mask)
+{
+	int ret;
+
+	ret = qp->context->ops.modify_qp(qp, attr, attr_mask);
+	if (ret)
+		return ret;
+
+	if (attr_mask & RDMA_QP_STATE)
+		qp->state = attr->qp_state;
+
+	return 0;
+}
+
+int rdmav_destroy_qp(struct rdma_qp *qp)
+{
+	return qp->context->ops.destroy_qp(qp);
+}
+
+struct rdma_ah *rdma_create_ah(struct rdma_pd *pd, struct rdma_ah_attr
*attr)
+{
+	struct rdma_ah *ah = pd->context->ops.create_ah(pd, attr);
+
+	if (ah) {
+		ah->context = pd->context;
+		ah->pd      = pd;
+	}
+
+	return ah;
+}
+
+int rdma_destroy_ah(struct rdma_ah *ah)
+{
+	return ah->context->ops.destroy_ah(ah);
+}
+
+int rdma_attach_mcast(struct rdma_qp *qp, union rdma_gid *gid, uint16_t
lid)
+{
+	return qp->context->ops.attach_mcast(qp, gid, lid);
+}
+
+int rdma_detach_mcast(struct rdma_qp *qp, union rdma_gid *gid, uint16_t
lid)
+{
+	return qp->context->ops.detach_mcast(qp, gid, lid);
+}






More information about the general mailing list