diff -r -u /tmp/839450/libmlx4-1.0.1/Makefile.am libmlx4-1.0.1/Makefile.am

--- /tmp/839450/libmlx4-1.0.1/Makefile.am	Tue Sep  8 06:40:35 2009

+++ libmlx4-1.0.1/Makefile.am	Tue Mar 15 06:49:47 2011

@@ -10,7 +10,7 @@

     src_libmlx4_la_SOURCES = $(MLX4_SOURCES)

     src_libmlx4_la_LDFLAGS = -avoid-version -release @IBV_DEVICE_LIBRARY_EXTENSION@ \

         $(mlx4_version_script)

-    mlx4confdir = $(sysconfdir)/libibverbs.d

+    mlx4confdir = $(datadir)/libibverbs.d

     mlx4conf_DATA = mlx4.driver

 else

     mlx4libdir = $(libdir)/infiniband

diff -r -u /tmp/839450/libmlx4-1.0.1/src/mlx4-abi.h libmlx4-1.0.1/src/mlx4-abi.h

--- /tmp/839450/libmlx4-1.0.1/src/mlx4-abi.h	Thu Mar 10 04:48:34 2011

+++ libmlx4-1.0.1/src/mlx4-abi.h	Fri Feb 11 03:49:51 2011

@@ -35,6 +35,10 @@

 #include <infiniband/kern-abi.h>

+#if defined(__SVR4) && defined(__sun)

+#include <sys/ib/adapters/mlnx_umap.h>   /* Opaque CI data out definitions */

+#endif

+

 #define MLX4_UVERBS_MIN_ABI_VERSION	2

 #define MLX4_UVERBS_MAX_ABI_VERSION	3

diff -r -u /tmp/839450/libmlx4-1.0.1/src/verbs.c libmlx4-1.0.1/src/verbs.c

--- /tmp/839450/libmlx4-1.0.1/src/verbs.c	Thu Mar 10 04:48:34 2011

+++ libmlx4-1.0.1/src/verbs.c	Fri Mar 11 14:40:18 2011

@@ -56,6 +56,15 @@

 	if (ret)

 		return ret;

+#if defined(__SVR4) && defined(__sun)

+	/*

+	 * To be consistent with OFED and so the queue operations in srq.c work

+	 * we need to report the max as actual max  less 1. In OFED this is

+	 * done in the HCA driver.

+	 */

+	attr->max_srq_wr -=1;

+#endif

+

 	major     = (raw_fw_ver >> 32) & 0xffff;

 	minor     = (raw_fw_ver >> 16) & 0xffff;

 	sub_minor = raw_fw_ver & 0xffff;

@@ -79,6 +88,9 @@

 	struct ibv_alloc_pd       cmd;

 	struct mlx4_alloc_pd_resp resp;

 	struct mlx4_pd		 *pd;

+#if defined(__SVR4) && defined(__sun)

+	mlnx_umap_pd_data_out_t   *mdd;

+#endif

 	pd = malloc(sizeof *pd);

 	if (!pd)

@@ -90,7 +102,16 @@

 		return NULL;

 	}

+#if defined(__SVR4) && defined(__sun)

+	/*

+	 * The kernel driver passes back the PD table index as opaque data.  This

+	 * index is required for specifying the PD in user space address vectors.

+	 */

+	mdd     = (mlnx_umap_pd_data_out_t *) &resp.ibv_resp.drv_out;

+	pd->pdn = mdd->mpd_pdnum;

+#else

 	pd->pdn = resp.pdn;

+#endif

 	return &pd->ibv_pd;

 }

@@ -168,6 +189,10 @@

 	struct mlx4_create_cq_resp resp;

 	struct mlx4_cq		  *cq;

 	int			   ret;

+#if defined(__SVR4) && defined(__sun)

+	void                      *cqbuf;

+	mlnx_umap_cq_data_out_t   *mdd;

+#endif

 	/* Sanity check CQ size before proceeding */

 	if (cqe > 0x3fffff)

@@ -184,7 +209,8 @@

 	cqe = align_queue_size(cqe + 1);

-	if (mlx4_alloc_cq_buf(to_mdev(context->device), &cq->buf, cqe))

+#if !(defined(__SVR4) && defined(__sun))

+	if (mlx4_alloc_cq_buf((to_mdev(context->device), &cq->buf, cqe))

 		goto err;

 	cq->set_ci_db  = mlx4_alloc_db(to_mctx(context), MLX4_DB_TYPE_CQ);

@@ -198,15 +224,84 @@

 	cmd.buf_addr = (uintptr_t) cq->buf.buf;

 	cmd.db_addr  = (uintptr_t) cq->set_ci_db;

+#else

+	cq->buf.buf    = NULL;

+	cq->buf.length = 0;

+	cq->arm_db     = NULL;

+	cq->set_ci_db  = NULL;

+#endif

 	ret = ibv_cmd_create_cq(context, cqe - 1, channel, comp_vector,

 				&cq->ibv_cq, &cmd.ibv_cmd, sizeof cmd,

 				&resp.ibv_resp, sizeof resp);

+

+#if defined(__SVR4) && defined(__sun)

+	if (ret) {

+		goto err;

+	}

+#else

 	if (ret)

 		goto err_db;

+#endif

 	cq->cqn = resp.cqn;

+#if defined(__SVR4) && defined(__sun)

+        /*

+         * For Solaris the kernel driver passes back mmap information for

+	 *  mapping the CQ memory it allocated.

+         */

+        mdd = (mlnx_umap_cq_data_out_t *) &resp.ibv_resp.drv_out;

+	if (mdd->mcq_rev < MLNX_UMAP_IF_VERSION) {

+		fprintf(stderr, PFX "libmlx4_create_cq: libmlx4/hermon umap "

+				"rev mismatch (kernel rev=%d)\n", mdd->mcq_rev);

+		goto err_destroy;

+	}

+

+        cqbuf = mmap64((void *)0, mdd->mcq_maplen, (PROT_READ | PROT_WRITE),

+                    MAP_SHARED, context->mmap_fd, mdd->mcq_mapoffset);

+

+        if (cqbuf == MAP_FAILED) {

+                goto err_destroy;

+        }

+

+        /*

+         * Extract hardware driver values for the number of CQEs and the

+	 * hardware CQ number to use (needed for user space doorbells).

+         */

+        cqe            = mdd->mcq_numcqe;

+        cq->cqn        = mdd->mcq_cqnum;

+        cq->buf.buf    = cqbuf;

+        cq->buf.length = mdd->mcq_maplen;

+	cq->ibv_cq.cqe = cqe-1;

+

+	/*

+	 * We map both poll and arm as seperate doorbells (OFED assumes 1 word

+	 * offset and just bumpts the address) since Solaris provides a

+	 * separate offst. This will amount to the same thing (a second

+	 * reference to the first doorbell is added) but is more flexible.

+	 */

+	cq->set_ci_db = mlx4_alloc_db(to_mctx(context),

+	                              mdd->mcq_polldbr_mapoffset,

+	                              mdd->mcq_polldbr_maplen,

+	                              mdd->mcq_polldbr_offset);

+        if (cq->set_ci_db == NULL) {

+                goto err_buf;

+        }

+

+	cq->arm_db = mlx4_alloc_db(to_mctx(context),

+	                           mdd->mcq_armdbr_mapoffset,

+	                           mdd->mcq_armdbr_maplen,

+	                           mdd->mcq_armdbr_offset);

+        if (cq->arm_db == NULL) {

+                goto err_db;

+        }

+

+	*cq->arm_db    = 0;

+	cq->arm_sn     = 1;

+	*cq->set_ci_db = 0;

+#endif

+

 	return &cq->ibv_cq;

 err_db:

@@ -215,6 +310,22 @@

 err_buf:

 	mlx4_free_buf(&cq->buf);

+#if defined(__SVR4) && defined(__sun)

+err_destroy:

+	/*

+	 * Calling ibv_cmd_destroy_cq() will try and take the ibv_cq

+	 * mutext that is initialised by the ibv_create_cq() entry point

+	 * that called us AFETR we return, so its not initialised yet.

+	 * So initialised it here so the destroy call doesn't hang.

+	 */

+	pthread_mutex_init(&(cq->ibv_cq.mutex), NULL);

+	pthread_cond_init(&(cq->ibv_cq.cond), NULL);

+	cq->ibv_cq.comp_events_completed = 0;

+	cq->ibv_cq.async_events_completed = 0;

+

+	ibv_cmd_destroy_cq(&cq->ibv_cq);

+#endif

+

 err:

 	free(cq);

@@ -225,12 +336,17 @@

 {

 	struct mlx4_cq *cq = to_mcq(ibcq);

 	struct mlx4_resize_cq cmd;

+	struct ibv_resize_cq_resp resp;

 	struct mlx4_buf buf;

 	int old_cqe, outst_cqe, ret;

-

+#if defined(__SVR4) && defined(__sun)

+	void			*cqbuf;

+	mlnx_umap_cq_data_out_t	*mdd;

+#endif

+	

 	/* Sanity check CQ size before proceeding */

 	if (cqe > 0x3fffff)

-		return EINVAL;

+ 		return EINVAL;

 	pthread_spin_lock(&cq->lock);

@@ -247,32 +363,65 @@

 		goto out;

 	}

+#if !(defined(__SVR4) && defined(__sun))

 	ret = mlx4_alloc_cq_buf(to_mdev(ibcq->context->device), &buf, cqe);

 	if (ret)

 		goto out;

-	old_cqe = ibcq->cqe;

-	cmd.buf_addr = (uintptr_t) buf.buf;

+        cmd.buf_addr = (uintptr_t) buf.buf;

+#endif

+        old_cqe = ibcq->cqe;

 #ifdef IBV_CMD_RESIZE_CQ_HAS_RESP_PARAMS

-	{

-		struct ibv_resize_cq_resp resp;

-		ret = ibv_cmd_resize_cq(ibcq, cqe - 1, &cmd.ibv_cmd, sizeof cmd,

+	ret = ibv_cmd_resize_cq(ibcq, cqe - 1, &cmd.ibv_cmd, sizeof cmd,

 					&resp, sizeof resp);

-	}

 #else

 	ret = ibv_cmd_resize_cq(ibcq, cqe - 1, &cmd.ibv_cmd, sizeof cmd);

 #endif

-	if (ret) {

-		mlx4_free_buf(&buf);

+

+        if (ret) {

+#if ! (defined(__SVR4) && defined(__sun))

+                mlx4_free_buf(&buf);

+#endif

 		goto out;

 	}

-	mlx4_cq_resize_copy_cqes(cq, buf.buf, old_cqe);

+#if defined(__SVR4) && defined(__sun)

+	/*

+	 * For Solaris the kernel driver passes back mmap information for

+	 * mapping the CQ memory it allocated.

+	 */

+	mdd = (mlnx_umap_cq_data_out_t *) &resp.drv_out;

+	if (mdd->mcq_rev < MLNX_UMAP_IF_VERSION) {

+		fprintf(stderr, PFX "libmlx4_resize_cq: libmlx4/hermon umap "

+		    "rev mismatch (kernel rev=%d)\n", mdd->mcq_rev);

+		ret = EINVAL;

+		goto out;

+	}

-	mlx4_free_buf(&cq->buf);

-	cq->buf = buf;

+	cqbuf = mmap64((void *)0, mdd->mcq_maplen, (PROT_READ | PROT_WRITE),

+	     MAP_SHARED, ibcq->context->mmap_fd, mdd->mcq_mapoffset);

+	if (cqbuf == MAP_FAILED) {

+		ret = EINVAL;

+		goto out;

+	}

+#endif

+

+        mlx4_cq_resize_copy_cqes(cq, buf.buf, old_cqe);

+

+#if !(defined(__SVR4) && defined(__sun))

+        mlx4_free_buf(&cq->buf);

+#endif

+        cq->buf = buf;

+

+#if defined(__SVR4) && defined(__sun)

+	cqe            = mdd->mcq_numcqe;

+	cq->cqn        = mdd->mcq_cqnum;

+	cq->buf.buf    = cqbuf;

+	cq->buf.length = mdd->mcq_maplen;

+	cq->ibv_cq.cqe = cqe-1;

+#endif

 out:

 	pthread_spin_unlock(&cq->lock);

 	return ret;

@@ -287,6 +436,9 @@

 		return ret;

 	mlx4_free_db(to_mctx(cq->context), MLX4_DB_TYPE_CQ, to_mcq(cq)->set_ci_db);

+#if defined(__SVR4) && defined(__sun)

+	mlx4_free_db(to_mctx(cq->context), MLX4_DB_TYPE_CQ, to_mcq(cq)->arm_db);

+#endif

 	mlx4_free_buf(&to_mcq(cq)->buf);

 	free(to_mcq(cq));

@@ -300,6 +452,10 @@

 	struct mlx4_create_srq_resp resp;

 	struct mlx4_srq		   *srq;

 	int			    ret;

+#if defined(__SVR4) && defined(__sun)

+	mlnx_umap_srq_data_out_t   *mdd;

+	void                       *srqbuf;

+#endif

 	/* Sanity check SRQ size before proceeding */

 	if (attr->attr.max_wr > 1 << 16 || attr->attr.max_sge > 64)

@@ -312,6 +468,7 @@

 	if (pthread_spin_init(&srq->lock, PTHREAD_PROCESS_PRIVATE))

 		goto err;

+#if !(defined(__SVR4) && defined(__sun))

 	srq->max     = align_queue_size(attr->attr.max_wr + 1);

 	srq->max_gs  = attr->attr.max_sge;

 	srq->counter = 0;

@@ -324,7 +481,23 @@

 		goto err_free;

 	*srq->db = 0;

+#else

+	/*

+	 * Solaris SRQ WQE memory is supplied by the kernel; we'll update

+	 * these after the creation.

+	 */

+	srq->buf.buf      = NULL;

+	srq->buf.length   = 0;

+	srq->db           = NULL;

+	/*

+	 * Need solaris to allocate space for the spare WR in

+	 * the list that makes the queue work. The Solaris driver

+	 * will round up to the nearest power of 2 as align_queue_size()

+	 * does for OFED.

+	 */

+	attr->attr.max_wr += 1;

+#endif

 	cmd.buf_addr = (uintptr_t) srq->buf.buf;

 	cmd.db_addr  = (uintptr_t) srq->db;

@@ -331,19 +504,97 @@

 	ret = ibv_cmd_create_srq(pd, &srq->ibv_srq, attr,

 				 &cmd.ibv_cmd, sizeof cmd,

 				 &resp.ibv_resp, sizeof resp);

+#if defined(__SVR4) && defined(__sun)

+	if (ret) {

+		goto err;

+	}

+

+        /*

+         * The kernel driver passes back mmap information for mapping the

+         * SRQ work queue memory it allocated and the doorbell for

+	 * for posting.

+         */

+	mdd = (mlnx_umap_srq_data_out_t *) &resp.ibv_resp.drv_out;

+	if (mdd->msrq_rev < 1) {

+		fprintf(stderr, PFX "libmlx4_create_srq libmlx4/hermon umap "

+			"rev mismatch (kernel rev=%d)\n", mdd->msrq_rev);

+		goto err_destroy;

+	}

+

+        srqbuf = mmap64((void *)0, mdd->msrq_maplen, (PROT_READ | PROT_WRITE),

+                    MAP_SHARED, pd->context->mmap_fd, mdd->msrq_mapoffset);

+

+        if (srqbuf == MAP_FAILED) {

+                goto err_destroy;

+        }

+

+	srq->buf.buf    = srqbuf;

+	srq->buf.length = mdd->msrq_maplen;

+	srq->max	= resp.ibv_resp.max_wr;

+	srq->max_gs	= resp.ibv_resp.max_sge;

+	srq->srqn       = mdd->msrq_srqnum;

+	srq->counter 	= 0;

+

+	srq->db = mlx4_alloc_db(to_mctx(pd->context),

+	                        mdd->msrq_rdbr_mapoffset,

+	                        mdd->msrq_rdbr_maplen,

+	                        mdd->msrq_rdbr_offset);

+	if (srq->db == NULL) {

+                goto err_unmap;

+	}

+

+	/*

+	 * The following call only initializes memory and control structures,

+	 * it utilizes the memory allocated by the kernel.

+	 * It also allocates the srq->wrid memory.

+	 */

+	if (mlx4_set_srq_buf(pd, srq, mdd->msrq_wqesz, mdd->msrq_numwqe)) {

+		goto err_db;

+	}

+

+	/*

+	 * The rturned max wr will have been rounded up to the nearest

+	 * power of 2, subtracting  1 from that and rporting that value

+	 * as the max will give us the required free WR in the queue, as

+	 * in OFED.

+	 */

+	attr->attr.max_wr -= 1;

+#else

 	if (ret)

 		goto err_db;

 	srq->srqn = resp.srqn;

+#endif

 	return &srq->ibv_srq;

 err_db:

 	mlx4_free_db(to_mctx(pd->context), MLX4_DB_TYPE_RQ, srq->db);

+#if defined(__SVR4) && defined(__sun)

+	if (srq->wrid)

+		free(srq->wrid);

+err_unmap:

+	mlx4_free_buf(&srq->buf);

+

+err_destroy:

+	/*

+	 * Calling ibv_cmd_destroy_srq() will try and take the ibv_srq

+	 * mutext that is initialised by the ibv_create_srq() entry point

+	 * that called us AFETR we return, so its not initialised yet.

+	 * So initialised it here so the destroy call doesn't hang.

+	 */

+	pthread_mutex_init(&(srq->ibv_srq.mutex), NULL);

+	pthread_cond_init(&(srq->ibv_srq.cond), NULL);

+	srq->ibv_srq.events_completed = 0;

+

+	ibv_cmd_destroy_srq(&srq->ibv_srq);

+

+#else

 err_free:

 	free(srq->wrid);

 	mlx4_free_buf(&srq->buf);

+#endif

 err:

 	free(srq);

@@ -357,7 +608,16 @@

 {

 	struct ibv_modify_srq cmd;

+#if !(defined(__SVR4) && defined(__sun))

 	return ibv_cmd_modify_srq(srq, attr, attr_mask, &cmd, sizeof cmd);

+#else

+	int	ret;

+

+	attr->max_wr += 1;		/* See create_srq */

+	ret = ibv_cmd_modify_srq(srq, attr, attr_mask, &cmd, sizeof cmd);

+	attr->max_wr -= 1;

+	return (ret);

+#endif

 }

 int mlx4_query_srq(struct ibv_srq *srq,

@@ -365,7 +625,17 @@

 {

 	struct ibv_query_srq cmd;

+#if !(defined(__SVR4) && defined(__sun))

 	return ibv_cmd_query_srq(srq, attr, &cmd, sizeof cmd);

+#else

+

+	int	ret;

+

+	ret = ibv_cmd_query_srq(srq, attr, &cmd, sizeof cmd);

+	attr->max_wr -= 1;		/* See create_srq */

+

+	return (ret);

+#endif

 }

 int mlx4_destroy_srq(struct ibv_srq *ibsrq)

@@ -414,7 +684,11 @@

 		return -1;

 	if (attr->cap.max_inline_data) {

+#if !(defined(__SVR4) && defined(__sun))

 		nsegs = num_inline_segs(attr->cap.max_inline_data, attr->qp_type);

+#else

+		nsegs = mlx4_num_inline_segs(attr->cap.max_inline_data, attr->qp_type);

+#endif

 		size = MLX4_MAX_WQE_SIZE - nsegs * sizeof (struct mlx4_wqe_inline_seg);

 		switch (attr->qp_type) {

 		case IBV_QPT_UD:

@@ -447,6 +721,12 @@

 	struct mlx4_qp		 *qp;

 	int			  ret;

 	struct mlx4_context	 *context = to_mctx(pd->context);

+#if defined(__SVR4) && defined(__sun)

+	mlnx_umap_qp_data_out_t	*mdd;

+	void			*qpbuf;

+	int			max_send_sge;

+	int			max_inline_data;

+#endif

 	/* Sanity check QP size before proceeding */

@@ -457,6 +737,7 @@

 	if (!qp)

 		return NULL;

+#if !(defined(__SVR4) && defined(__sun))

 	mlx4_calc_sq_wqe_size(&attr->cap, attr->qp_type, qp);

 	/*

@@ -466,6 +747,7 @@

 	qp->sq_spare_wqes = (2048 >> qp->sq.wqe_shift) + 1;

 	qp->sq.wqe_cnt = align_queue_size(attr->cap.max_send_wr + qp->sq_spare_wqes);

 	qp->rq.wqe_cnt = align_queue_size(attr->cap.max_recv_wr);

+#endif

 	if (attr->srq || attr->qp_type == IBV_QPT_XRC)

 		attr->cap.max_recv_wr = qp->rq.wqe_cnt = 0;

@@ -476,6 +758,46 @@

 			attr->cap.max_recv_wr = 1;

 	}