Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f470f8d4 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband: (62 commits)
  mlx4_core: Deprecate log_num_vlan module param
  IB/mlx4: Don't set VLAN in IBoE WQEs' control segment
  IB/mlx4: Enable 4K mtu for IBoE
  RDMA/cxgb4: Mark QP in error before disabling the queue in firmware
  RDMA/cxgb4: Serialize calls to CQ's comp_handler
  RDMA/cxgb3: Serialize calls to CQ's comp_handler
  IB/qib: Fix issue with link states and QSFP cables
  IB/mlx4: Configure extended active speeds
  mlx4_core: Add extended port capabilities support
  IB/qib: Hold links until tuning data is available
  IB/qib: Clean up checkpatch issue
  IB/qib: Remove s_lock around header validation
  IB/qib: Precompute timeout jiffies to optimize latency
  IB/qib: Use RCU for qpn lookup
  IB/qib: Eliminate divide/mod in converting idx to egr buf pointer
  IB/qib: Decode path MTU optimization
  IB/qib: Optimize RC/UC code by IB operation
  IPoIB: Use the right function to do DMA unmap pages
  RDMA/cxgb4: Use correct QID in insert_recv_cqe()
  RDMA/cxgb4: Make sure flush CQ entries are collected on connection close
  ...
parents dc47d381 504255f8

drivers/infiniband/core/cm.c

+41 −22
Original line number Diff line number Diff line
@@ -889,6 +889,8 @@ static void cm_destroy_id(struct ib_cm_id *cm_id, int err) 
		break;

	case IB_CM_ESTABLISHED:

		spin_unlock_irq(&cm_id_priv->lock);

		if (cm_id_priv->qp_type == IB_QPT_XRC_TGT)

			break;

		ib_send_cm_dreq(cm_id, NULL, 0);

		goto retest;

	case IB_CM_DREQ_SENT:
@@ -1008,7 +1010,6 @@ static void cm_format_req(struct cm_req_msg *req_msg, 
	req_msg->service_id = param->service_id;

	req_msg->local_ca_guid = cm_id_priv->id.device->node_guid;

	cm_req_set_local_qpn(req_msg, cpu_to_be32(param->qp_num));

	cm_req_set_resp_res(req_msg, param->responder_resources);

	cm_req_set_init_depth(req_msg, param->initiator_depth);

	cm_req_set_remote_resp_timeout(req_msg,

				       param->remote_cm_response_timeout);
@@ -1017,12 +1018,16 @@ static void cm_format_req(struct cm_req_msg *req_msg, 
	cm_req_set_starting_psn(req_msg, cpu_to_be32(param->starting_psn));

	cm_req_set_local_resp_timeout(req_msg,

				      param->local_cm_response_timeout);

	cm_req_set_retry_count(req_msg, param->retry_count);

	req_msg->pkey = param->primary_path->pkey;

	cm_req_set_path_mtu(req_msg, param->primary_path->mtu);

	cm_req_set_rnr_retry_count(req_msg, param->rnr_retry_count);

	cm_req_set_max_cm_retries(req_msg, param->max_cm_retries);



	if (param->qp_type != IB_QPT_XRC_INI) {

		cm_req_set_resp_res(req_msg, param->responder_resources);

		cm_req_set_retry_count(req_msg, param->retry_count);

		cm_req_set_rnr_retry_count(req_msg, param->rnr_retry_count);

		cm_req_set_srq(req_msg, param->srq);

	}



	if (pri_path->hop_limit <= 1) {

		req_msg->primary_local_lid = pri_path->slid;
@@ -1080,7 +1085,8 @@ static int cm_validate_req_param(struct ib_cm_req_param *param) 
	if (!param->primary_path)

		return -EINVAL;



	if (param->qp_type != IB_QPT_RC && param->qp_type != IB_QPT_UC)

	if (param->qp_type != IB_QPT_RC && param->qp_type != IB_QPT_UC &&

	    param->qp_type != IB_QPT_XRC_INI)

		return -EINVAL;



	if (param->private_data &&
@@ -1601,18 +1607,24 @@ static void cm_format_rep(struct cm_rep_msg *rep_msg, 
	cm_format_mad_hdr(&rep_msg->hdr, CM_REP_ATTR_ID, cm_id_priv->tid);

	rep_msg->local_comm_id = cm_id_priv->id.local_id;

	rep_msg->remote_comm_id = cm_id_priv->id.remote_id;

	cm_rep_set_local_qpn(rep_msg, cpu_to_be32(param->qp_num));

	cm_rep_set_starting_psn(rep_msg, cpu_to_be32(param->starting_psn));

	rep_msg->resp_resources = param->responder_resources;

	rep_msg->initiator_depth = param->initiator_depth;

	cm_rep_set_target_ack_delay(rep_msg,

				    cm_id_priv->av.port->cm_dev->ack_delay);

	cm_rep_set_failover(rep_msg, param->failover_accepted);

	cm_rep_set_flow_ctrl(rep_msg, param->flow_control);

	cm_rep_set_rnr_retry_count(rep_msg, param->rnr_retry_count);

	cm_rep_set_srq(rep_msg, param->srq);

	rep_msg->local_ca_guid = cm_id_priv->id.device->node_guid;



	if (cm_id_priv->qp_type != IB_QPT_XRC_TGT) {

		rep_msg->initiator_depth = param->initiator_depth;

		cm_rep_set_flow_ctrl(rep_msg, param->flow_control);

		cm_rep_set_srq(rep_msg, param->srq);

		cm_rep_set_local_qpn(rep_msg, cpu_to_be32(param->qp_num));

	} else {

		cm_rep_set_srq(rep_msg, 1);

		cm_rep_set_local_eecn(rep_msg, cpu_to_be32(param->qp_num));

	}



	if (param->private_data && param->private_data_len)

		memcpy(rep_msg->private_data, param->private_data,

		       param->private_data_len);
@@ -1660,7 +1672,7 @@ int ib_send_cm_rep(struct ib_cm_id *cm_id, 
	cm_id_priv->initiator_depth = param->initiator_depth;

	cm_id_priv->responder_resources = param->responder_resources;

	cm_id_priv->rq_psn = cm_rep_get_starting_psn(rep_msg);

	cm_id_priv->local_qpn = cm_rep_get_local_qpn(rep_msg);

	cm_id_priv->local_qpn = cpu_to_be32(param->qp_num & 0xFFFFFF);



out:	spin_unlock_irqrestore(&cm_id_priv->lock, flags);

	return ret;
@@ -1731,7 +1743,7 @@ error: spin_unlock_irqrestore(&cm_id_priv->lock, flags); 
}

EXPORT_SYMBOL(ib_send_cm_rtu);



static void cm_format_rep_event(struct cm_work *work)

static void cm_format_rep_event(struct cm_work *work, enum ib_qp_type qp_type)

{

	struct cm_rep_msg *rep_msg;

	struct ib_cm_rep_event_param *param;
@@ -1740,7 +1752,7 @@ static void cm_format_rep_event(struct cm_work *work) 
	param = &work->cm_event.param.rep_rcvd;

	param->remote_ca_guid = rep_msg->local_ca_guid;

	param->remote_qkey = be32_to_cpu(rep_msg->local_qkey);

	param->remote_qpn = be32_to_cpu(cm_rep_get_local_qpn(rep_msg));

	param->remote_qpn = be32_to_cpu(cm_rep_get_qpn(rep_msg, qp_type));

	param->starting_psn = be32_to_cpu(cm_rep_get_starting_psn(rep_msg));

	param->responder_resources = rep_msg->initiator_depth;

	param->initiator_depth = rep_msg->resp_resources;
@@ -1808,7 +1820,7 @@ static int cm_rep_handler(struct cm_work *work) 
		return -EINVAL;

	}



	cm_format_rep_event(work);

	cm_format_rep_event(work, cm_id_priv->qp_type);



	spin_lock_irq(&cm_id_priv->lock);

	switch (cm_id_priv->id.state) {
@@ -1823,7 +1835,7 @@ static int cm_rep_handler(struct cm_work *work) 


	cm_id_priv->timewait_info->work.remote_id = rep_msg->local_comm_id;

	cm_id_priv->timewait_info->remote_ca_guid = rep_msg->local_ca_guid;

	cm_id_priv->timewait_info->remote_qpn = cm_rep_get_local_qpn(rep_msg);

	cm_id_priv->timewait_info->remote_qpn = cm_rep_get_qpn(rep_msg, cm_id_priv->qp_type);



	spin_lock(&cm.lock);

	/* Check for duplicate REP. */
@@ -1850,7 +1862,7 @@ static int cm_rep_handler(struct cm_work *work) 


	cm_id_priv->id.state = IB_CM_REP_RCVD;

	cm_id_priv->id.remote_id = rep_msg->local_comm_id;

	cm_id_priv->remote_qpn = cm_rep_get_local_qpn(rep_msg);

	cm_id_priv->remote_qpn = cm_rep_get_qpn(rep_msg, cm_id_priv->qp_type);

	cm_id_priv->initiator_depth = rep_msg->resp_resources;

	cm_id_priv->responder_resources = rep_msg->initiator_depth;

	cm_id_priv->sq_psn = cm_rep_get_starting_psn(rep_msg);
@@ -3492,7 +3504,8 @@ static int cm_init_qp_rtr_attr(struct cm_id_private *cm_id_priv, 
		qp_attr->path_mtu = cm_id_priv->path_mtu;

		qp_attr->dest_qp_num = be32_to_cpu(cm_id_priv->remote_qpn);

		qp_attr->rq_psn = be32_to_cpu(cm_id_priv->rq_psn);

		if (cm_id_priv->qp_type == IB_QPT_RC) {

		if (cm_id_priv->qp_type == IB_QPT_RC ||

		    cm_id_priv->qp_type == IB_QPT_XRC_TGT) {

			*qp_attr_mask |= IB_QP_MAX_DEST_RD_ATOMIC |

					 IB_QP_MIN_RNR_TIMER;

			qp_attr->max_dest_rd_atomic =
@@ -3537,15 +3550,21 @@ static int cm_init_qp_rts_attr(struct cm_id_private *cm_id_priv, 
		if (cm_id_priv->id.lap_state == IB_CM_LAP_UNINIT) {

			*qp_attr_mask = IB_QP_STATE | IB_QP_SQ_PSN;

			qp_attr->sq_psn = be32_to_cpu(cm_id_priv->sq_psn);

			if (cm_id_priv->qp_type == IB_QPT_RC) {

				*qp_attr_mask |= IB_QP_TIMEOUT | IB_QP_RETRY_CNT |

						 IB_QP_RNR_RETRY |

			switch (cm_id_priv->qp_type) {

			case IB_QPT_RC:

			case IB_QPT_XRC_INI:

				*qp_attr_mask |= IB_QP_RETRY_CNT | IB_QP_RNR_RETRY |

						 IB_QP_MAX_QP_RD_ATOMIC;

				qp_attr->timeout = cm_id_priv->av.timeout;

				qp_attr->retry_cnt = cm_id_priv->retry_count;

				qp_attr->rnr_retry = cm_id_priv->rnr_retry_count;

				qp_attr->max_rd_atomic =

					cm_id_priv->initiator_depth;

				qp_attr->max_rd_atomic = cm_id_priv->initiator_depth;

				/* fall through */

			case IB_QPT_XRC_TGT:

				*qp_attr_mask |= IB_QP_TIMEOUT;

				qp_attr->timeout = cm_id_priv->av.timeout;

				break;

			default:

				break;

			}

			if (cm_id_priv->alt_av.ah_attr.dlid) {

				*qp_attr_mask |= IB_QP_PATH_MIG_STATE;

drivers/infiniband/core/cm_msgs.h

+30 −2
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2004 Intel Corporation.  All rights reserved.

 * Copyright (c) 2004, 2011 Intel Corporation.  All rights reserved.

 * Copyright (c) 2004 Topspin Corporation.  All rights reserved.

 * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.

 *
@@ -86,7 +86,7 @@ struct cm_req_msg { 
	__be16 pkey;

	/* path MTU:4, RDC exists:1, RNR retry count:3. */

	u8 offset50;

	/* max CM Retries:4, SRQ:1, rsvd:3 */

	/* max CM Retries:4, SRQ:1, extended transport type:3 */

	u8 offset51;



	__be16 primary_local_lid;
@@ -175,6 +175,11 @@ static inline enum ib_qp_type cm_req_get_qp_type(struct cm_req_msg *req_msg) 
	switch(transport_type) {

	case 0: return IB_QPT_RC;

	case 1: return IB_QPT_UC;

	case 3:

		switch (req_msg->offset51 & 0x7) {

		case 1: return IB_QPT_XRC_TGT;

		default: return 0;

		}

	default: return 0;

	}

}
@@ -188,6 +193,12 @@ static inline void cm_req_set_qp_type(struct cm_req_msg *req_msg, 
						  req_msg->offset40) &

						   0xFFFFFFF9) | 0x2);

		break;

	case IB_QPT_XRC_INI:

		req_msg->offset40 = cpu_to_be32((be32_to_cpu(

						 req_msg->offset40) &

						   0xFFFFFFF9) | 0x6);

		req_msg->offset51 = (req_msg->offset51 & 0xF8) | 1;

		break;

	default:

		req_msg->offset40 = cpu_to_be32(be32_to_cpu(

						 req_msg->offset40) &
@@ -527,6 +538,23 @@ static inline void cm_rep_set_local_qpn(struct cm_rep_msg *rep_msg, __be32 qpn) 
			    (be32_to_cpu(rep_msg->offset12) & 0x000000FF));

}



static inline __be32 cm_rep_get_local_eecn(struct cm_rep_msg *rep_msg)

{

	return cpu_to_be32(be32_to_cpu(rep_msg->offset16) >> 8);

}



static inline void cm_rep_set_local_eecn(struct cm_rep_msg *rep_msg, __be32 eecn)

{

	rep_msg->offset16 = cpu_to_be32((be32_to_cpu(eecn) << 8) |

			    (be32_to_cpu(rep_msg->offset16) & 0x000000FF));

}



static inline __be32 cm_rep_get_qpn(struct cm_rep_msg *rep_msg, enum ib_qp_type qp_type)

{

	return (qp_type == IB_QPT_XRC_INI) ?

		cm_rep_get_local_eecn(rep_msg) : cm_rep_get_local_qpn(rep_msg);

}



static inline __be32 cm_rep_get_starting_psn(struct cm_rep_msg *rep_msg)

{

	return cpu_to_be32(be32_to_cpu(rep_msg->offset20) >> 8);

drivers/infiniband/core/cma.c

+48 −19
Original line number Diff line number Diff line
@@ -81,6 +81,7 @@ static DEFINE_IDR(sdp_ps); 
static DEFINE_IDR(tcp_ps);

static DEFINE_IDR(udp_ps);

static DEFINE_IDR(ipoib_ps);

static DEFINE_IDR(ib_ps);



struct cma_device {

	struct list_head	list;
@@ -1179,6 +1180,15 @@ static void cma_set_req_event_data(struct rdma_cm_event *event, 
	event->param.conn.qp_num = req_data->remote_qpn;

}



static int cma_check_req_qp_type(struct rdma_cm_id *id, struct ib_cm_event *ib_event)

{

	return (((ib_event->event == IB_CM_REQ_RECEIVED) ||

		 (ib_event->param.req_rcvd.qp_type == id->qp_type)) ||

		((ib_event->event == IB_CM_SIDR_REQ_RECEIVED) &&

		 (id->qp_type == IB_QPT_UD)) ||

		(!id->qp_type));

}



static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)

{

	struct rdma_id_private *listen_id, *conn_id;
@@ -1186,13 +1196,16 @@ static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event) 
	int offset, ret;



	listen_id = cm_id->context;

	if (!cma_check_req_qp_type(&listen_id->id, ib_event))

		return -EINVAL;



	if (cma_disable_callback(listen_id, RDMA_CM_LISTEN))

		return -ECONNABORTED;



	memset(&event, 0, sizeof event);

	offset = cma_user_data_offset(listen_id->id.ps);

	event.event = RDMA_CM_EVENT_CONNECT_REQUEST;

	if (listen_id->id.qp_type == IB_QPT_UD) {

	if (ib_event->event == IB_CM_SIDR_REQ_RECEIVED) {

		conn_id = cma_new_udp_id(&listen_id->id, ib_event);

		event.param.ud.private_data = ib_event->private_data + offset;

		event.param.ud.private_data_len =
@@ -1328,6 +1341,8 @@ static int cma_iw_handler(struct iw_cm_id *iw_id, struct iw_cm_event *iw_event) 
		switch (iw_event->status) {

		case 0:

			event.event = RDMA_CM_EVENT_ESTABLISHED;

			event.param.conn.initiator_depth = iw_event->ird;

			event.param.conn.responder_resources = iw_event->ord;

			break;

		case -ECONNRESET:

		case -ECONNREFUSED:
@@ -1343,6 +1358,8 @@ static int cma_iw_handler(struct iw_cm_id *iw_id, struct iw_cm_event *iw_event) 
		break;

	case IW_CM_EVENT_ESTABLISHED:

		event.event = RDMA_CM_EVENT_ESTABLISHED;

		event.param.conn.initiator_depth = iw_event->ird;

		event.param.conn.responder_resources = iw_event->ord;

		break;

	default:

		BUG_ON(1);
@@ -1433,8 +1450,8 @@ static int iw_conn_req_handler(struct iw_cm_id *cm_id, 
	event.event = RDMA_CM_EVENT_CONNECT_REQUEST;

	event.param.conn.private_data = iw_event->private_data;

	event.param.conn.private_data_len = iw_event->private_data_len;

	event.param.conn.initiator_depth = attr.max_qp_init_rd_atom;

	event.param.conn.responder_resources = attr.max_qp_rd_atom;

	event.param.conn.initiator_depth = iw_event->ird;

	event.param.conn.responder_resources = iw_event->ord;



	/*

	 * Protect against the user destroying conn_id from another thread
@@ -2234,6 +2251,9 @@ static int cma_get_port(struct rdma_id_private *id_priv) 
	case RDMA_PS_IPOIB:

		ps = &ipoib_ps;

		break;

	case RDMA_PS_IB:

		ps = &ib_ps;

		break;

	default:

		return -EPROTONOSUPPORT;

	}
@@ -2569,7 +2589,7 @@ static int cma_connect_ib(struct rdma_id_private *id_priv, 
	req.service_id = cma_get_service_id(id_priv->id.ps,

					    (struct sockaddr *) &route->addr.dst_addr);

	req.qp_num = id_priv->qp_num;

	req.qp_type = IB_QPT_RC;

	req.qp_type = id_priv->id.qp_type;

	req.starting_psn = id_priv->seq_num;

	req.responder_resources = conn_param->responder_resources;

	req.initiator_depth = conn_param->initiator_depth;
@@ -2616,14 +2636,16 @@ static int cma_connect_iw(struct rdma_id_private *id_priv, 
	if (ret)

		goto out;



	if (conn_param) {

		iw_param.ord = conn_param->initiator_depth;

		iw_param.ird = conn_param->responder_resources;

		iw_param.private_data = conn_param->private_data;

		iw_param.private_data_len = conn_param->private_data_len;

	if (id_priv->id.qp)

		iw_param.qpn = id_priv->id.qp ? id_priv->qp_num : conn_param->qp_num;

	} else {

		memset(&iw_param, 0, sizeof iw_param);

		iw_param.qpn = id_priv->qp_num;

	else

		iw_param.qpn = conn_param->qp_num;

	}

	ret = iw_cm_connect(cm_id, &iw_param);

out:

	if (ret) {
@@ -2765,14 +2787,20 @@ int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param) 


	switch (rdma_node_get_transport(id->device->node_type)) {

	case RDMA_TRANSPORT_IB:

		if (id->qp_type == IB_QPT_UD)

		if (id->qp_type == IB_QPT_UD) {

			if (conn_param)

				ret = cma_send_sidr_rep(id_priv, IB_SIDR_SUCCESS,

							conn_param->private_data,

							conn_param->private_data_len);

		else if (conn_param)

			else

				ret = cma_send_sidr_rep(id_priv, IB_SIDR_SUCCESS,

							NULL, 0);

		} else {

			if (conn_param)

				ret = cma_accept_ib(id_priv, conn_param);

			else

				ret = cma_rep_recv(id_priv);

		}

		break;

	case RDMA_TRANSPORT_IWARP:

		ret = cma_accept_iw(id_priv, conn_param);
@@ -3460,6 +3488,7 @@ static void __exit cma_cleanup(void) 
	idr_destroy(&tcp_ps);

	idr_destroy(&udp_ps);

	idr_destroy(&ipoib_ps);

	idr_destroy(&ib_ps);

}



module_init(cma_init);

drivers/infiniband/core/mad.c

+3 −0
Original line number Diff line number Diff line
@@ -1596,6 +1596,9 @@ find_mad_agent(struct ib_mad_port_private *port_priv, 
					mad->mad_hdr.class_version].class;

			if (!class)

				goto out;

			if (convert_mgmt_class(mad->mad_hdr.mgmt_class) >=

			    IB_MGMT_MAX_METHODS)

				goto out;

			method = class->method_table[convert_mgmt_class(

							mad->mad_hdr.mgmt_class)];

			if (method)

drivers/infiniband/core/sysfs.c

+22 −4
Original line number Diff line number Diff line
@@ -185,17 +185,35 @@ static ssize_t rate_show(struct ib_port *p, struct port_attribute *unused, 
	if (ret)

		return ret;



	rate = (25 * attr.active_speed) / 10;



	switch (attr.active_speed) {

	case 2: speed = " DDR"; break;

	case 4: speed = " QDR"; break;

	case 2:

		speed = " DDR";

		break;

	case 4:

		speed = " QDR";

		break;

	case 8:

		speed = " FDR10";

		rate = 10;

		break;

	case 16:

		speed = " FDR";

		rate = 14;

		break;

	case 32:

		speed = " EDR";

		rate = 25;

		break;

	}



	rate = 25 * ib_width_enum_to_int(attr.active_width) * attr.active_speed;

	rate *= ib_width_enum_to_int(attr.active_width);

	if (rate < 0)

		return -EINVAL;



	return sprintf(buf, "%d%s Gb/sec (%dX%s)\n",

		       rate / 10, rate % 10 ? ".5" : "",

		       rate, (attr.active_speed == 1) ? ".5" : "",

		       ib_width_enum_to_int(attr.active_width), speed);

}