#

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

 #include <infiniband/kern-abi.h>

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

+#endif

+

 #define MLX4_UVERBS_MIN_ABI_VERSION	2

 #define MLX4_UVERBS_MAX_ABI_VERSION	3

 	__u32				reserved;

+struct mlx4_share_pd_resp {

+	struct ibv_share_pd_resp	ibv_resp;

+	__u32				pdn;

+	__u32				reserved;

 };

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,14 @@

 	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;

 	return &pd->ibv_pd;

 }

+struct ibv_shpd *mlx4_alloc_shpd(struct ibv_pd *pd, uint64_t share_key, struct ibv_shpd *shpd)

+{

+	struct ibv_alloc_shpd cmd;

+	struct ibv_alloc_shpd_resp resp;

+

+	if (ibv_cmd_alloc_shpd(pd->context, pd, share_key, shpd, &cmd, sizeof cmd,

+			     &resp, sizeof resp)) {

+		return NULL;

+	}

+

+	return shpd;

+}

+

+

+struct ibv_pd *mlx4_share_pd(struct ibv_context *context, struct ibv_shpd *shpd, uint64_t share_key)

+{

+	struct ibv_share_pd       cmd;

+	struct mlx4_share_pd_resp resp;

+	struct mlx4_pd		 *pd;

+

+	pd = malloc(sizeof *pd);

+	if (!pd)

+		return NULL;

+

+	if (ibv_cmd_share_pd(context, shpd, share_key, &pd->ibv_pd, &cmd, sizeof cmd,

+			     &resp.ibv_resp, sizeof resp)) {

+		free(pd);

+		return NULL;

+	}

+	pd->pdn = resp.pdn;

+	return &pd->ibv_pd;

+}

+

 int mlx4_free_pd(struct ibv_pd *pd)

 {

 	int ret;

 	return mr;

 }

+struct ibv_mr *mlx4_reg_mr_relaxed(struct ibv_pd *pd, void *addr, size_t length,

+			   int access)

+{

+	struct ibv_mr *mr;

+	struct ibv_reg_mr cmd;

+	int ret;

+

+	mr = malloc(sizeof *mr);

+	if (!mr)

+		return NULL;

+

+#ifdef IBV_CMD_REG_MR_RELAXED_HAS_RESP_PARAMS

+	{

+		struct ibv_reg_mr_resp resp;

+

+		ret = ibv_cmd_reg_mr_relaxed(pd, addr, length, (uintptr_t) addr,

+				     access, mr, &cmd, sizeof cmd,

+				     &resp, sizeof resp);

+	}

+#else

+	ret = ibv_cmd_reg_mr_relaxed(pd, addr, length, (uintptr_t) addr, access, mr,

+			     &cmd, sizeof cmd);

+#endif

+	if (ret) {

+		free(mr);

+		return NULL;

+	}

+

+	return mr;

+}

+

 int mlx4_dereg_mr(struct ibv_mr *mr)

 {

 	int ret;

 	return 0;

 }

+int mlx4_dereg_mr_relaxed(struct ibv_mr *mr)

+{

+	int ret;

+

+	ret = ibv_cmd_dereg_mr_relaxed(mr);

+	if (ret)

+		return ret;

+

+	free(mr);

+	return 0;

+}

+

+int mlx4_flush_relaxed_mr(struct ibv_pd *pd)

+{

+	int ret;

+

+	ret = ibv_cmd_flush_relaxed_mr(pd);

+	if (ret)

+		return ret;

+

+	return 0;

+}

+

 static int align_queue_size(int req)

 {

 	int nent;

 	struct mlx4_create_cq_resp resp;

 	struct mlx4_cq		  *cq;

 	int			   ret;

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

+	void                      *cqbuf;

+#endif

 	/* Sanity check CQ size before proceeding */

 	if (cqe > 0x3fffff)

 	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);

 	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 (ret)

 		goto err_db;

 	cq->cqn = resp.cqn;

+        /*

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

+	 *  mapping the CQ memory it allocated.

+         */

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

+		goto err_destroy;

+	}

+

+

+        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).

+         */

+	cq->buf.buf    = cqbuf;

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

+

+	/*

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

+	 * 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),

+        if (cq->set_ci_db == NULL)

+                goto err_buf;

+

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

+        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:

 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);

 	struct mlx4_resize_cq cmd;

 	struct mlx4_buf buf;

 	int old_cqe, outst_cqe, ret;

-

+#endif

 	/* Sanity check CQ size before proceeding */

 	if (cqe > 0x3fffff)

-		return EINVAL;

+ 		return EINVAL;

 	pthread_spin_lock(&cq->lock);

 		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;

+#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);

 		goto out;

 	}

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

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

+        mlx4_free_buf(&cq->buf);

+        cq->buf = buf;

+#else

+		goto out;

+	}

+        if (cq->buf.buf != NULL) {

+        	buf.buf = malloc(cq->buf.length);

+        	if (!buf.buf) {

+                	ret = ENOMEM;

+                	goto out;

+        	}

-	mlx4_free_buf(&cq->buf);

-	cq->buf = buf;

+        	memcpy(buf.buf, cq->buf.buf, cq->buf.length);

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

+                ret = munmap((char *)cq->buf.buf, cq->buf.length);

+                if (ret) {

+                        free(buf.buf);

+                        goto out;

+                }

+        }

+	/*

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

+	 * mapping the CQ memory it allocated.

+	 */

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

+		ret = EINVAL;

+		goto out;

+	}

+

+	if (cqbuf == MAP_FAILED) {

+		ret = EINVAL;

+		goto out;

+	}

+	cq->buf.buf    = buf.buf;

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

+	mlx4_cq_resize_copy_cqes(cq, cqbuf, old_cqe);

+	cq->buf.buf    = cqbuf;

+	free(buf.buf);

+#endif

 out:

 	pthread_spin_unlock(&cq->lock);

 	return ret;

 		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));

 	struct mlx4_create_srq_resp resp;

 	struct mlx4_srq		   *srq;

 	int			    ret;

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

+	void                       *srqbuf;

+#endif