D41105.diff
No OneTemporary
Actions

Size

34 KB

Referenced Files

None

Subscribers

None

D41105.diff
View Options

	diff --git a/contrib/ofed/libcxgb4/dev.c b/contrib/ofed/libcxgb4/dev.c
	--- a/contrib/ofed/libcxgb4/dev.c
	+++ b/contrib/ofed/libcxgb4/dev.c
	@@ -519,7 +519,9 @@
	return NULL;
	}

	- pthread_spin_init(&dev->lock, PTHREAD_PROCESS_PRIVATE);
	+ if (pthread_spin_init(&dev->lock, PTHREAD_PROCESS_PRIVATE))
	+ goto err;
	+
	dev->ibv_dev.ops = &c4iw_dev_ops;
	dev->chip_version = CHELSIO_CHIP_VERSION(hca_table[i].device >> 8);
	dev->abi_version = abi_version;
	@@ -554,6 +556,11 @@
	}

	return &dev->ibv_dev;
	+
	+err:
	+ free(dev);
	+
	+ return NULL;
	}

	static __attribute__((constructor)) void cxgb4_register_driver(void)
	diff --git a/contrib/ofed/libcxgb4/verbs.c b/contrib/ofed/libcxgb4/verbs.c
	--- a/contrib/ofed/libcxgb4/verbs.c
	+++ b/contrib/ofed/libcxgb4/verbs.c
	@@ -190,7 +190,9 @@
	PDBG("%s c4iw_create_cq_resp reserved field modified by kernel\n",
	__FUNCTION__);

	- pthread_spin_init(&chp->lock, PTHREAD_PROCESS_PRIVATE);
	+ ret = pthread_spin_init(&chp->lock, PTHREAD_PROCESS_PRIVATE);
	+ if (ret)
	+ goto err2;
	#ifdef STALL_DETECTION
	gettimeofday(&chp->time, NULL);
	#endif
	@@ -203,12 +205,12 @@
	chp->cq.queue = mmap(NULL, chp->cq.memsize, PROT_READ\|PROT_WRITE,
	MAP_SHARED, context->cmd_fd, resp.key);
	if (chp->cq.queue == MAP_FAILED)
	- goto err2;
	+ goto err3;

	chp->cq.ugts = mmap(NULL, c4iw_page_size, PROT_WRITE, MAP_SHARED,
	context->cmd_fd, resp.gts_key);
	if (chp->cq.ugts == MAP_FAILED)
	- goto err3;
	+ goto err4;

	if (dev_is_t4(chp->rhp))
	chp->cq.ugts += 1;
	@@ -216,7 +218,7 @@
	chp->cq.ugts += 5;
	chp->cq.sw_queue = calloc(chp->cq.size, sizeof *chp->cq.queue);
	if (!chp->cq.sw_queue)
	- goto err4;
	+ goto err5;

	PDBG("%s cqid 0x%x key %" PRIx64 " va %p memsize %lu gts_key %"
	PRIx64 " va %p qid_mask 0x%x\n",
	@@ -228,10 +230,12 @@
	pthread_spin_unlock(&dev->lock);
	INC_STAT(cq);
	return &chp->ibv_cq;
	-err4:
	+err5:
	munmap(MASKED(chp->cq.ugts), c4iw_page_size);
	-err3:
	+err4:
	munmap(chp->cq.queue, chp->cq.memsize);
	+err3:
	+ pthread_spin_destroy(&chp->lock);
	err2:
	(void)ibv_cmd_destroy_cq(&chp->ibv_cq);
	err1:
	@@ -265,6 +269,7 @@
	if (ret) {
	return ret;
	}
	+ verbs_cleanup_cq(ibcq);
	munmap(MASKED(chp->cq.ugts), c4iw_page_size);
	munmap(chp->cq.queue, chp->cq.memsize);

	@@ -273,6 +278,7 @@
	pthread_spin_unlock(&dev->lock);

	free(chp->cq.sw_queue);
	+ pthread_spin_destroy(&chp->lock);
	free(chp);
	return 0;
	}
	@@ -337,38 +343,40 @@
	qhp->wq.rq.qid = resp.rqid;
	qhp->wq.rq.size = resp.rq_size;
	qhp->wq.rq.memsize = resp.rq_memsize;
	- pthread_spin_init(&qhp->lock, PTHREAD_PROCESS_PRIVATE);
	+ ret = pthread_spin_init(&qhp->lock, PTHREAD_PROCESS_PRIVATE);
	+ if (ret)
	+ goto err3;

	dbva = mmap(NULL, c4iw_page_size, PROT_WRITE, MAP_SHARED,
	pd->context->cmd_fd, resp.sq_db_gts_key);
	if (dbva == MAP_FAILED)
	- goto err3;
	+ goto err4;

	qhp->wq.sq.udb = dbva;
	qhp->wq.sq.queue = mmap(NULL, qhp->wq.sq.memsize,
	PROT_WRITE, MAP_SHARED,
	pd->context->cmd_fd, resp.sq_key);
	if (qhp->wq.sq.queue == MAP_FAILED)
	- goto err4;
	+ goto err5;

	dbva = mmap(NULL, c4iw_page_size, PROT_WRITE, MAP_SHARED,
	pd->context->cmd_fd, resp.rq_db_gts_key);
	if (dbva == MAP_FAILED)
	- goto err5;
	+ goto err6;
	qhp->wq.rq.udb = dbva;
	qhp->wq.rq.queue = mmap(NULL, qhp->wq.rq.memsize,
	PROT_WRITE, MAP_SHARED,
	pd->context->cmd_fd, resp.rq_key);
	if (qhp->wq.rq.queue == MAP_FAILED)
	- goto err6;
	+ goto err7;

	qhp->wq.sq.sw_sq = calloc(qhp->wq.sq.size, sizeof (struct t4_swsqe));
	if (!qhp->wq.sq.sw_sq)
	- goto err7;
	+ goto err8;

	qhp->wq.rq.sw_rq = calloc(qhp->wq.rq.size, sizeof (uint64_t));
	if (!qhp->wq.rq.sw_rq)
	- goto err8;
	+ goto err9;

	PDBG("%s sq dbva %p sq qva %p sq depth %u sq memsize %lu "
	" rq dbva %p rq qva %p rq depth %u rq memsize %lu\n",
	@@ -385,16 +393,18 @@
	pthread_spin_unlock(&dev->lock);
	INC_STAT(qp);
	return &qhp->ibv_qp;
	-err8:
	+err9:
	free(qhp->wq.sq.sw_sq);
	-err7:
	+err8:
	munmap((void *)qhp->wq.rq.queue, qhp->wq.rq.memsize);
	-err6:
	+err7:
	munmap(MASKED(qhp->wq.rq.udb), c4iw_page_size);
	-err5:
	+err6:
	munmap((void *)qhp->wq.sq.queue, qhp->wq.sq.memsize);
	-err4:
	+err5:
	munmap(MASKED(qhp->wq.sq.udb), c4iw_page_size);
	+err4:
	+ pthread_spin_destroy(&qhp->lock);
	err3:
	(void)ibv_cmd_destroy_qp(&qhp->ibv_qp);
	err2:
	@@ -448,12 +458,14 @@
	fprintf(stderr, "libcxgb4 warning - downlevel iw_cxgb4 driver. "
	"MA workaround disabled.\n");
	}
	- pthread_spin_init(&qhp->lock, PTHREAD_PROCESS_PRIVATE);
	+ ret = pthread_spin_init(&qhp->lock, PTHREAD_PROCESS_PRIVATE);
	+ if (ret)
	+ goto err3;

	dbva = mmap(NULL, c4iw_page_size, PROT_WRITE, MAP_SHARED,
	pd->context->cmd_fd, resp.sq_db_gts_key);
	if (dbva == MAP_FAILED)
	- goto err3;
	+ goto err4;
	qhp->wq.sq.udb = dbva;
	if (!dev_is_t4(qhp->rhp)) {
	unsigned long segment_offset = 128 * (qhp->wq.sq.qid &
	@@ -471,12 +483,12 @@
	PROT_READ\|PROT_WRITE, MAP_SHARED,
	pd->context->cmd_fd, resp.sq_key);
	if (qhp->wq.sq.queue == MAP_FAILED)
	- goto err4;
	+ goto err5;

	dbva = mmap(NULL, c4iw_page_size, PROT_WRITE, MAP_SHARED,
	pd->context->cmd_fd, resp.rq_db_gts_key);
	if (dbva == MAP_FAILED)
	- goto err5;
	+ goto err6;
	qhp->wq.rq.udb = dbva;
	if (!dev_is_t4(qhp->rhp)) {
	unsigned long segment_offset = 128 * (qhp->wq.rq.qid &
	@@ -493,22 +505,22 @@
	PROT_READ\|PROT_WRITE, MAP_SHARED,
	pd->context->cmd_fd, resp.rq_key);
	if (qhp->wq.rq.queue == MAP_FAILED)
	- goto err6;
	+ goto err7;

	qhp->wq.sq.sw_sq = calloc(qhp->wq.sq.size, sizeof (struct t4_swsqe));
	if (!qhp->wq.sq.sw_sq)
	- goto err7;
	+ goto err8;

	qhp->wq.rq.sw_rq = calloc(qhp->wq.rq.size, sizeof (uint64_t));
	if (!qhp->wq.rq.sw_rq)
	- goto err8;
	+ goto err9;

	if (t4_sq_onchip(&qhp->wq)) {
	qhp->wq.sq.ma_sync = mmap(NULL, c4iw_page_size, PROT_WRITE,
	MAP_SHARED, pd->context->cmd_fd,
	resp.ma_sync_key);
	if (qhp->wq.sq.ma_sync == MAP_FAILED)
	- goto err9;
	+ goto err10;
	qhp->wq.sq.ma_sync += (A_PCIE_MA_SYNC & (c4iw_page_size - 1));
	}

	@@ -534,18 +546,20 @@
	pthread_spin_unlock(&dev->lock);
	INC_STAT(qp);
	return &qhp->ibv_qp;
	-err9:
	+err10:
	free(qhp->wq.rq.sw_rq);
	-err8:
	+err9:
	free(qhp->wq.sq.sw_sq);
	-err7:
	+err8:
	munmap((void *)qhp->wq.rq.queue, qhp->wq.rq.memsize);
	-err6:
	+err7:
	munmap(MASKED(qhp->wq.rq.udb), c4iw_page_size);
	-err5:
	+err6:
	munmap((void *)qhp->wq.sq.queue, qhp->wq.sq.memsize);
	-err4:
	+err5:
	munmap(MASKED(qhp->wq.sq.udb), c4iw_page_size);
	+err4:
	+ pthread_spin_destroy(&qhp->lock);
	err3:
	(void)ibv_cmd_destroy_qp(&qhp->ibv_qp);
	err2:
	@@ -625,6 +639,7 @@

	free(qhp->wq.rq.sw_rq);
	free(qhp->wq.sq.sw_sq);
	+ pthread_spin_destroy(&qhp->lock);
	free(qhp);
	return 0;
	}
	diff --git a/contrib/ofed/libibcm/cm.c b/contrib/ofed/libibcm/cm.c
	--- a/contrib/ofed/libibcm/cm.c
	+++ b/contrib/ofed/libibcm/cm.c
	@@ -232,7 +232,8 @@
	memset(cm_id_priv, 0, sizeof *cm_id_priv);
	cm_id_priv->id.device = device;
	cm_id_priv->id.context = context;
	- pthread_mutex_init(&cm_id_priv->mut, NULL);
	+ if (pthread_mutex_init(&cm_id_priv->mut, NULL))
	+ goto err;
	if (pthread_cond_init(&cm_id_priv->cond, NULL))
	goto err;

	diff --git a/contrib/ofed/libibverbs/cmd.c b/contrib/ofed/libibverbs/cmd.c
	--- a/contrib/ofed/libibverbs/cmd.c
	+++ b/contrib/ofed/libibverbs/cmd.c
	@@ -679,6 +679,7 @@
	struct ibv_create_srq_resp *resp, size_t resp_size)
	{
	struct verbs_xrcd *vxrcd = NULL;
	+ int ret = 0;

	IBV_INIT_CMD_RESP(cmd, cmd_size, CREATE_XSRQ, resp, resp_size);

	@@ -705,8 +706,17 @@
	cmd->cq_handle = attr_ex->cq->handle;
	}

	- if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
	- return errno;
	+ ret = pthread_mutex_init(&srq->srq.mutex, NULL);
	+ if (ret)
	+ goto err;
	+ ret = pthread_cond_init(&srq->srq.cond, NULL);
	+ if (ret)
	+ goto err_mutex;
	+
	+ if (write(context->cmd_fd, cmd, cmd_size) != cmd_size) {
	+ ret = errno;
	+ goto err_cond;
	+ }

	(void) VALGRIND_MAKE_MEM_DEFINED(resp, resp_size);

	@@ -715,8 +725,6 @@
	srq->srq.srq_context = attr_ex->srq_context;
	srq->srq.pd = attr_ex->pd;
	srq->srq.events_completed = 0;
	- pthread_mutex_init(&srq->srq.mutex, NULL);
	- pthread_cond_init(&srq->srq.cond, NULL);

	/*
	* check that the last field is available.
	@@ -744,6 +752,12 @@
	attr_ex->attr.max_sge = resp->max_sge;

	return 0;
	+err_cond:
	+ pthread_cond_destroy(&srq->srq.cond);
	+err_mutex:
	+ pthread_mutex_destroy(&srq->srq.mutex);
	+err:
	+ return ret;
	}


	@@ -837,6 +851,9 @@
	pthread_cond_wait(&srq->cond, &srq->mutex);
	pthread_mutex_unlock(&srq->mutex);

	+ pthread_cond_destroy(&srq->cond);
	+ pthread_mutex_destroy(&srq->mutex);
	+
	return 0;
	}

	@@ -887,6 +904,31 @@
	return 0;
	}

	+static int create_qp_handle_resp_common_cleanup(struct verbs_qp *qp)
	+{
	+ pthread_cond_destroy(&qp->qp.cond);
	+ pthread_mutex_destroy(&qp->qp.mutex);
	+}
	+
	+static int create_qp_handle_resp_common_init(struct verbs_qp *qp)
	+{
	+ int ret = 0;
	+
	+ ret = pthread_mutex_init(&qp->qp.mutex, NULL);
	+ if (ret)
	+ return ret;
	+ ret = pthread_cond_init(&qp->qp.cond, NULL);
	+ if (ret)
	+ goto err;
	+
	+ return ret;
	+
	+err:
	+ pthread_mutex_destroy(&qp->qp.mutex);
	+
	+ return ret;
	+}
	+
	static void create_qp_handle_resp_common(struct ibv_context *context,
	struct verbs_qp *qp,
	struct ibv_qp_init_attr_ex *qp_attr,
	@@ -913,8 +955,6 @@
	qp->qp.qp_type = qp_attr->qp_type;
	qp->qp.state = IBV_QPS_RESET;
	qp->qp.events_completed = 0;
	- pthread_mutex_init(&qp->qp.mutex, NULL);
	- pthread_cond_init(&qp->qp.cond, NULL);

	qp->comp_mask = 0;
	if (vext_field_avail(struct verbs_qp, xrcd, vqp_sz) &&
	@@ -977,9 +1017,15 @@
	cmd->comp_mask = IBV_CREATE_QP_EX_KERNEL_MASK_IND_TABLE;
	}

	+ err = create_qp_handle_resp_common_init(qp);
	+ if (err)
	+ return err;
	+
	err = write(context->cmd_fd, cmd, cmd_size);
	- if (err != cmd_size)
	- return errno;
	+ if (err != cmd_size) {
	+ err = errno;
	+ goto err;
	+ }

	(void)VALGRIND_MAKE_MEM_DEFINED(resp, resp_size);

	@@ -987,6 +1033,11 @@
	vqp_sz);

	return 0;
	+
	+err:
	+ create_qp_handle_resp_common_cleanup(qp);
	+
	+ return err;
	}

	int ibv_cmd_create_qp_ex(struct ibv_context *context,
	@@ -1008,8 +1059,15 @@
	if (err)
	return err;

	- if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
	- return errno;
	+ err = create_qp_handle_resp_common_init(qp);
	+ if (err)
	+ return err;
	+
	+ err = write(context->cmd_fd, cmd, cmd_size);
	+ if (err != cmd_size) {
	+ err = errno;
	+ goto err;
	+ }

	(void)VALGRIND_MAKE_MEM_DEFINED(resp, resp_size);

	@@ -1032,6 +1090,11 @@
	create_qp_handle_resp_common(context, qp, attr_ex, resp, vxrcd, vqp_sz);

	return 0;
	+
	+err:
	+ create_qp_handle_resp_common_cleanup(qp);
	+
	+ return err;
	}

	int ibv_cmd_create_qp(struct ibv_pd *pd,
	@@ -1098,6 +1161,7 @@
	struct ibv_open_qp *cmd, size_t cmd_size,
	struct ibv_create_qp_resp *resp, size_t resp_size)
	{
	+ int err = 0;
	struct verbs_xrcd *xrcd;
	IBV_INIT_CMD_RESP(cmd, cmd_size, OPEN_QP, resp, resp_size);

	@@ -1115,8 +1179,18 @@
	cmd->qpn = attr->qp_num;
	cmd->qp_type = attr->qp_type;

	- if (write(context->cmd_fd, cmd, cmd_size) != cmd_size)
	- return errno;
	+ err = pthread_mutex_init(&qp->qp.mutex, NULL);
	+ if (err)
	+ return err;
	+ err = pthread_cond_init(&qp->qp.cond, NULL);
	+ if (err)
	+ goto err_mutex;
	+
	+ err = write(context->cmd_fd, cmd, cmd_size);
	+ if (err != cmd_size) {
	+ err = errno;
	+ goto err_cond;
	+ }

	(void) VALGRIND_MAKE_MEM_DEFINED(resp, resp_size);

	@@ -1131,8 +1205,6 @@
	qp->qp.qp_type = attr->qp_type;
	qp->qp.state = IBV_QPS_UNKNOWN;
	qp->qp.events_completed = 0;
	- pthread_mutex_init(&qp->qp.mutex, NULL);
	- pthread_cond_init(&qp->qp.cond, NULL);
	qp->comp_mask = 0;
	if (vext_field_avail(struct verbs_qp, xrcd, vqp_sz)) {
	qp->comp_mask = VERBS_QP_XRCD;
	@@ -1140,6 +1212,13 @@
	}

	return 0;
	+
	+err_cond:
	+ pthread_cond_destroy(&qp->qp.cond);
	+err_mutex:
	+ pthread_mutex_destroy(&qp->qp.mutex);
	+
	+ return err;
	}

	int ibv_cmd_query_qp(struct ibv_qp qp, struct ibv_qp_attr attr,
	@@ -1644,6 +1723,9 @@
	pthread_cond_wait(&qp->cond, &qp->mutex);
	pthread_mutex_unlock(&qp->mutex);

	+ pthread_cond_destroy(&qp->cond);
	+ pthread_mutex_destroy(&qp->mutex);
	+
	return 0;
	}

	diff --git a/contrib/ofed/libibverbs/device.c b/contrib/ofed/libibverbs/device.c
	--- a/contrib/ofed/libibverbs/device.c
	+++ b/contrib/ofed/libibverbs/device.c
	@@ -132,13 +132,22 @@
	}
	default_symver(__ibv_get_device_guid, ibv_get_device_guid);

	-void verbs_init_cq(struct ibv_cq cq, struct ibv_context context,
	+int verbs_init_cq(struct ibv_cq cq, struct ibv_context context,
	struct ibv_comp_channel *channel,
	void *cq_context)
	{
	+ int err = 0;
	+
	cq->context = context;
	cq->channel = channel;

	+ err = pthread_mutex_init(&cq->mutex, NULL);
	+ if (err)
	+ return err;
	+ err = pthread_cond_init(&cq->cond, NULL);
	+ if (err)
	+ goto err;
	+
	if (cq->channel) {
	pthread_mutex_lock(&context->mutex);
	++cq->channel->refcnt;
	@@ -148,8 +157,19 @@
	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 err;
	+
	+err:
	+ pthread_mutex_destroy(&cq->mutex);
	+
	+ return err;
	+}
	+
	+void verbs_cleanup_cq(struct ibv_cq *cq)
	+{
	+ pthread_cond_destroy(&cq->cond);
	+ pthread_mutex_destroy(&cq->mutex);
	}

	static struct ibv_cq_ex *
	@@ -158,6 +178,7 @@
	{
	struct verbs_context *vctx = verbs_get_ctx(context);
	struct ibv_cq_ex *cq;
	+ int err = 0;

	if (cq_attr->wc_flags & ~IBV_CREATE_CQ_SUP_WC_FLAGS) {
	errno = EOPNOTSUPP;
	@@ -165,12 +186,20 @@
	}

	cq = vctx->priv->create_cq_ex(context, cq_attr);
	+ if (!cq)
	+ return NULL;

	- if (cq)
	- verbs_init_cq(ibv_cq_ex_to_cq(cq), context,
	- cq_attr->channel, cq_attr->cq_context);
	+ err = verbs_init_cq(ibv_cq_ex_to_cq(cq), context,
	+ cq_attr->channel, cq_attr->cq_context);
	+ if (err)
	+ goto err;

	return cq;
	+
	+err:
	+ context->ops.destroy_cq(ibv_cq_ex_to_cq(cq));
	+
	+ return NULL;
	}

	struct ibv_context __ibv_open_device(struct ibv_device device)
	@@ -198,6 +227,11 @@
	context = verbs_device->ops->alloc_context(device, cmd_fd);
	if (!context)
	goto err;
	+
	+ if (pthread_mutex_init(&context->mutex, NULL)) {
	+ verbs_device->ops->free_context(context);
	+ goto err;
	+ }
	} else {
	struct verbs_ex_private *priv;

	@@ -212,8 +246,7 @@
	priv = calloc(1, sizeof(*priv));
	if (!priv) {
	errno = ENOMEM;
	- free(context_ex);
	- goto err;
	+ goto err_context;
	}

	context_ex->priv = priv;
	@@ -221,9 +254,12 @@
	context_ex->sz = sizeof(*context_ex);

	context = &context_ex->context;
	+ if (pthread_mutex_init(&context->mutex, NULL))
	+ goto verbs_err;
	+
	ret = verbs_device->ops->init_context(verbs_device, context, cmd_fd);
	if (ret)
	- goto verbs_err;
	+ goto err_mutex;
	/*
	* In order to maintain backward/forward binary compatibility
	* with apps compiled against libibverbs-1.1.8 that use the
	@@ -247,12 +283,14 @@

	context->device = device;
	context->cmd_fd = cmd_fd;
	- pthread_mutex_init(&context->mutex, NULL);

	return context;

	+err_mutex:
	+ pthread_mutex_destroy(&context->mutex);
	verbs_err:
	free(context_ex->priv);
	+err_context:
	free(context_ex);
	err:
	close(cmd_fd);
	@@ -267,6 +305,7 @@
	struct verbs_context *context_ex;
	struct verbs_device *verbs_device = verbs_get_device(context->device);

	+ pthread_mutex_destroy(&context->mutex);
	context_ex = verbs_get_ctx(context);
	if (context_ex) {
	verbs_device->ops->uninit_context(verbs_device, context);
	@@ -393,3 +432,31 @@
	}
	}
	default_symver(__ibv_ack_async_event, ibv_ack_async_event);
	+
	+int __ibv_init_wq(struct ibv_wq *wq)
	+{
	+ int err = 0;
	+ wq->events_completed = 0;
	+ err = pthread_mutex_init(&wq->mutex, NULL);
	+ if (err)
	+ return err;
	+
	+ err = pthread_cond_init(&wq->cond, NULL);
	+ if (err)
	+ goto err;
	+
	+ return err;
	+
	+err:
	+ pthread_mutex_destroy(&wq->mutex);
	+
	+ return err;
	+}
	+default_symver(__ibv_init_wq, ibv_init_wq);
	+
	+void __ibv_cleanup_wq(struct ibv_wq *wq)
	+{
	+ pthread_cond_destroy(&wq->mutex);
	+ pthread_mutex_destroy(&wq->mutex);
	+}
	+default_symver(__ibv_cleanup_wq, ibv_cleanup_wq);
	diff --git a/contrib/ofed/libibverbs/driver.h b/contrib/ofed/libibverbs/driver.h
	--- a/contrib/ofed/libibverbs/driver.h
	+++ b/contrib/ofed/libibverbs/driver.h
	@@ -130,9 +130,12 @@
	typedef struct verbs_device (verbs_driver_init_func)(const char *uverbs_sys_path,
	int abi_version);
	void verbs_register_driver(const char *name, verbs_driver_init_func init_func);
	-void verbs_init_cq(struct ibv_cq cq, struct ibv_context context,
	+int verbs_init_cq(struct ibv_cq cq, struct ibv_context context,
	struct ibv_comp_channel *channel,
	void *cq_context);
	+void verbs_cleanup_cq(struct ibv_cq *cq);
	+int ibv_init_wq(struct ibv_wq *wq);
	+void ibv_cleanup_wq(struct ibv_wq *wq);

	int ibv_cmd_get_context(struct ibv_context context, struct ibv_get_context cmd,
	size_t cmd_size, struct ibv_get_context_resp *resp,
	diff --git a/contrib/ofed/libibverbs/libibverbs.map b/contrib/ofed/libibverbs/libibverbs.map
	--- a/contrib/ofed/libibverbs/libibverbs.map
	+++ b/contrib/ofed/libibverbs/libibverbs.map
	@@ -136,4 +136,7 @@
	ibv_query_gid_type;
	verbs_register_driver;
	verbs_init_cq;
	+ verbs_cleanup_cq;
	+ ibv_init_wq;
	+ ibv_cleanup_wq;
	};
	diff --git a/contrib/ofed/libibverbs/verbs.h b/contrib/ofed/libibverbs/verbs.h
	--- a/contrib/ofed/libibverbs/verbs.h
	+++ b/contrib/ofed/libibverbs/verbs.h
	@@ -2166,11 +2166,8 @@
	}

	wq = vctx->create_wq(context, wq_init_attr);
	- if (wq) {
	+ if (wq)
	wq->events_completed = 0;
	- pthread_mutex_init(&wq->mutex, NULL);
	- pthread_cond_init(&wq->cond, NULL);
	- }

	return wq;
	}
	diff --git a/contrib/ofed/libibverbs/verbs.c b/contrib/ofed/libibverbs/verbs.c
	--- a/contrib/ofed/libibverbs/verbs.c
	+++ b/contrib/ofed/libibverbs/verbs.c
	@@ -455,13 +455,23 @@
	struct ibv_comp_channel *channel, int comp_vector)
	{
	struct ibv_cq *cq;
	+ int err = 0;

	cq = context->ops.create_cq(context, cqe, channel, comp_vector);

	- if (cq)
	- verbs_init_cq(cq, context, channel, cq_context);
	+ if (!cq)
	+ return NULL;
	+
	+ err = verbs_init_cq(cq, context, channel, cq_context);
	+ if (err)
	+ goto err;

	return cq;
	+
	+err:
	+ context->ops.destroy_cq(cq);
	+
	+ return NULL;
	}
	default_symver(__ibv_create_cq, ibv_create_cq);

	@@ -529,16 +539,26 @@
	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);
	- }
	+ if (!srq)
	+ return NULL;
	+
	+ srq->context = pd->context;
	+ srq->srq_context = srq_init_attr->srq_context;
	+ srq->pd = pd;
	+ srq->events_completed = 0;
	+ if (pthread_mutex_init(&srq->mutex, NULL))
	+ goto err;
	+ if (pthread_cond_init(&srq->cond, NULL))
	+ goto err_mutex;

	return srq;
	+
	+err_mutex:
	+ pthread_mutex_destroy(&srq->mutex);
	+err:
	+ pd->context->ops.destroy_srq(srq);
	+
	+ return NULL;
	}
	default_symver(__ibv_create_srq, ibv_create_srq);

	@@ -558,6 +578,8 @@

	int __ibv_destroy_srq(struct ibv_srq *srq)
	{
	+ pthread_cond_destroy(&srq->cond);
	+ pthread_mutex_destroy(&srq->mutex);
	return srq->context->ops.destroy_srq(srq);
	}
	default_symver(__ibv_destroy_srq, ibv_destroy_srq);
	diff --git a/contrib/ofed/libmlx4/mlx4.h b/contrib/ofed/libmlx4/mlx4.h
	--- a/contrib/ofed/libmlx4/mlx4.h
	+++ b/contrib/ofed/libmlx4/mlx4.h
	@@ -414,7 +414,8 @@
	int mlx4_destroy_xrc_srq(struct ibv_srq *srq);
	int mlx4_alloc_srq_buf(struct ibv_pd pd, struct ibv_srq_attr attr,
	struct mlx4_srq *srq);
	-void mlx4_init_xsrq_table(struct mlx4_xsrq_table *xsrq_table, int size);
	+void mlx4_cleanup_xsrq_table(struct mlx4_xsrq_table *xsrq_table);
	+int mlx4_init_xsrq_table(struct mlx4_xsrq_table *xsrq_table, int size);
	struct mlx4_srq mlx4_find_xsrq(struct mlx4_xsrq_table xsrq_table, uint32_t srqn);
	int mlx4_store_xsrq(struct mlx4_xsrq_table *xsrq_table, uint32_t srqn,
	struct mlx4_srq *srq);
	diff --git a/contrib/ofed/libmlx4/mlx4.c b/contrib/ofed/libmlx4/mlx4.c
	--- a/contrib/ofed/libmlx4/mlx4.c
	+++ b/contrib/ofed/libmlx4/mlx4.c
	@@ -147,6 +147,7 @@
	struct ibv_get_context cmd;
	struct mlx4_alloc_ucontext_resp resp;
	int i;
	+ int ret;
	struct mlx4_alloc_ucontext_resp_v3 resp_v3;
	__u16 bf_reg_size;
	struct mlx4_device *dev = to_mdev(&v_device->device);
	@@ -185,15 +186,22 @@
	for (i = 0; i < MLX4_PORTS_NUM; ++i)
	context->port_query_cache[i].valid = 0;

	- pthread_mutex_init(&context->qp_table_mutex, NULL);
	+ ret = pthread_mutex_init(&context->qp_table_mutex, NULL);
	+ if (ret)
	+ return ret;
	for (i = 0; i < MLX4_QP_TABLE_SIZE; ++i)
	context->qp_table[i].refcnt = 0;

	for (i = 0; i < MLX4_NUM_DB_TYPE; ++i)
	context->db_list[i] = NULL;

	- mlx4_init_xsrq_table(&context->xsrq_table, context->num_qps);
	- pthread_mutex_init(&context->db_list_mutex, NULL);
	+ ret = mlx4_init_xsrq_table(&context->xsrq_table, context->num_qps);
	+ if (ret)
	+ goto err;
	+
	+ ret = pthread_mutex_init(&context->db_list_mutex, NULL);
	+ if (ret)
	+ goto err_xsrq;

	context->uar = mmap(NULL, dev->page_size, PROT_WRITE,
	MAP_SHARED, cmd_fd, 0);
	@@ -212,14 +220,18 @@
	} else {
	context->bf_buf_size = bf_reg_size / 2;
	context->bf_offset = 0;
	- pthread_spin_init(&context->bf_lock, PTHREAD_PROCESS_PRIVATE);
	+ ret = pthread_spin_init(&context->bf_lock, PTHREAD_PROCESS_PRIVATE);
	+ if (ret)
	+ goto err_db_list;
	}
	} else {
	context->bf_page = NULL;
	context->bf_buf_size = 0;
	}

	- pthread_spin_init(&context->uar_lock, PTHREAD_PROCESS_PRIVATE);
	+ ret = pthread_spin_init(&context->uar_lock, PTHREAD_PROCESS_PRIVATE);
	+ if (ret)
	+ goto err_bf_lock;
	ibv_ctx->ops = mlx4_ctx_ops;

	context->hca_core_clock = NULL;
	@@ -248,6 +260,17 @@

	return 0;

	+err_bf_lock:
	+ if (context->bf_buf_size)
	+ pthread_spin_destroy(&context->bf_lock);
	+err_db_list:
	+ pthread_mutex_destroy(&context->db_list_mutex);
	+err_xsrq:
	+ mlx4_cleanup_xsrq_table(&context->xsrq_table);
	+err:
	+ pthread_mutex_destroy(&context->qp_table_mutex);
	+
	+ return ret;
	}

	static void mlx4_uninit_context(struct verbs_device *v_device,
	@@ -255,6 +278,12 @@
	{
	struct mlx4_context *context = to_mctx(ibv_ctx);

	+ pthread_mutex_destroy(&context->qp_table_mutex);
	+ mlx4_cleanup_xsrq_table(&context->xsrq_table);
	+ pthread_mutex_destroy(&context->db_list_mutex);
	+ pthread_spin_destroy(&context->bf_lock);
	+ pthread_spin_destroy(&context->uar_lock);
	+
	munmap(context->uar, to_mdev(&v_device->device)->page_size);
	if (context->bf_page)
	munmap(context->bf_page, to_mdev(&v_device->device)->page_size);
	diff --git a/contrib/ofed/libmlx4/srq.c b/contrib/ofed/libmlx4/srq.c
	--- a/contrib/ofed/libmlx4/srq.c
	+++ b/contrib/ofed/libmlx4/srq.c
	@@ -172,14 +172,20 @@
	return 0;
	}

	-void mlx4_init_xsrq_table(struct mlx4_xsrq_table *xsrq_table, int size)
	+void mlx4_cleanup_xsrq_table(struct mlx4_xsrq_table *xsrq_table)
	{
	+ pthread_mutex_destroy(&xsrq_table->mutex);
	+}
	+
	+int mlx4_init_xsrq_table(struct mlx4_xsrq_table *xsrq_table, int size)
	+{
	+ int ret;
	memset(xsrq_table, 0, sizeof *xsrq_table);
	xsrq_table->num_xsrq = size;
	xsrq_table->shift = ffs(size) - 1 - MLX4_XSRQ_TABLE_BITS;
	xsrq_table->mask = (1 << xsrq_table->shift) - 1;

	- pthread_mutex_init(&xsrq_table->mutex, NULL);
	+ return pthread_mutex_init(&xsrq_table->mutex, NULL);
	}

	struct mlx4_srq mlx4_find_xsrq(struct mlx4_xsrq_table xsrq_table, uint32_t srqn)
	@@ -257,7 +263,7 @@
	srq->ext_srq = 1;

	if (mlx4_alloc_srq_buf(attr_ex->pd, &attr_ex->attr, srq))
	- goto err;
	+ goto err_spl;

	srq->db = mlx4_alloc_db(to_mctx(context), MLX4_DB_TYPE_RQ);
	if (!srq->db)
	@@ -290,6 +296,8 @@
	err_free:
	free(srq->wrid);
	mlx4_free_buf(&srq->buf);
	+err_spl:
	+ pthread_spin_destroy(&srq->lock);
	err:
	free(srq);
	return NULL;
	@@ -319,6 +327,7 @@
	mlx4_free_db(mctx, MLX4_DB_TYPE_RQ, msrq->db);
	mlx4_free_buf(&msrq->buf);
	free(msrq->wrid);
	+ pthread_spin_destroy(&msrq->lock);
	free(msrq);

	return 0;
	diff --git a/contrib/ofed/libmlx4/verbs.c b/contrib/ofed/libmlx4/verbs.c
	--- a/contrib/ofed/libmlx4/verbs.c
	+++ b/contrib/ofed/libmlx4/verbs.c
	@@ -497,7 +497,7 @@
	cq_attr->cqe = align_queue_size(cq_attr->cqe + 1);

	if (mlx4_alloc_cq_buf(to_mdev(context->device), &cq->buf, cq_attr->cqe, mctx->cqe_size))
	- goto err;
	+ goto err_spl;

	cq->cqe_size = mctx->cqe_size;
	cq->set_ci_db = mlx4_alloc_db(to_mctx(context), MLX4_DB_TYPE_CQ);
	@@ -535,6 +535,9 @@
	err_buf:
	mlx4_free_buf(&cq->buf);

	+err_spl:
	+ pthread_spin_destroy(&cq->lock);
	+
	err:
	free(cq);

	@@ -631,6 +634,8 @@
	if (ret)
	return ret;

	+ verbs_cleanup_cq(cq);
	+ pthread_spin_destroy(&to_mcq(cq)->lock);
	mlx4_free_db(to_mctx(cq->context), MLX4_DB_TYPE_CQ, to_mcq(cq)->set_ci_db);
	mlx4_free_buf(&to_mcq(cq)->buf);
	free(to_mcq(cq));
	@@ -663,7 +668,7 @@
	srq->ext_srq = 0;

	if (mlx4_alloc_srq_buf(pd, &attr->attr, srq))
	- goto err;
	+ goto err_spl;

	srq->db = mlx4_alloc_db(to_mctx(pd->context), MLX4_DB_TYPE_RQ);
	if (!srq->db)
	@@ -689,6 +694,9 @@
	free(srq->wrid);
	mlx4_free_buf(&srq->buf);

	+err_spl:
	+ pthread_spin_destroy(&srq->lock);
	+
	err:
	free(srq);

	@@ -738,6 +746,7 @@
	mlx4_free_db(to_mctx(srq->context), MLX4_DB_TYPE_RQ, to_msrq(srq)->db);
	mlx4_free_buf(&to_msrq(srq)->buf);
	free(to_msrq(srq)->wrid);
	+ pthread_spin_destroy(&to_msrq(srq)->lock);
	free(to_msrq(srq));

	return 0;
	@@ -841,14 +850,15 @@

	mlx4_init_qp_indices(qp);

	- if (pthread_spin_init(&qp->sq.lock, PTHREAD_PROCESS_PRIVATE) \|\|
	- pthread_spin_init(&qp->rq.lock, PTHREAD_PROCESS_PRIVATE))
	+ if (pthread_spin_init(&qp->sq.lock, PTHREAD_PROCESS_PRIVATE))
	goto err_free;
	+ if (pthread_spin_init(&qp->rq.lock, PTHREAD_PROCESS_PRIVATE))
	+ goto err_sq_spl;

	if (attr->cap.max_recv_sge) {
	qp->db = mlx4_alloc_db(to_mctx(context), MLX4_DB_TYPE_RQ);
	if (!qp->db)
	- goto err_free;
	+ goto err_rq_spl;

	*qp->db = 0;
	cmd.db_addr = (uintptr_t) qp->db;
	@@ -903,7 +913,10 @@
	pthread_mutex_unlock(&to_mctx(context)->qp_table_mutex);
	if (attr->cap.max_recv_sge)
	mlx4_free_db(to_mctx(context), MLX4_DB_TYPE_RQ, qp->db);
	-
	+err_rq_spl:
	+ pthread_spin_destroy(&qp->rq.lock);
	+err_sq_spl:
	+ pthread_spin_destroy(&qp->sq.lock);
	err_free:
	free(qp->sq.wrid);
	if (qp->rq.wqe_cnt)
	@@ -1108,6 +1121,9 @@
	mlx4_unlock_cqs(ibqp);
	pthread_mutex_unlock(&to_mctx(ibqp->context)->qp_table_mutex);

	+ pthread_spin_destroy(&qp->rq.lock);
	+ pthread_spin_destroy(&qp->sq.lock);
	+
	if (qp->rq.wqe_cnt) {
	mlx4_free_db(to_mctx(ibqp->context), MLX4_DB_TYPE_RQ, qp->db);
	free(qp->rq.wrid);
	diff --git a/contrib/ofed/libmlx5/mlx5.c b/contrib/ofed/libmlx5/mlx5.c
	--- a/contrib/ofed/libmlx5/mlx5.c
	+++ b/contrib/ofed/libmlx5/mlx5.c
	@@ -850,9 +850,12 @@
	context->cmds_supp_uhw = resp.cmds_supp_uhw;
	context->vendor_cap_flags = 0;

	- pthread_mutex_init(&context->qp_table_mutex, NULL);
	- pthread_mutex_init(&context->srq_table_mutex, NULL);
	- pthread_mutex_init(&context->uidx_table_mutex, NULL);
	+ if (pthread_mutex_init(&context->qp_table_mutex, NULL))
	+ goto err_free_bf;
	+ if (pthread_mutex_init(&context->srq_table_mutex, NULL))
	+ goto err_qp_table_mutex;
	+ if (pthread_mutex_init(&context->uidx_table_mutex, NULL))
	+ goto err_srq_table_mutex;
	for (i = 0; i < MLX5_QP_TABLE_SIZE; ++i)
	context->qp_table[i].refcnt = 0;

	@@ -861,7 +864,8 @@

	context->db_list = NULL;

	- pthread_mutex_init(&context->db_list_mutex, NULL);
	+ if (pthread_mutex_init(&context->db_list_mutex, NULL))
	+ goto err_uidx_table_mutex;

	num_sys_page_map = context->tot_uuars / (context->num_uars_per_page * MLX5_NUM_NON_FP_BFREGS_PER_UAR);
	for (i = 0; i < num_sys_page_map; ++i) {
	@@ -872,7 +876,7 @@
	cmd_fd, page_size * offset);
	if (context->uar[i] == MAP_FAILED) {
	context->uar[i] = NULL;
	- goto err_free_bf;
	+ goto err_db_list_mutex;
	}
	}

	@@ -883,7 +887,8 @@
	context->bfs[bfi].reg = context->uar[i] + MLX5_ADAPTER_PAGE_SIZE * j +
	MLX5_BF_OFFSET + k * context->bf_reg_size;
	context->bfs[bfi].need_lock = need_uuar_lock(context, bfi);
	- mlx5_spinlock_init(&context->bfs[bfi].lock);
	+ if (mlx5_spinlock_init(&context->bfs[bfi].lock))
	+ goto err_bfs_spl;
	context->bfs[bfi].offset = 0;
	if (bfi)
	context->bfs[bfi].buf_size = context->bf_reg_size / 2;
	@@ -900,13 +905,15 @@
	mlx5_map_internal_clock(mdev, ctx);
	}

	- mlx5_spinlock_init(&context->lock32);
	+ if (mlx5_spinlock_init(&context->lock32))
	+ goto err_bfs_spl;

	context->prefer_bf = get_always_bf();
	context->shut_up_bf = get_shut_up_bf();
	mlx5_read_env(&vdev->device, context);

	- mlx5_spinlock_init(&context->hugetlb_lock);
	+ if (mlx5_spinlock_init(&context->hugetlb_lock))
	+ goto err_32_spl;
	TAILQ_INIT(&context->hugetlb_list);

	context->ibv_ctx.ops = mlx5_ctx_ops;
	@@ -944,6 +951,31 @@

	return 0;

	+err_32_spl:
	+ mlx5_spinlock_destroy(&context->lock32);
	+
	+err_bfs_spl:
	+ for (i = 0; i < num_sys_page_map; i++) {
	+ for (j = 0; j < context->num_uars_per_page; j++) {
	+ for (k = 0; k < NUM_BFREGS_PER_UAR; k++) {
	+ bfi = (i * context->num_uars_per_page + j) * NUM_BFREGS_PER_UAR + k;
	+ mlx5_spinlock_destroy(&context->bfs[bfi].lock);
	+ }
	+ }
	+ }
	+
	+err_db_list_mutex:
	+ pthread_mutex_destroy(&context->db_list_mutex);
	+
	+err_uidx_table_mutex:
	+ pthread_mutex_destroy(&context->uidx_table_mutex);
	+
	+err_srq_table_mutex:
	+ pthread_mutex_destroy(&context->srq_table_mutex);
	+
	+err_qp_table_mutex:
	+ pthread_mutex_destroy(&context->qp_table_mutex);
	+
	err_free_bf:
	free(context->bfs);

	@@ -962,6 +994,26 @@
	struct mlx5_context *context = to_mctx(ibctx);
	int page_size = to_mdev(ibctx->device)->page_size;
	int i;
	+ int j;
	+ int k;
	+ int bfi;
	+ int num_sys_page_map;
	+
	+ num_sys_page_map = context->tot_uuars / (context->num_uars_per_page * MLX5_NUM_NON_FP_BFREGS_PER_UAR);
	+ for (i = 0; i < num_sys_page_map; i++) {
	+ for (j = 0; j < context->num_uars_per_page; j++) {
	+ for (k = 0; k < NUM_BFREGS_PER_UAR; k++) {
	+ bfi = (i * context->num_uars_per_page + j) * NUM_BFREGS_PER_UAR + k;
	+ mlx5_spinlock_destroy(&context->bfs[bfi].lock);
	+ }
	+ }
	+ }
	+ mlx5_spinlock_destroy(&context->hugetlb_lock);
	+ mlx5_spinlock_destroy(&context->lock32);
	+ pthread_mutex_destroy(&context->db_list_mutex);
	+ pthread_mutex_destroy(&context->uidx_table_mutex);
	+ pthread_mutex_destroy(&context->srq_table_mutex);
	+ pthread_mutex_destroy(&context->qp_table_mutex);

	free(context->bfs);
	for (i = 0; i < MLX5_MAX_UARS; ++i) {
	diff --git a/contrib/ofed/libmlx5/verbs.c b/contrib/ofed/libmlx5/verbs.c
	--- a/contrib/ofed/libmlx5/verbs.c
	+++ b/contrib/ofed/libmlx5/verbs.c
	@@ -517,14 +517,23 @@
	struct mlx5dv_cq_init_attr *mlx5_cq_attr)
	{
	struct ibv_cq_ex *cq;
	+ int err = 0;

	cq = create_cq(context, cq_attr, MLX5_CQ_FLAGS_EXTENDED, mlx5_cq_attr);
	if (!cq)
	return NULL;

	- verbs_init_cq(ibv_cq_ex_to_cq(cq), context,
	+ err = verbs_init_cq(ibv_cq_ex_to_cq(cq), context,
	cq_attr->channel, cq_attr->cq_context);
	+ if (err)
	+ goto err;
	+
	return cq;
	+
	+err:
	+ context->ops.destroy_cq(ibv_cq_ex_to_cq(cq));
	+
	+ return NULL;
	}

	int mlx5_resize_cq(struct ibv_cq *ibcq, int cqe)
	@@ -598,13 +607,16 @@
	int mlx5_destroy_cq(struct ibv_cq *cq)
	{
	int ret;
	+ struct mlx5_cq *mcq = to_mcq(cq);

	ret = ibv_cmd_destroy_cq(cq);
	if (ret)
	return ret;

	+ verbs_cleanup_cq(cq);
	mlx5_free_db(to_mctx(cq->context), to_mcq(cq)->dbrec);
	mlx5_free_cq_buf(to_mctx(cq->context), to_mcq(cq)->active_buf);
	+ mlx5_spinlock_destroy(&mcq->lock);
	free(to_mcq(cq));

	return 0;
	@@ -639,7 +651,7 @@
	fprintf(stderr, "%s-%d:max_wr %d, max_srq_recv_wr %d\n", __func__, __LINE__,
	attr->attr.max_wr, ctx->max_srq_recv_wr);
	errno = EINVAL;
	- goto err;
	+ goto err_spl;
	}

	/*
	@@ -652,7 +664,7 @@
	fprintf(stderr, "%s-%d:max_wr %d, max_srq_recv_wr %d\n", __func__, __LINE__,
	attr->attr.max_wr, ctx->max_srq_recv_wr);
	errno = EINVAL;
	- goto err;
	+ goto err_spl;
	}

	srq->max = align_queue_size(attr->attr.max_wr + 1);
	@@ -661,7 +673,7 @@

	if (mlx5_alloc_srq_buf(pd->context, srq)) {
	fprintf(stderr, "%s-%d:\n", __func__, __LINE__);
	- goto err;
	+ goto err_spl;
	}

	srq->db = mlx5_alloc_dbrec(to_mctx(pd->context));
	@@ -708,6 +720,9 @@
	free(srq->wrid);
	mlx5_free_buf(&srq->buf);

	+err_spl:
	+ mlx5_spinlock_destroy(&srq->lock);
	+
	err:
	free(srq);

	@@ -749,6 +764,7 @@
	mlx5_free_db(ctx, msrq->db);
	mlx5_free_buf(&msrq->buf);
	free(msrq->wrid);
	+ mlx5_spinlock_destroy(&msrq->lock);
	free(msrq);

	return 0;
	@@ -1306,14 +1322,16 @@

	mlx5_init_qp_indices(qp);

	- if (mlx5_spinlock_init(&qp->sq.lock) \|\|
	- mlx5_spinlock_init(&qp->rq.lock))
	+ if (mlx5_spinlock_init(&qp->sq.lock))
	goto err_free_qp_buf;

	+ if (mlx5_spinlock_init(&qp->rq.lock))
	+ goto err_sq_spl;
	+
	qp->db = mlx5_alloc_dbrec(ctx);
	if (!qp->db) {
	mlx5_dbg(fp, MLX5_DBG_QP, "\n");
	- goto err_free_qp_buf;
	+ goto err_rq_spl;
	}

	qp->db[MLX5_RCV_DBR] = 0;
	@@ -1398,6 +1416,12 @@
	err_rq_db:
	mlx5_free_db(to_mctx(context), qp->db);

	+err_rq_spl:
	+ mlx5_spinlock_destroy(&qp->rq.lock);
	+
	+err_sq_spl:
	+ mlx5_spinlock_destroy(&qp->sq.lock);
	+
	err_free_qp_buf:
	mlx5_free_qp_buf(qp);

	@@ -1510,6 +1534,8 @@
	mlx5_clear_uidx(ctx, qp->rsc.rsn);

	mlx5_free_db(ctx, qp->db);
	+ mlx5_spinlock_destroy(&qp->rq.lock);
	+ mlx5_spinlock_destroy(&qp->sq.lock);
	mlx5_free_qp_buf(qp);
	free:
	free(qp);
	@@ -1823,7 +1849,7 @@
	__func__, __LINE__, attr->attr.max_wr,
	ctx->max_srq_recv_wr);
	errno = EINVAL;
	- goto err;
	+ goto err_spl;
	}

	/*
	@@ -1837,7 +1863,7 @@
	__func__, __LINE__, attr->attr.max_wr,
	ctx->max_srq_recv_wr);
	errno = EINVAL;
	- goto err;
	+ goto err_spl;
	}

	msrq->max = align_queue_size(attr->attr.max_wr + 1);
	@@ -1846,7 +1872,7 @@

	if (mlx5_alloc_srq_buf(context, msrq)) {
	fprintf(stderr, "%s-%d:\n", __func__, __LINE__);
	- goto err;
	+ goto err_spl;
	}

	msrq->db = mlx5_alloc_dbrec(ctx);
	@@ -1912,6 +1938,9 @@
	free(msrq->wrid);
	mlx5_free_buf(&msrq->buf);

	+err_spl:
	+ mlx5_spinlock_destroy(&msrq->lock);
	+
	err:
	free(msrq);

	@@ -2058,9 +2087,13 @@
	goto err;
	}

	+ ret = ibv_init_wq(&rwq->wq);
	+ if (ret < 0)
	+ goto err;
	+
	rwq->buf_size = ret;
	if (mlx5_alloc_rwq_buf(context, rwq, ret))
	- goto err;
	+ goto err_cleanup_wq;

	mlx5_init_rwq_indices(rwq);

	@@ -2069,7 +2102,7 @@

	rwq->db = mlx5_alloc_dbrec(ctx);
	if (!rwq->db)
	- goto err_free_rwq_buf;
	+ goto err_spl;

	rwq->db[MLX5_RCV_DBR] = 0;
	rwq->db[MLX5_SND_DBR] = 0;
	@@ -2104,8 +2137,12 @@
	mlx5_clear_uidx(ctx, cmd.drv.user_index);
	err_free_db_rec:
	mlx5_free_db(to_mctx(context), rwq->db);
	+err_spl:
	+ mlx5_spinlock_destroy(&rwq->rq.lock);
	err_free_rwq_buf:
	mlx5_free_rwq_buf(rwq, context);
	+err_cleanup_wq:
	+ ibv_cleanup_wq(&rwq->wq);
	err:
	free(rwq);
	return NULL;
	@@ -2150,7 +2187,9 @@
	mlx5_spin_unlock(&to_mcq(wq->cq)->lock);
	mlx5_clear_uidx(to_mctx(wq->context), rwq->rsc.rsn);
	mlx5_free_db(to_mctx(wq->context), rwq->db);
	+ mlx5_spinlock_destroy(&rwq->rq.lock);
	mlx5_free_rwq_buf(rwq, wq->context);
	+ ibv_cleanup_wq(&rwq->wq);
	free(rwq);

	return 0;
	diff --git a/contrib/ofed/librdmacm/cma.c b/contrib/ofed/librdmacm/cma.c
	--- a/contrib/ofed/librdmacm/cma.c
	+++ b/contrib/ofed/librdmacm/cma.c
	@@ -502,7 +502,8 @@
	id_priv->id.channel = channel;
	}

	- pthread_mutex_init(&id_priv->mut, NULL);
	+ if (pthread_mutex_init(&id_priv->mut, NULL))
	+ goto err;
	if (pthread_cond_init(&id_priv->cond, NULL))
	goto err;

File Metadata

Mime Type: text/plain
Expires: Thu, May 1, 12:58 PM (20 h, 15 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 17881562
Default Alt Text: D41105.diff (34 KB)

D41105.diffNo OneTemporaryActions

D41105.diffView Options

File Metadata

Event Timeline

D41105.diff
No OneTemporary
Actions

D41105.diff
View Options