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

Commit 064c94f9 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:
  IB/mad: RMPP support for additional classes
  IB/mad: include GID/class when matching receives
  IB/mthca: Fix section mismatch problems
  IPoIB: Fix oops with raw sockets
  IB/mthca: Fix check of size in SRQ creation
  IB/srp: Fix unmapping of fake scatterlist
parents 256414de 618a3c03

drivers/infiniband/core/mad.c

+101 −11
Original line number Diff line number Diff line
@@ -227,6 +227,14 @@ struct ib_mad_agent *ib_register_mad_agent(struct ib_device *device, 
			if (!is_vendor_oui(mad_reg_req->oui))

				goto error1;

		}

		/* Make sure class supplied is consistent with RMPP */

		if (ib_is_mad_class_rmpp(mad_reg_req->mgmt_class)) {

			if (!rmpp_version)

				goto error1;

		} else {

			if (rmpp_version)

				goto error1;

		}

		/* Make sure class supplied is consistent with QP type */

		if (qp_type == IB_QPT_SMI) {

			if ((mad_reg_req->mgmt_class !=
@@ -890,6 +898,35 @@ struct ib_mad_send_buf * ib_create_send_mad(struct ib_mad_agent *mad_agent, 
}

EXPORT_SYMBOL(ib_create_send_mad);



int ib_get_mad_data_offset(u8 mgmt_class)

{

	if (mgmt_class == IB_MGMT_CLASS_SUBN_ADM)

		return IB_MGMT_SA_HDR;

	else if ((mgmt_class == IB_MGMT_CLASS_DEVICE_MGMT) ||

		 (mgmt_class == IB_MGMT_CLASS_DEVICE_ADM) ||

		 (mgmt_class == IB_MGMT_CLASS_BIS))

		return IB_MGMT_DEVICE_HDR;

	else if ((mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START) &&

		 (mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END))

		return IB_MGMT_VENDOR_HDR;

	else

		return IB_MGMT_MAD_HDR;

}

EXPORT_SYMBOL(ib_get_mad_data_offset);



int ib_is_mad_class_rmpp(u8 mgmt_class)

{

	if ((mgmt_class == IB_MGMT_CLASS_SUBN_ADM) ||

	    (mgmt_class == IB_MGMT_CLASS_DEVICE_MGMT) ||

	    (mgmt_class == IB_MGMT_CLASS_DEVICE_ADM) ||

	    (mgmt_class == IB_MGMT_CLASS_BIS) ||

	    ((mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START) &&

	     (mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END)))

		return 1;

	return 0;

}

EXPORT_SYMBOL(ib_is_mad_class_rmpp);



void *ib_get_rmpp_segment(struct ib_mad_send_buf *send_buf, int seg_num)

{

	struct ib_mad_send_wr_private *mad_send_wr;
@@ -1022,6 +1059,13 @@ int ib_post_send_mad(struct ib_mad_send_buf *send_buf, 
			goto error;

		}



		if (!ib_is_mad_class_rmpp(((struct ib_mad_hdr *) send_buf->mad)->mgmt_class)) {

			if (mad_agent_priv->agent.rmpp_version) {

				ret = -EINVAL;

				goto error;

			}

		}



		/*

		 * Save pointer to next work request to post in case the

		 * current one completes, and the user modifies the work
@@ -1618,14 +1662,59 @@ static int is_data_mad(struct ib_mad_agent_private *mad_agent_priv, 
		(rmpp_mad->rmpp_hdr.rmpp_type == IB_MGMT_RMPP_TYPE_DATA);

}



static inline int rcv_has_same_class(struct ib_mad_send_wr_private *wr,

				     struct ib_mad_recv_wc *rwc)

{

	return ((struct ib_mad *)(wr->send_buf.mad))->mad_hdr.mgmt_class ==

		rwc->recv_buf.mad->mad_hdr.mgmt_class;

}



static inline int rcv_has_same_gid(struct ib_mad_send_wr_private *wr,

				   struct ib_mad_recv_wc *rwc )

{

	struct ib_ah_attr attr;

	u8 send_resp, rcv_resp;



	send_resp = ((struct ib_mad *)(wr->send_buf.mad))->

		     mad_hdr.method & IB_MGMT_METHOD_RESP;

	rcv_resp = rwc->recv_buf.mad->mad_hdr.method & IB_MGMT_METHOD_RESP;



	if (!send_resp && rcv_resp)

		/* is request/response. GID/LIDs are both local (same). */

		return 1;



	if (send_resp == rcv_resp)

		/* both requests, or both responses. GIDs different */

		return 0;



	if (ib_query_ah(wr->send_buf.ah, &attr))

		/* Assume not equal, to avoid false positives. */

		return 0;



	if (!(attr.ah_flags & IB_AH_GRH) && !(rwc->wc->wc_flags & IB_WC_GRH))

		return attr.dlid == rwc->wc->slid;

	else if ((attr.ah_flags & IB_AH_GRH) &&

		 (rwc->wc->wc_flags & IB_WC_GRH))

		return memcmp(attr.grh.dgid.raw,

			      rwc->recv_buf.grh->sgid.raw, 16) == 0;

	else

		/* one has GID, other does not.  Assume different */

		return 0;

}

struct ib_mad_send_wr_private*

ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv, __be64 tid)

ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv,

		 struct ib_mad_recv_wc *mad_recv_wc)

{

	struct ib_mad_send_wr_private *mad_send_wr;

	struct ib_mad *mad;



	mad = (struct ib_mad *)mad_recv_wc->recv_buf.mad;



	list_for_each_entry(mad_send_wr, &mad_agent_priv->wait_list,

			    agent_list) {

		if (mad_send_wr->tid == tid)

		if ((mad_send_wr->tid == mad->mad_hdr.tid) &&

		    rcv_has_same_class(mad_send_wr, mad_recv_wc) &&

		    rcv_has_same_gid(mad_send_wr, mad_recv_wc))

			return mad_send_wr;

	}
@@ -1636,7 +1725,10 @@ ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv, __be64 tid) 
	list_for_each_entry(mad_send_wr, &mad_agent_priv->send_list,

			    agent_list) {

		if (is_data_mad(mad_agent_priv, mad_send_wr->send_buf.mad) &&

		    mad_send_wr->tid == tid && mad_send_wr->timeout) {

		    mad_send_wr->tid == mad->mad_hdr.tid &&

		    mad_send_wr->timeout &&

		    rcv_has_same_class(mad_send_wr, mad_recv_wc) &&

		    rcv_has_same_gid(mad_send_wr, mad_recv_wc)) {

			/* Verify request has not been canceled */

			return (mad_send_wr->status == IB_WC_SUCCESS) ?

				mad_send_wr : NULL;
@@ -1661,7 +1753,6 @@ static void ib_mad_complete_recv(struct ib_mad_agent_private *mad_agent_priv, 
	struct ib_mad_send_wr_private *mad_send_wr;

	struct ib_mad_send_wc mad_send_wc;

	unsigned long flags;

	__be64 tid;



	INIT_LIST_HEAD(&mad_recv_wc->rmpp_list);

	list_add(&mad_recv_wc->recv_buf.list, &mad_recv_wc->rmpp_list);
@@ -1677,9 +1768,8 @@ static void ib_mad_complete_recv(struct ib_mad_agent_private *mad_agent_priv, 


	/* Complete corresponding request */

	if (response_mad(mad_recv_wc->recv_buf.mad)) {

		tid = mad_recv_wc->recv_buf.mad->mad_hdr.tid;

		spin_lock_irqsave(&mad_agent_priv->lock, flags);

		mad_send_wr = ib_find_send_mad(mad_agent_priv, tid);

		mad_send_wr = ib_find_send_mad(mad_agent_priv, mad_recv_wc);

		if (!mad_send_wr) {

			spin_unlock_irqrestore(&mad_agent_priv->lock, flags);

			ib_free_recv_mad(mad_recv_wc);

drivers/infiniband/core/mad_priv.h

+2 −1
Original line number Diff line number Diff line
@@ -216,7 +216,8 @@ extern kmem_cache_t *ib_mad_cache; 
int ib_send_mad(struct ib_mad_send_wr_private *mad_send_wr);



struct ib_mad_send_wr_private *

ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv, __be64 tid);

ib_find_send_mad(struct ib_mad_agent_private *mad_agent_priv,

		 struct ib_mad_recv_wc *mad_recv_wc);



void ib_mad_complete_send_wr(struct ib_mad_send_wr_private *mad_send_wr,

			     struct ib_mad_send_wc *mad_send_wc);

drivers/infiniband/core/mad_rmpp.c

+17 −37
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2005 Intel Inc. All rights reserved.

 * Copyright (c) 2005 Voltaire, Inc. All rights reserved.

 * Copyright (c) 2005-2006 Voltaire, Inc. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU
@@ -100,17 +100,6 @@ void ib_cancel_rmpp_recvs(struct ib_mad_agent_private *agent) 
	}

}



static int data_offset(u8 mgmt_class)

{

	if (mgmt_class == IB_MGMT_CLASS_SUBN_ADM)

		return IB_MGMT_SA_HDR;

	else if ((mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START) &&

		 (mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END))

		return IB_MGMT_VENDOR_HDR;

	else

		return IB_MGMT_RMPP_HDR;

}



static void format_ack(struct ib_mad_send_buf *msg,

		       struct ib_rmpp_mad *data,

		       struct mad_rmpp_recv *rmpp_recv)
@@ -137,7 +126,7 @@ static void ack_recv(struct mad_rmpp_recv *rmpp_recv, 
	struct ib_mad_send_buf *msg;

	int ret, hdr_len;



	hdr_len = data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class);

	hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class);

	msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp,

				 recv_wc->wc->pkey_index, 1, hdr_len,

				 0, GFP_KERNEL);
@@ -163,7 +152,7 @@ static struct ib_mad_send_buf *alloc_response_msg(struct ib_mad_agent *agent, 
	if (IS_ERR(ah))

		return (void *) ah;



	hdr_len = data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class);

	hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class);

	msg = ib_create_send_mad(agent, recv_wc->wc->src_qp,

				 recv_wc->wc->pkey_index, 1,

				 hdr_len, 0, GFP_KERNEL);
@@ -408,7 +397,7 @@ static inline int get_mad_len(struct mad_rmpp_recv *rmpp_recv) 


	rmpp_mad = (struct ib_rmpp_mad *)rmpp_recv->cur_seg_buf->mad;



	hdr_size = data_offset(rmpp_mad->mad_hdr.mgmt_class);

	hdr_size = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class);

	data_size = sizeof(struct ib_rmpp_mad) - hdr_size;

	pad = IB_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);

	if (pad > IB_MGMT_RMPP_DATA || pad < 0)
@@ -562,15 +551,15 @@ static int send_next_seg(struct ib_mad_send_wr_private *mad_send_wr) 
	return ib_send_mad(mad_send_wr);

}



static void abort_send(struct ib_mad_agent_private *agent, __be64 tid,

		       u8 rmpp_status)

static void abort_send(struct ib_mad_agent_private *agent,

		       struct ib_mad_recv_wc *mad_recv_wc, u8 rmpp_status)

{

	struct ib_mad_send_wr_private *mad_send_wr;

	struct ib_mad_send_wc wc;

	unsigned long flags;



	spin_lock_irqsave(&agent->lock, flags);

	mad_send_wr = ib_find_send_mad(agent, tid);

	mad_send_wr = ib_find_send_mad(agent, mad_recv_wc);

	if (!mad_send_wr)

		goto out;	/* Unmatched send */
@@ -612,8 +601,7 @@ static void process_rmpp_ack(struct ib_mad_agent_private *agent, 


	rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad;

	if (rmpp_mad->rmpp_hdr.rmpp_status) {

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   IB_MGMT_RMPP_STATUS_BAD_STATUS);

		abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);

		nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);

		return;

	}
@@ -621,14 +609,13 @@ static void process_rmpp_ack(struct ib_mad_agent_private *agent, 
	seg_num = be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num);

	newwin = be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin);

	if (newwin < seg_num) {

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   IB_MGMT_RMPP_STATUS_W2S);

		abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S);

		nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S);

		return;

	}



	spin_lock_irqsave(&agent->lock, flags);

	mad_send_wr = ib_find_send_mad(agent, rmpp_mad->mad_hdr.tid);

	mad_send_wr = ib_find_send_mad(agent, mad_recv_wc);

	if (!mad_send_wr)

		goto out;	/* Unmatched ACK */
@@ -639,8 +626,7 @@ static void process_rmpp_ack(struct ib_mad_agent_private *agent, 
	if (seg_num > mad_send_wr->send_buf.seg_count ||

	    seg_num > mad_send_wr->newwin) {

		spin_unlock_irqrestore(&agent->lock, flags);

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   IB_MGMT_RMPP_STATUS_S2B);

		abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B);

		nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B);

		return;

	}
@@ -728,12 +714,10 @@ static void process_rmpp_stop(struct ib_mad_agent_private *agent, 
	rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad;



	if (rmpp_mad->rmpp_hdr.rmpp_status != IB_MGMT_RMPP_STATUS_RESX) {

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   IB_MGMT_RMPP_STATUS_BAD_STATUS);

		abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);

		nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);

	} else

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   rmpp_mad->rmpp_hdr.rmpp_status);

		abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status);

}



static void process_rmpp_abort(struct ib_mad_agent_private *agent,
@@ -745,12 +729,10 @@ static void process_rmpp_abort(struct ib_mad_agent_private *agent, 


	if (rmpp_mad->rmpp_hdr.rmpp_status < IB_MGMT_RMPP_STATUS_ABORT_MIN ||

	    rmpp_mad->rmpp_hdr.rmpp_status > IB_MGMT_RMPP_STATUS_ABORT_MAX) {

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   IB_MGMT_RMPP_STATUS_BAD_STATUS);

		abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);

		nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS);

	} else

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   rmpp_mad->rmpp_hdr.rmpp_status);

		abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status);

}



struct ib_mad_recv_wc *
@@ -764,8 +746,7 @@ ib_process_rmpp_recv_wc(struct ib_mad_agent_private *agent, 
		return mad_recv_wc;



	if (rmpp_mad->rmpp_hdr.rmpp_version != IB_MGMT_RMPP_VERSION) {

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   IB_MGMT_RMPP_STATUS_UNV);

		abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV);

		nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV);

		goto out;

	}
@@ -783,8 +764,7 @@ ib_process_rmpp_recv_wc(struct ib_mad_agent_private *agent, 
		process_rmpp_abort(agent, mad_recv_wc);

		break;

	default:

		abort_send(agent, rmpp_mad->mad_hdr.tid,

			   IB_MGMT_RMPP_STATUS_BADT);

		abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT);

		nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT);

		break;

	}

drivers/infiniband/core/user_mad.c

+6 −24
Original line number Diff line number Diff line
@@ -177,17 +177,6 @@ static int queue_packet(struct ib_umad_file *file, 
	return ret;

}



static int data_offset(u8 mgmt_class)

{

	if (mgmt_class == IB_MGMT_CLASS_SUBN_ADM)

		return IB_MGMT_SA_HDR;

	else if ((mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START) &&

		 (mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END))

		return IB_MGMT_VENDOR_HDR;

	else

		return IB_MGMT_RMPP_HDR;

}



static void send_handler(struct ib_mad_agent *agent,

			 struct ib_mad_send_wc *send_wc)

{
@@ -283,7 +272,7 @@ static ssize_t copy_recv_mad(char __user *buf, struct ib_umad_packet *packet, 
			 */

			return -ENOSPC;

		}

		offset = data_offset(recv_buf->mad->mad_hdr.mgmt_class);

		offset = ib_get_mad_data_offset(recv_buf->mad->mad_hdr.mgmt_class);

		max_seg_payload = sizeof (struct ib_mad) - offset;



		for (left = packet->length - seg_payload, buf += seg_payload;
@@ -441,21 +430,14 @@ static ssize_t ib_umad_write(struct file *filp, const char __user *buf, 
	}



	rmpp_mad = (struct ib_rmpp_mad *) packet->mad.data;

	if (rmpp_mad->mad_hdr.mgmt_class == IB_MGMT_CLASS_SUBN_ADM) {

		hdr_len = IB_MGMT_SA_HDR;

		copy_offset = IB_MGMT_RMPP_HDR;

		rmpp_active = ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &

			      IB_MGMT_RMPP_FLAG_ACTIVE;

	} else if (rmpp_mad->mad_hdr.mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START &&

		   rmpp_mad->mad_hdr.mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END) {

		hdr_len = IB_MGMT_VENDOR_HDR;

	hdr_len = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class);

	if (!ib_is_mad_class_rmpp(rmpp_mad->mad_hdr.mgmt_class)) {

		copy_offset = IB_MGMT_MAD_HDR;

		rmpp_active = 0;

	} else {

		copy_offset = IB_MGMT_RMPP_HDR;

		rmpp_active = ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &

			      IB_MGMT_RMPP_FLAG_ACTIVE;

	} else {

		hdr_len = IB_MGMT_MAD_HDR;

		copy_offset = IB_MGMT_MAD_HDR;

		rmpp_active = 0;

	}



	data_len = count - sizeof (struct ib_user_mad) - hdr_len;

drivers/infiniband/hw/mthca/mthca_av.c

+1 −1
Original line number Diff line number Diff line
@@ -265,7 +265,7 @@ int __devinit mthca_init_av_table(struct mthca_dev *dev) 
	return -ENOMEM;

}



void __devexit mthca_cleanup_av_table(struct mthca_dev *dev)

void mthca_cleanup_av_table(struct mthca_dev *dev)

{

	if (mthca_is_memfree(dev))

		return;