Commit 25edbc38 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma 

Pull rdma updates from Jason Gunthorpe:
 "A typical collection of patches this cycle, mostly fixing with a few
  new features:

   - Fixes from static tools. clang warnings, dead code, unused
     variable, coccinelle sweeps, etc

   - Driver bug fixes and minor improvements in rxe, bnxt_re, hfi1,
     mlx5, irdma, qedr

   - rtrs ULP bug fixes an improvments

   - Additional counters for bnxt_re

   - Support verbs CQ notifications in EFA

   - Continued reworking and fixing of rxe

   - netlink control to enable/disable optional device counters

   - rxe now can use AH objects for its UD path, fixing various bugs in
     the process

   - Add DMABUF support to EFA"

* tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rdma/rdma: (103 commits)
  RDMA/core: Require the driver to set the IOVA correctly during rereg_mr
  RDMA/bnxt_re: Remove unsupported bnxt_re_modify_ah callback
  RDMA/irdma: optimize rx path by removing unnecessary copy
  RDMA/qed: Use helper function to set GUIDs
  RDMA/hns: Use the core code to manage the fixed mmap entries
  IB/opa_vnic: Rebranding of OPA VNIC driver to Cornelis Networks
  IB/qib: Rebranding of qib driver to Cornelis Networks
  IB/hfi1: Rebranding of hfi1 driver to Cornelis Networks
  RDMA/bnxt_re: Use helper function to set GUIDs
  RDMA/bnxt_re: Fix kernel panic when trying to access bnxt_re_stat_descs
  RDMA/qedr: Fix NULL deref for query_qp on the GSI QP
  RDMA/hns: Modify the value of MAX_LP_MSG_LEN to meet hardware compatibility
  RDMA/hns: Fix initial arm_st of CQ
  RDMA/rxe: Make rxe_type_info static const
  RDMA/rxe: Use 'bitmap_zalloc()' when applicable
  RDMA/rxe: Save a few bytes from struct rxe_pool
  RDMA/irdma: Remove the unused variable local_qp
  RDMA/core: Fix missed initialization of rdma_hw_stats::lock
  RDMA/efa: Add support for dmabuf memory regions
  RDMA/umem: Allow pinned dmabuf umem usage
  ...
parents ff0700f0 f1a090f0

drivers/infiniband/core/cma.c

+18 −16
Original line number Diff line number Diff line
@@ -453,7 +453,7 @@ static void _cma_attach_to_dev(struct rdma_id_private *id_priv, 
	id_priv->id.device = cma_dev->device;

	id_priv->id.route.addr.dev_addr.transport =

		rdma_node_get_transport(cma_dev->device->node_type);

	list_add_tail(&id_priv->list, &cma_dev->id_list);

	list_add_tail(&id_priv->device_item, &cma_dev->id_list);



	trace_cm_id_attach(id_priv, cma_dev->device);

}
@@ -470,7 +470,7 @@ static void cma_attach_to_dev(struct rdma_id_private *id_priv, 
static void cma_release_dev(struct rdma_id_private *id_priv)

{

	mutex_lock(&lock);

	list_del(&id_priv->list);

	list_del_init(&id_priv->device_item);

	cma_dev_put(id_priv->cma_dev);

	id_priv->cma_dev = NULL;

	id_priv->id.device = NULL;
@@ -854,6 +854,7 @@ __rdma_create_id(struct net *net, rdma_cm_event_handler event_handler, 
	init_completion(&id_priv->comp);

	refcount_set(&id_priv->refcount, 1);

	mutex_init(&id_priv->handler_mutex);

	INIT_LIST_HEAD(&id_priv->device_item);

	INIT_LIST_HEAD(&id_priv->listen_list);

	INIT_LIST_HEAD(&id_priv->mc_list);

	get_random_bytes(&id_priv->seq_num, sizeof id_priv->seq_num);
@@ -1647,7 +1648,7 @@ static struct rdma_id_private *cma_find_listener( 
				return id_priv;

			list_for_each_entry(id_priv_dev,

					    &id_priv->listen_list,

					    listen_list) {

					    listen_item) {

				if (id_priv_dev->id.device == cm_id->device &&

				    cma_match_net_dev(&id_priv_dev->id,

						      net_dev, req))
@@ -1756,14 +1757,15 @@ static void _cma_cancel_listens(struct rdma_id_private *id_priv) 
	 * Remove from listen_any_list to prevent added devices from spawning

	 * additional listen requests.

	 */

	list_del(&id_priv->list);

	list_del_init(&id_priv->listen_any_item);



	while (!list_empty(&id_priv->listen_list)) {

		dev_id_priv = list_entry(id_priv->listen_list.next,

					 struct rdma_id_private, listen_list);

		dev_id_priv =

			list_first_entry(&id_priv->listen_list,

					 struct rdma_id_private, listen_item);

		/* sync with device removal to avoid duplicate destruction */

		list_del_init(&dev_id_priv->list);

		list_del(&dev_id_priv->listen_list);

		list_del_init(&dev_id_priv->device_item);

		list_del_init(&dev_id_priv->listen_item);

		mutex_unlock(&lock);



		rdma_destroy_id(&dev_id_priv->id);
@@ -2564,7 +2566,7 @@ static int cma_listen_on_dev(struct rdma_id_private *id_priv, 
	ret = rdma_listen(&dev_id_priv->id, id_priv->backlog);

	if (ret)

		goto err_listen;

	list_add_tail(&dev_id_priv->listen_list, &id_priv->listen_list);

	list_add_tail(&dev_id_priv->listen_item, &id_priv->listen_list);

	return 0;

err_listen:

	/* Caller must destroy this after releasing lock */
@@ -2580,13 +2582,13 @@ static int cma_listen_on_all(struct rdma_id_private *id_priv) 
	int ret;



	mutex_lock(&lock);

	list_add_tail(&id_priv->list, &listen_any_list);

	list_add_tail(&id_priv->listen_any_item, &listen_any_list);

	list_for_each_entry(cma_dev, &dev_list, list) {

		ret = cma_listen_on_dev(id_priv, cma_dev, &to_destroy);

		if (ret) {

			/* Prevent racing with cma_process_remove() */

			if (to_destroy)

				list_del_init(&to_destroy->list);

				list_del_init(&to_destroy->device_item);

			goto err_listen;

		}

	}
@@ -4895,7 +4897,7 @@ static int cma_netdev_callback(struct notifier_block *self, unsigned long event, 


	mutex_lock(&lock);

	list_for_each_entry(cma_dev, &dev_list, list)

		list_for_each_entry(id_priv, &cma_dev->id_list, list) {

		list_for_each_entry(id_priv, &cma_dev->id_list, device_item) {

			ret = cma_netdev_change(ndev, id_priv);

			if (ret)

				goto out;
@@ -4955,10 +4957,10 @@ static void cma_process_remove(struct cma_device *cma_dev) 
	mutex_lock(&lock);

	while (!list_empty(&cma_dev->id_list)) {

		struct rdma_id_private *id_priv = list_first_entry(

			&cma_dev->id_list, struct rdma_id_private, list);

			&cma_dev->id_list, struct rdma_id_private, device_item);



		list_del(&id_priv->listen_list);

		list_del_init(&id_priv->list);

		list_del_init(&id_priv->listen_item);

		list_del_init(&id_priv->device_item);

		cma_id_get(id_priv);

		mutex_unlock(&lock);
@@ -5035,7 +5037,7 @@ static int cma_add_one(struct ib_device *device) 


	mutex_lock(&lock);

	list_add_tail(&cma_dev->list, &dev_list);

	list_for_each_entry(id_priv, &listen_any_list, list) {

	list_for_each_entry(id_priv, &listen_any_list, listen_any_item) {

		ret = cma_listen_on_dev(id_priv, cma_dev, &to_destroy);

		if (ret)

			goto free_listen;

drivers/infiniband/core/cma_priv.h

+9 −2
Original line number Diff line number Diff line
@@ -55,8 +55,15 @@ struct rdma_id_private { 


	struct rdma_bind_list	*bind_list;

	struct hlist_node	node;

	struct list_head	list; /* listen_any_list or cma_device.list */

	struct list_head	listen_list; /* per device listens */

	union {

		struct list_head device_item; /* On cma_device->id_list */

		struct list_head listen_any_item; /* On listen_any_list */

	};

	union {

		/* On rdma_id_private->listen_list */

		struct list_head listen_item;

		struct list_head listen_list;

	};

	struct cma_device	*cma_dev;

	struct list_head	mc_list;

drivers/infiniband/core/counters.c

+36 −4
Original line number Diff line number Diff line
@@ -106,6 +106,38 @@ static int __rdma_counter_bind_qp(struct rdma_counter *counter, 
	return ret;

}



int rdma_counter_modify(struct ib_device *dev, u32 port,

			unsigned int index, bool enable)

{

	struct rdma_hw_stats *stats;

	int ret = 0;



	if (!dev->ops.modify_hw_stat)

		return -EOPNOTSUPP;



	stats = ib_get_hw_stats_port(dev, port);

	if (!stats || index >= stats->num_counters ||

	    !(stats->descs[index].flags & IB_STAT_FLAG_OPTIONAL))

		return -EINVAL;



	mutex_lock(&stats->lock);



	if (enable != test_bit(index, stats->is_disabled))

		goto out;



	ret = dev->ops.modify_hw_stat(dev, port, index, enable);

	if (ret)

		goto out;



	if (enable)

		clear_bit(index, stats->is_disabled);

	else

		set_bit(index, stats->is_disabled);

out:

	mutex_unlock(&stats->lock);

	return ret;

}



static struct rdma_counter *alloc_and_bind(struct ib_device *dev, u32 port,

					   struct ib_qp *qp,

					   enum rdma_nl_counter_mode mode)
@@ -165,7 +197,7 @@ static struct rdma_counter *alloc_and_bind(struct ib_device *dev, u32 port, 
	return counter;



err_mode:

	kfree(counter->stats);

	rdma_free_hw_stats_struct(counter->stats);

err_stats:

	rdma_restrack_put(&counter->res);

	kfree(counter);
@@ -186,7 +218,7 @@ static void rdma_counter_free(struct rdma_counter *counter) 
	mutex_unlock(&port_counter->lock);



	rdma_restrack_del(&counter->res);

	kfree(counter->stats);

	rdma_free_hw_stats_struct(counter->stats);

	kfree(counter);

}
@@ -618,7 +650,7 @@ void rdma_counter_init(struct ib_device *dev) 
fail:

	for (i = port; i >= rdma_start_port(dev); i--) {

		port_counter = &dev->port_data[port].port_counter;

		kfree(port_counter->hstats);

		rdma_free_hw_stats_struct(port_counter->hstats);

		port_counter->hstats = NULL;

		mutex_destroy(&port_counter->lock);

	}
@@ -631,7 +663,7 @@ void rdma_counter_release(struct ib_device *dev) 


	rdma_for_each_port(dev, port) {

		port_counter = &dev->port_data[port].port_counter;

		kfree(port_counter->hstats);

		rdma_free_hw_stats_struct(port_counter->hstats);

		mutex_destroy(&port_counter->lock);

	}

}

drivers/infiniband/core/device.c

+1 −0
Original line number Diff line number Diff line
@@ -2676,6 +2676,7 @@ void ib_set_device_ops(struct ib_device *dev, const struct ib_device_ops *ops) 
	SET_DEVICE_OP(dev_ops, modify_cq);

	SET_DEVICE_OP(dev_ops, modify_device);

	SET_DEVICE_OP(dev_ops, modify_flow_action_esp);

	SET_DEVICE_OP(dev_ops, modify_hw_stat);

	SET_DEVICE_OP(dev_ops, modify_port);

	SET_DEVICE_OP(dev_ops, modify_qp);

	SET_DEVICE_OP(dev_ops, modify_srq);

drivers/infiniband/core/iwpm_util.c

+1 −1
Original line number Diff line number Diff line
@@ -762,7 +762,7 @@ int iwpm_send_hello(u8 nl_client, int iwpm_pid, u16 abi_version) 
{

	struct sk_buff *skb = NULL;

	struct nlmsghdr *nlh;

	const char *err_str = "";

	const char *err_str;

	int ret = -EINVAL;



	skb = iwpm_create_nlmsg(RDMA_NL_IWPM_HELLO, &nlh, nl_client);