Commit a1139697 authored by Doug Ledford's avatar Doug Ledford
Browse files

Merge branch 'mellanox' into k.o/for-next 



Signed-off-by: default avatarDoug Ledford <dledford@redhat.com>
parents accbef5c 050da902

drivers/infiniband/core/cache.c

+8 −15
Original line number Diff line number Diff line
@@ -1199,30 +1199,23 @@ int ib_cache_setup_one(struct ib_device *device) 
	device->cache.ports =

		kzalloc(sizeof(*device->cache.ports) *

			(rdma_end_port(device) - rdma_start_port(device) + 1), GFP_KERNEL);

	if (!device->cache.ports) {

		err = -ENOMEM;

		goto out;

	}

	if (!device->cache.ports)

		return -ENOMEM;



	err = gid_table_setup_one(device);

	if (err)

		goto out;

	if (err) {

		kfree(device->cache.ports);

		device->cache.ports = NULL;

		return err;

	}



	for (p = 0; p <= rdma_end_port(device) - rdma_start_port(device); ++p)

		ib_cache_update(device, p + rdma_start_port(device), true);



	INIT_IB_EVENT_HANDLER(&device->cache.event_handler,

			      device, ib_cache_event);

	err = ib_register_event_handler(&device->cache.event_handler);

	if (err)

		goto err;



	ib_register_event_handler(&device->cache.event_handler);

	return 0;



err:

	gid_table_cleanup_one(device);

out:

	return err;

}



void ib_cache_release_one(struct ib_device *device)

drivers/infiniband/core/cma.c

+2 −2
Original line number Diff line number Diff line
@@ -72,7 +72,7 @@ MODULE_LICENSE("Dual BSD/GPL"); 
#define CMA_MAX_CM_RETRIES 15

#define CMA_CM_MRA_SETTING (IB_CM_MRA_FLAG_DELAY | 24)

#define CMA_IBOE_PACKET_LIFETIME 18

#define CMA_PREFERRED_ROCE_GID_TYPE (1 << IB_GID_TYPE_ROCE_UDP_ENCAP)

#define CMA_PREFERRED_ROCE_GID_TYPE IB_GID_TYPE_ROCE_UDP_ENCAP



static const char * const cma_events[] = {

	[RDMA_CM_EVENT_ADDR_RESOLVED]	 = "address resolved",
@@ -4282,7 +4282,7 @@ static void cma_add_one(struct ib_device *device) 
	for (i = rdma_start_port(device); i <= rdma_end_port(device); i++) {

		supported_gids = roce_gid_type_mask_support(device, i);

		WARN_ON(!supported_gids);

		if (supported_gids & CMA_PREFERRED_ROCE_GID_TYPE)

		if (supported_gids & (1 << CMA_PREFERRED_ROCE_GID_TYPE))

			cma_dev->default_gid_type[i - rdma_start_port(device)] =

				CMA_PREFERRED_ROCE_GID_TYPE;

		else

drivers/infiniband/core/device.c

+2 −6
Original line number Diff line number Diff line
@@ -747,7 +747,7 @@ EXPORT_SYMBOL(ib_set_client_data); 
 * chapter 11 of the InfiniBand Architecture Specification).  This

 * callback may occur in interrupt context.

 */

int ib_register_event_handler  (struct ib_event_handler *event_handler)

void ib_register_event_handler(struct ib_event_handler *event_handler)

{

	unsigned long flags;
@@ -755,8 +755,6 @@ int ib_register_event_handler (struct ib_event_handler *event_handler) 
	list_add_tail(&event_handler->list,

		      &event_handler->device->event_handler_list);

	spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);



	return 0;

}

EXPORT_SYMBOL(ib_register_event_handler);
@@ -767,15 +765,13 @@ EXPORT_SYMBOL(ib_register_event_handler); 
 * Unregister an event handler registered with

 * ib_register_event_handler().

 */

int ib_unregister_event_handler(struct ib_event_handler *event_handler)

void ib_unregister_event_handler(struct ib_event_handler *event_handler)

{

	unsigned long flags;



	spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);

	list_del(&event_handler->list);

	spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);



	return 0;

}

EXPORT_SYMBOL(ib_unregister_event_handler);

drivers/infiniband/core/sa_query.c

+1 −2
Original line number Diff line number Diff line
@@ -2417,8 +2417,7 @@ static void ib_sa_add_one(struct ib_device *device) 
	 */



	INIT_IB_EVENT_HANDLER(&sa_dev->event_handler, device, ib_sa_event);

	if (ib_register_event_handler(&sa_dev->event_handler))

		goto err;

	ib_register_event_handler(&sa_dev->event_handler);



	for (i = 0; i <= e - s; ++i) {

		if (rdma_cap_ib_sa(device, i + 1))

drivers/infiniband/core/uverbs_cmd.c

+51 −76
Original line number Diff line number Diff line
@@ -1820,6 +1820,28 @@ ssize_t ib_uverbs_open_qp(struct ib_uverbs_file *file, 
	return ret;

}



static void copy_ah_attr_to_uverbs(struct ib_uverbs_qp_dest *uverb_attr,

				   struct rdma_ah_attr *rdma_attr)

{

	const struct ib_global_route   *grh;



	uverb_attr->dlid              = rdma_ah_get_dlid(rdma_attr);

	uverb_attr->sl                = rdma_ah_get_sl(rdma_attr);

	uverb_attr->src_path_bits     = rdma_ah_get_path_bits(rdma_attr);

	uverb_attr->static_rate       = rdma_ah_get_static_rate(rdma_attr);

	uverb_attr->is_global         = !!(rdma_ah_get_ah_flags(rdma_attr) &

					 IB_AH_GRH);

	if (uverb_attr->is_global) {

		grh = rdma_ah_read_grh(rdma_attr);

		memcpy(uverb_attr->dgid, grh->dgid.raw, 16);

		uverb_attr->flow_label        = grh->flow_label;

		uverb_attr->sgid_index        = grh->sgid_index;

		uverb_attr->hop_limit         = grh->hop_limit;

		uverb_attr->traffic_class     = grh->traffic_class;

	}

	uverb_attr->port_num          = rdma_ah_get_port_num(rdma_attr);

}



ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file,

			   struct ib_device *ib_dev,

			   const char __user *buf, int in_len,
@@ -1830,7 +1852,6 @@ ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file, 
	struct ib_qp                   *qp;

	struct ib_qp_attr              *attr;

	struct ib_qp_init_attr         *init_attr;

	const struct ib_global_route   *grh;

	int                            ret;



	if (copy_from_user(&cmd, buf, sizeof cmd))
@@ -1880,39 +1901,8 @@ ssize_t ib_uverbs_query_qp(struct ib_uverbs_file *file, 
	resp.alt_port_num           = attr->alt_port_num;

	resp.alt_timeout            = attr->alt_timeout;



	resp.dest.dlid              = rdma_ah_get_dlid(&attr->ah_attr);

	resp.dest.sl                = rdma_ah_get_sl(&attr->ah_attr);

	resp.dest.src_path_bits     = rdma_ah_get_path_bits(&attr->ah_attr);

	resp.dest.static_rate       = rdma_ah_get_static_rate(&attr->ah_attr);

	resp.dest.is_global         = !!(rdma_ah_get_ah_flags(&attr->ah_attr) &

					 IB_AH_GRH);

	if (resp.dest.is_global) {

		grh = rdma_ah_read_grh(&attr->ah_attr);

		memcpy(resp.dest.dgid, grh->dgid.raw, 16);

		resp.dest.flow_label        = grh->flow_label;

		resp.dest.sgid_index        = grh->sgid_index;

		resp.dest.hop_limit         = grh->hop_limit;

		resp.dest.traffic_class     = grh->traffic_class;

	}

	resp.dest.port_num          = rdma_ah_get_port_num(&attr->ah_attr);



	resp.alt_dest.dlid          = rdma_ah_get_dlid(&attr->alt_ah_attr);

	resp.alt_dest.sl            = rdma_ah_get_sl(&attr->alt_ah_attr);

	resp.alt_dest.src_path_bits = rdma_ah_get_path_bits(&attr->alt_ah_attr);

	resp.alt_dest.static_rate

			= rdma_ah_get_static_rate(&attr->alt_ah_attr);

	resp.alt_dest.is_global

			= !!(rdma_ah_get_ah_flags(&attr->alt_ah_attr) &

						  IB_AH_GRH);

	if (resp.alt_dest.is_global) {

		grh = rdma_ah_read_grh(&attr->alt_ah_attr);

		memcpy(resp.alt_dest.dgid, grh->dgid.raw, 16);

		resp.alt_dest.flow_label    = grh->flow_label;

		resp.alt_dest.sgid_index    = grh->sgid_index;

		resp.alt_dest.hop_limit     = grh->hop_limit;

		resp.alt_dest.traffic_class = grh->traffic_class;

	}

	resp.alt_dest.port_num      = rdma_ah_get_port_num(&attr->alt_ah_attr);

	copy_ah_attr_to_uverbs(&resp.dest, &attr->ah_attr);

	copy_ah_attr_to_uverbs(&resp.alt_dest, &attr->alt_ah_attr);



	resp.max_send_wr            = init_attr->cap.max_send_wr;

	resp.max_recv_wr            = init_attr->cap.max_recv_wr;
@@ -1946,6 +1936,29 @@ static int modify_qp_mask(enum ib_qp_type qp_type, int mask) 
	}

}



static void copy_ah_attr_from_uverbs(struct ib_device *dev,

				     struct rdma_ah_attr *rdma_attr,

				     struct ib_uverbs_qp_dest *uverb_attr)

{

	rdma_attr->type = rdma_ah_find_type(dev, uverb_attr->port_num);

	if (uverb_attr->is_global) {

		rdma_ah_set_grh(rdma_attr, NULL,

				uverb_attr->flow_label,

				uverb_attr->sgid_index,

				uverb_attr->hop_limit,

				uverb_attr->traffic_class);

		rdma_ah_set_dgid_raw(rdma_attr, uverb_attr->dgid);

	} else {

		rdma_ah_set_ah_flags(rdma_attr, 0);

	}

	rdma_ah_set_dlid(rdma_attr, uverb_attr->dlid);

	rdma_ah_set_sl(rdma_attr, uverb_attr->sl);

	rdma_ah_set_path_bits(rdma_attr, uverb_attr->src_path_bits);

	rdma_ah_set_static_rate(rdma_attr, uverb_attr->static_rate);

	rdma_ah_set_port_num(rdma_attr, uverb_attr->port_num);

	rdma_ah_set_make_grd(rdma_attr, false);

}



static int modify_qp(struct ib_uverbs_file *file,

		     struct ib_uverbs_ex_modify_qp *cmd, struct ib_udata *udata)

{
@@ -1993,50 +2006,12 @@ static int modify_qp(struct ib_uverbs_file *file, 
	attr->rate_limit	  = cmd->rate_limit;



	if (cmd->base.attr_mask & IB_QP_AV)

		attr->ah_attr.type = rdma_ah_find_type(qp->device,

						       cmd->base.dest.port_num);

	if (cmd->base.dest.is_global) {

		rdma_ah_set_grh(&attr->ah_attr, NULL,

				cmd->base.dest.flow_label,

				cmd->base.dest.sgid_index,

				cmd->base.dest.hop_limit,

				cmd->base.dest.traffic_class);

		rdma_ah_set_dgid_raw(&attr->ah_attr, cmd->base.dest.dgid);

	} else {

		rdma_ah_set_ah_flags(&attr->ah_attr, 0);

	}

	rdma_ah_set_dlid(&attr->ah_attr, cmd->base.dest.dlid);

	rdma_ah_set_sl(&attr->ah_attr, cmd->base.dest.sl);

	rdma_ah_set_path_bits(&attr->ah_attr, cmd->base.dest.src_path_bits);

	rdma_ah_set_static_rate(&attr->ah_attr, cmd->base.dest.static_rate);

	rdma_ah_set_port_num(&attr->ah_attr,

			     cmd->base.dest.port_num);

	rdma_ah_set_make_grd(&attr->ah_attr, false);

		copy_ah_attr_from_uverbs(qp->device, &attr->ah_attr,

					 &cmd->base.dest);



	if (cmd->base.attr_mask & IB_QP_ALT_PATH)

		attr->alt_ah_attr.type =

			rdma_ah_find_type(qp->device, cmd->base.dest.port_num);

	if (cmd->base.alt_dest.is_global) {

		rdma_ah_set_grh(&attr->alt_ah_attr, NULL,

				cmd->base.alt_dest.flow_label,

				cmd->base.alt_dest.sgid_index,

				cmd->base.alt_dest.hop_limit,

				cmd->base.alt_dest.traffic_class);

		rdma_ah_set_dgid_raw(&attr->alt_ah_attr,

				     cmd->base.alt_dest.dgid);

	} else {

		rdma_ah_set_ah_flags(&attr->alt_ah_attr, 0);

	}



	rdma_ah_set_dlid(&attr->alt_ah_attr, cmd->base.alt_dest.dlid);

	rdma_ah_set_sl(&attr->alt_ah_attr, cmd->base.alt_dest.sl);

	rdma_ah_set_path_bits(&attr->alt_ah_attr,

			      cmd->base.alt_dest.src_path_bits);

	rdma_ah_set_static_rate(&attr->alt_ah_attr,

				cmd->base.alt_dest.static_rate);

	rdma_ah_set_port_num(&attr->alt_ah_attr,

			     cmd->base.alt_dest.port_num);

	rdma_ah_set_make_grd(&attr->alt_ah_attr, false);

		copy_ah_attr_from_uverbs(qp->device, &attr->alt_ah_attr,

					 &cmd->base.alt_dest);



	ret = ib_modify_qp_with_udata(qp, attr,

				      modify_qp_mask(qp->qp_type,