Merge branch 'ip-roce' into for-next (fb1b5034) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/infiniband/Kconfig

+3 −2

Original line number	Original line	Diff line number	Diff line
	@@ -3,6 +3,8 @@ menuconfig INFINIBAND
	depends on PCI \|\| BROKEN		depends on PCI \|\| BROKEN
	depends on HAS_IOMEM		depends on HAS_IOMEM
	depends on NET		depends on NET
			depends on INET
			depends on m \|\| IPV6 != m
	---help---		---help---
	Core support for InfiniBand (IB). Make sure to also select		Core support for InfiniBand (IB). Make sure to also select
	any protocols you wish to use as well as drivers for your		any protocols you wish to use as well as drivers for your
	@@ -38,8 +40,7 @@ config INFINIBAND_USER_MEM

	config INFINIBAND_ADDR_TRANS		config INFINIBAND_ADDR_TRANS
	bool		bool
	depends on INET		depends on INFINIBAND
	depends on !(INFINIBAND = y && IPV6 = m)
	default y		default y

	source "drivers/infiniband/hw/mthca/Kconfig"		source "drivers/infiniband/hw/mthca/Kconfig"

drivers/infiniband/core/Makefile

+3 −2

Original line number	Original line	Diff line number	Diff line
	infiniband-$(CONFIG_INFINIBAND_ADDR_TRANS) := ib_addr.o rdma_cm.o		infiniband-$(CONFIG_INFINIBAND_ADDR_TRANS) := rdma_cm.o
	user_access-$(CONFIG_INFINIBAND_ADDR_TRANS) := rdma_ucm.o		user_access-$(CONFIG_INFINIBAND_ADDR_TRANS) := rdma_ucm.o

	obj-$(CONFIG_INFINIBAND) += ib_core.o ib_mad.o ib_sa.o \		obj-$(CONFIG_INFINIBAND) += ib_core.o ib_mad.o ib_sa.o \
	ib_cm.o iw_cm.o $(infiniband-y)		ib_cm.o iw_cm.o ib_addr.o \
			$(infiniband-y)
	obj-$(CONFIG_INFINIBAND_USER_MAD) += ib_umad.o		obj-$(CONFIG_INFINIBAND_USER_MAD) += ib_umad.o
	obj-$(CONFIG_INFINIBAND_USER_ACCESS) += ib_uverbs.o ib_ucm.o \		obj-$(CONFIG_INFINIBAND_USER_ACCESS) += ib_uverbs.o ib_ucm.o \
	$(user_access-y)		$(user_access-y)

drivers/infiniband/core/addr.c

+94 −3

Original line number	Original line	Diff line number	Diff line
	@@ -86,6 +86,8 @@ int rdma_addr_size(struct sockaddr *addr)
	}		}
	EXPORT_SYMBOL(rdma_addr_size);		EXPORT_SYMBOL(rdma_addr_size);

			static struct rdma_addr_client self;

	void rdma_addr_register_client(struct rdma_addr_client *client)		void rdma_addr_register_client(struct rdma_addr_client *client)
	{		{
	atomic_set(&client->refcount, 1);		atomic_set(&client->refcount, 1);
	@@ -119,7 +121,8 @@ int rdma_copy_addr(struct rdma_dev_addr dev_addr, struct net_device dev,
	}		}
	EXPORT_SYMBOL(rdma_copy_addr);		EXPORT_SYMBOL(rdma_copy_addr);

	int rdma_translate_ip(struct sockaddr addr, struct rdma_dev_addr dev_addr)		int rdma_translate_ip(struct sockaddr addr, struct rdma_dev_addr dev_addr,
			u16 *vlan_id)
	{		{
	struct net_device *dev;		struct net_device *dev;
	int ret = -EADDRNOTAVAIL;		int ret = -EADDRNOTAVAIL;
	@@ -142,6 +145,8 @@ int rdma_translate_ip(struct sockaddr addr, struct rdma_dev_addr dev_addr)
	return ret;		return ret;

	ret = rdma_copy_addr(dev_addr, dev, NULL);		ret = rdma_copy_addr(dev_addr, dev, NULL);
			if (vlan_id)
			*vlan_id = rdma_vlan_dev_vlan_id(dev);
	dev_put(dev);		dev_put(dev);
	break;		break;

	@@ -153,6 +158,8 @@ int rdma_translate_ip(struct sockaddr addr, struct rdma_dev_addr dev_addr)
	&((struct sockaddr_in6 *) addr)->sin6_addr,		&((struct sockaddr_in6 *) addr)->sin6_addr,
	dev, 1)) {		dev, 1)) {
	ret = rdma_copy_addr(dev_addr, dev, NULL);		ret = rdma_copy_addr(dev_addr, dev, NULL);
			if (vlan_id)
			*vlan_id = rdma_vlan_dev_vlan_id(dev);
	break;		break;
	}		}
	}		}
	@@ -238,7 +245,7 @@ static int addr4_resolve(struct sockaddr_in *src_in,
	src_in->sin_addr.s_addr = fl4.saddr;		src_in->sin_addr.s_addr = fl4.saddr;

	if (rt->dst.dev->flags & IFF_LOOPBACK) {		if (rt->dst.dev->flags & IFF_LOOPBACK) {
	ret = rdma_translate_ip((struct sockaddr *) dst_in, addr);		ret = rdma_translate_ip((struct sockaddr *)dst_in, addr, NULL);
	if (!ret)		if (!ret)
	memcpy(addr->dst_dev_addr, addr->src_dev_addr, MAX_ADDR_LEN);		memcpy(addr->dst_dev_addr, addr->src_dev_addr, MAX_ADDR_LEN);
	goto put;		goto put;
	@@ -286,7 +293,7 @@ static int addr6_resolve(struct sockaddr_in6 *src_in,
	}		}

	if (dst->dev->flags & IFF_LOOPBACK) {		if (dst->dev->flags & IFF_LOOPBACK) {
	ret = rdma_translate_ip((struct sockaddr *) dst_in, addr);		ret = rdma_translate_ip((struct sockaddr *)dst_in, addr, NULL);
	if (!ret)		if (!ret)
	memcpy(addr->dst_dev_addr, addr->src_dev_addr, MAX_ADDR_LEN);		memcpy(addr->dst_dev_addr, addr->src_dev_addr, MAX_ADDR_LEN);
	goto put;		goto put;
	@@ -437,6 +444,88 @@ void rdma_addr_cancel(struct rdma_dev_addr *addr)
	}		}
	EXPORT_SYMBOL(rdma_addr_cancel);		EXPORT_SYMBOL(rdma_addr_cancel);

			struct resolve_cb_context {
			struct rdma_dev_addr *addr;
			struct completion comp;
			};

			static void resolve_cb(int status, struct sockaddr *src_addr,
			struct rdma_dev_addr addr, void context)
			{
			memcpy(((struct resolve_cb_context *)context)->addr, addr, sizeof(struct
			rdma_dev_addr));
			complete(&((struct resolve_cb_context *)context)->comp);
			}

			int rdma_addr_find_dmac_by_grh(union ib_gid sgid, union ib_gid dgid, u8 *dmac,
			u16 *vlan_id)
			{
			int ret = 0;
			struct rdma_dev_addr dev_addr;
			struct resolve_cb_context ctx;
			struct net_device *dev;

			union {
			struct sockaddr _sockaddr;
			struct sockaddr_in _sockaddr_in;
			struct sockaddr_in6 _sockaddr_in6;
			} sgid_addr, dgid_addr;


			ret = rdma_gid2ip(&sgid_addr._sockaddr, sgid);
			if (ret)
			return ret;

			ret = rdma_gid2ip(&dgid_addr._sockaddr, dgid);
			if (ret)
			return ret;

			memset(&dev_addr, 0, sizeof(dev_addr));

			ctx.addr = &dev_addr;
			init_completion(&ctx.comp);
			ret = rdma_resolve_ip(&self, &sgid_addr._sockaddr, &dgid_addr._sockaddr,
			&dev_addr, 1000, resolve_cb, &ctx);
			if (ret)
			return ret;

			wait_for_completion(&ctx.comp);

			memcpy(dmac, dev_addr.dst_dev_addr, ETH_ALEN);
			dev = dev_get_by_index(&init_net, dev_addr.bound_dev_if);
			if (!dev)
			return -ENODEV;
			if (vlan_id)
			*vlan_id = rdma_vlan_dev_vlan_id(dev);
			dev_put(dev);
			return ret;
			}
			EXPORT_SYMBOL(rdma_addr_find_dmac_by_grh);

			int rdma_addr_find_smac_by_sgid(union ib_gid sgid, u8 smac, u16 *vlan_id)
			{
			int ret = 0;
			struct rdma_dev_addr dev_addr;
			union {
			struct sockaddr _sockaddr;
			struct sockaddr_in _sockaddr_in;
			struct sockaddr_in6 _sockaddr_in6;
			} gid_addr;

			ret = rdma_gid2ip(&gid_addr._sockaddr, sgid);

			if (ret)
			return ret;
			memset(&dev_addr, 0, sizeof(dev_addr));
			ret = rdma_translate_ip(&gid_addr._sockaddr, &dev_addr, vlan_id);
			if (ret)
			return ret;

			memcpy(smac, dev_addr.src_dev_addr, ETH_ALEN);
			return ret;
			}
			EXPORT_SYMBOL(rdma_addr_find_smac_by_sgid);

	static int netevent_callback(struct notifier_block *self, unsigned long event,		static int netevent_callback(struct notifier_block *self, unsigned long event,
	void *ctx)		void *ctx)
	{		{
	@@ -461,11 +550,13 @@ static int __init addr_init(void)
	return -ENOMEM;		return -ENOMEM;

	register_netevent_notifier(&nb);		register_netevent_notifier(&nb);
			rdma_addr_register_client(&self);
	return 0;		return 0;
	}		}

	static void __exit addr_cleanup(void)		static void __exit addr_cleanup(void)
	{		{
			rdma_addr_unregister_client(&self);
	unregister_netevent_notifier(&nb);		unregister_netevent_notifier(&nb);
	destroy_workqueue(addr_wq);		destroy_workqueue(addr_wq);
	}		}

drivers/infiniband/core/cm.c

+52 −0

Original line number	Original line	Diff line number	Diff line
	@@ -47,6 +47,7 @@
	#include <linux/sysfs.h>		#include <linux/sysfs.h>
	#include <linux/workqueue.h>		#include <linux/workqueue.h>
	#include <linux/kdev_t.h>		#include <linux/kdev_t.h>
			#include <linux/etherdevice.h>

	#include <rdma/ib_cache.h>		#include <rdma/ib_cache.h>
	#include <rdma/ib_cm.h>		#include <rdma/ib_cm.h>
	@@ -177,6 +178,8 @@ struct cm_av {
	struct ib_ah_attr ah_attr;		struct ib_ah_attr ah_attr;
	u16 pkey_index;		u16 pkey_index;
	u8 timeout;		u8 timeout;
			u8 valid;
			u8 smac[ETH_ALEN];
	};		};

	struct cm_work {		struct cm_work {
	@@ -346,6 +349,23 @@ static void cm_init_av_for_response(struct cm_port port, struct ib_wc wc,
	grh, &av->ah_attr);		grh, &av->ah_attr);
	}		}

			int ib_update_cm_av(struct ib_cm_id id, const u8 smac, const u8 *alt_smac)
			{
			struct cm_id_private *cm_id_priv;

			cm_id_priv = container_of(id, struct cm_id_private, id);

			if (smac != NULL)
			memcpy(cm_id_priv->av.smac, smac, sizeof(cm_id_priv->av.smac));

			if (alt_smac != NULL)
			memcpy(cm_id_priv->alt_av.smac, alt_smac,
			sizeof(cm_id_priv->alt_av.smac));

			return 0;
			}
			EXPORT_SYMBOL(ib_update_cm_av);

	static int cm_init_av_by_path(struct ib_sa_path_rec path, struct cm_av av)		static int cm_init_av_by_path(struct ib_sa_path_rec path, struct cm_av av)
	{		{
	struct cm_device *cm_dev;		struct cm_device *cm_dev;
	@@ -376,6 +396,9 @@ static int cm_init_av_by_path(struct ib_sa_path_rec path, struct cm_av av)
	ib_init_ah_from_path(cm_dev->ib_device, port->port_num, path,		ib_init_ah_from_path(cm_dev->ib_device, port->port_num, path,
	&av->ah_attr);		&av->ah_attr);
	av->timeout = path->packet_life_time + 1;		av->timeout = path->packet_life_time + 1;
			memcpy(av->smac, path->smac, sizeof(av->smac));

			av->valid = 1;
	return 0;		return 0;
	}		}

	@@ -1554,6 +1577,9 @@ static int cm_req_handler(struct cm_work *work)

	cm_process_routed_req(req_msg, work->mad_recv_wc->wc);		cm_process_routed_req(req_msg, work->mad_recv_wc->wc);
	cm_format_paths_from_req(req_msg, &work->path[0], &work->path[1]);		cm_format_paths_from_req(req_msg, &work->path[0], &work->path[1]);

			memcpy(work->path[0].dmac, cm_id_priv->av.ah_attr.dmac, ETH_ALEN);
			work->path[0].vlan_id = cm_id_priv->av.ah_attr.vlan_id;
	ret = cm_init_av_by_path(&work->path[0], &cm_id_priv->av);		ret = cm_init_av_by_path(&work->path[0], &cm_id_priv->av);
	if (ret) {		if (ret) {
	ib_get_cached_gid(work->port->cm_dev->ib_device,		ib_get_cached_gid(work->port->cm_dev->ib_device,
	@@ -3500,6 +3526,32 @@ static int cm_init_qp_rtr_attr(struct cm_id_private *cm_id_priv,
	*qp_attr_mask = IB_QP_STATE \| IB_QP_AV \| IB_QP_PATH_MTU \|		*qp_attr_mask = IB_QP_STATE \| IB_QP_AV \| IB_QP_PATH_MTU \|
	IB_QP_DEST_QPN \| IB_QP_RQ_PSN;		IB_QP_DEST_QPN \| IB_QP_RQ_PSN;
	qp_attr->ah_attr = cm_id_priv->av.ah_attr;		qp_attr->ah_attr = cm_id_priv->av.ah_attr;
			if (!cm_id_priv->av.valid) {
			spin_unlock_irqrestore(&cm_id_priv->lock, flags);
			return -EINVAL;
			}
			if (cm_id_priv->av.ah_attr.vlan_id != 0xffff) {
			qp_attr->vlan_id = cm_id_priv->av.ah_attr.vlan_id;
			*qp_attr_mask \|= IB_QP_VID;
			}
			if (!is_zero_ether_addr(cm_id_priv->av.smac)) {
			memcpy(qp_attr->smac, cm_id_priv->av.smac,
			sizeof(qp_attr->smac));
			*qp_attr_mask \|= IB_QP_SMAC;
			}
			if (cm_id_priv->alt_av.valid) {
			if (cm_id_priv->alt_av.ah_attr.vlan_id != 0xffff) {
			qp_attr->alt_vlan_id =
			cm_id_priv->alt_av.ah_attr.vlan_id;
			*qp_attr_mask \|= IB_QP_ALT_VID;
			}
			if (!is_zero_ether_addr(cm_id_priv->alt_av.smac)) {
			memcpy(qp_attr->alt_smac,
			cm_id_priv->alt_av.smac,
			sizeof(qp_attr->alt_smac));
			*qp_attr_mask \|= IB_QP_ALT_SMAC;
			}
			}
	qp_attr->path_mtu = cm_id_priv->path_mtu;		qp_attr->path_mtu = cm_id_priv->path_mtu;
	qp_attr->dest_qp_num = be32_to_cpu(cm_id_priv->remote_qpn);		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);		qp_attr->rq_psn = be32_to_cpu(cm_id_priv->rq_psn);

drivers/infiniband/core/cma.c

+61 −13

Original line number	Original line	Diff line number	Diff line
	@@ -340,7 +340,7 @@ static int cma_translate_addr(struct sockaddr addr, struct rdma_dev_addr dev_a
	int ret;		int ret;

	if (addr->sa_family != AF_IB) {		if (addr->sa_family != AF_IB) {
	ret = rdma_translate_ip(addr, dev_addr);		ret = rdma_translate_ip(addr, dev_addr, NULL);
	} else {		} else {
	cma_translate_ib((struct sockaddr_ib *) addr, dev_addr);		cma_translate_ib((struct sockaddr_ib *) addr, dev_addr);
	ret = 0;		ret = 0;
	@@ -365,7 +365,9 @@ static int cma_acquire_dev(struct rdma_id_private *id_priv,
	return -EINVAL;		return -EINVAL;

	mutex_lock(&lock);		mutex_lock(&lock);
	iboe_addr_get_sgid(dev_addr, &iboe_gid);		rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.src_addr,
			&iboe_gid);

	memcpy(&gid, dev_addr->src_dev_addr +		memcpy(&gid, dev_addr->src_dev_addr +
	rdma_addr_gid_offset(dev_addr), sizeof gid);		rdma_addr_gid_offset(dev_addr), sizeof gid);
	if (listen_id_priv &&		if (listen_id_priv &&
	@@ -603,6 +605,7 @@ static int cma_modify_qp_rtr(struct rdma_id_private *id_priv,
	{		{
	struct ib_qp_attr qp_attr;		struct ib_qp_attr qp_attr;
	int qp_attr_mask, ret;		int qp_attr_mask, ret;
			union ib_gid sgid;

	mutex_lock(&id_priv->qp_mutex);		mutex_lock(&id_priv->qp_mutex);
	if (!id_priv->id.qp) {		if (!id_priv->id.qp) {
	@@ -625,6 +628,20 @@ static int cma_modify_qp_rtr(struct rdma_id_private *id_priv,
	if (ret)		if (ret)
	goto out;		goto out;

			ret = ib_query_gid(id_priv->id.device, id_priv->id.port_num,
			qp_attr.ah_attr.grh.sgid_index, &sgid);
			if (ret)
			goto out;

			if (rdma_node_get_transport(id_priv->cma_dev->device->node_type)
			== RDMA_TRANSPORT_IB &&
			rdma_port_get_link_layer(id_priv->id.device, id_priv->id.port_num)
			== IB_LINK_LAYER_ETHERNET) {
			ret = rdma_addr_find_smac_by_sgid(&sgid, qp_attr.smac, NULL);

			if (ret)
			goto out;
			}
	if (conn_param)		if (conn_param)
	qp_attr.max_dest_rd_atomic = conn_param->responder_resources;		qp_attr.max_dest_rd_atomic = conn_param->responder_resources;
	ret = ib_modify_qp(id_priv->id.qp, &qp_attr, qp_attr_mask);		ret = ib_modify_qp(id_priv->id.qp, &qp_attr, qp_attr_mask);
	@@ -725,6 +742,7 @@ int rdma_init_qp_attr(struct rdma_cm_id id, struct ib_qp_attr qp_attr,
	else		else
	ret = ib_cm_init_qp_attr(id_priv->cm_id.ib, qp_attr,		ret = ib_cm_init_qp_attr(id_priv->cm_id.ib, qp_attr,
	qp_attr_mask);		qp_attr_mask);

	if (qp_attr->qp_state == IB_QPS_RTR)		if (qp_attr->qp_state == IB_QPS_RTR)
	qp_attr->rq_psn = id_priv->seq_num;		qp_attr->rq_psn = id_priv->seq_num;
	break;		break;
	@@ -1266,6 +1284,15 @@ 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;		struct rdma_id_private listen_id, conn_id;
	struct rdma_cm_event event;		struct rdma_cm_event event;
	int offset, ret;		int offset, ret;
			u8 smac[ETH_ALEN];
			u8 alt_smac[ETH_ALEN];
			u8 *psmac = smac;
			u8 *palt_smac = alt_smac;
			int is_iboe = ((rdma_node_get_transport(cm_id->device->node_type) ==
			RDMA_TRANSPORT_IB) &&
			(rdma_port_get_link_layer(cm_id->device,
			ib_event->param.req_rcvd.port) ==
			IB_LINK_LAYER_ETHERNET));

	listen_id = cm_id->context;		listen_id = cm_id->context;
	if (!cma_check_req_qp_type(&listen_id->id, ib_event))		if (!cma_check_req_qp_type(&listen_id->id, ib_event))
	@@ -1310,12 +1337,29 @@ static int cma_req_handler(struct ib_cm_id cm_id, struct ib_cm_event ib_event)
	if (ret)		if (ret)
	goto err3;		goto err3;

			if (is_iboe) {
			if (ib_event->param.req_rcvd.primary_path != NULL)
			rdma_addr_find_smac_by_sgid(
			&ib_event->param.req_rcvd.primary_path->sgid,
			psmac, NULL);
			else
			psmac = NULL;
			if (ib_event->param.req_rcvd.alternate_path != NULL)
			rdma_addr_find_smac_by_sgid(
			&ib_event->param.req_rcvd.alternate_path->sgid,
			palt_smac, NULL);
			else
			palt_smac = NULL;
			}
	/*		/*
	* Acquire mutex to prevent user executing rdma_destroy_id()		* Acquire mutex to prevent user executing rdma_destroy_id()
	* while we're accessing the cm_id.		* while we're accessing the cm_id.
	*/		*/
	mutex_lock(&lock);		mutex_lock(&lock);
	if (cma_comp(conn_id, RDMA_CM_CONNECT) && (conn_id->id.qp_type != IB_QPT_UD))		if (is_iboe)
			ib_update_cm_av(cm_id, psmac, palt_smac);
			if (cma_comp(conn_id, RDMA_CM_CONNECT) &&
			(conn_id->id.qp_type != IB_QPT_UD))
	ib_send_cm_mra(cm_id, CMA_CM_MRA_SETTING, NULL, 0);		ib_send_cm_mra(cm_id, CMA_CM_MRA_SETTING, NULL, 0);
	mutex_unlock(&lock);		mutex_unlock(&lock);
	mutex_unlock(&conn_id->handler_mutex);		mutex_unlock(&conn_id->handler_mutex);
	@@ -1474,7 +1518,7 @@ static int iw_conn_req_handler(struct iw_cm_id *cm_id,
	mutex_lock_nested(&conn_id->handler_mutex, SINGLE_DEPTH_NESTING);		mutex_lock_nested(&conn_id->handler_mutex, SINGLE_DEPTH_NESTING);
	conn_id->state = RDMA_CM_CONNECT;		conn_id->state = RDMA_CM_CONNECT;

	ret = rdma_translate_ip(laddr, &conn_id->id.route.addr.dev_addr);		ret = rdma_translate_ip(laddr, &conn_id->id.route.addr.dev_addr, NULL);
	if (ret) {		if (ret) {
	mutex_unlock(&conn_id->handler_mutex);		mutex_unlock(&conn_id->handler_mutex);
	rdma_destroy_id(new_cm_id);		rdma_destroy_id(new_cm_id);
	@@ -1873,7 +1917,7 @@ static int cma_resolve_iboe_route(struct rdma_id_private *id_priv)
	struct cma_work *work;		struct cma_work *work;
	int ret;		int ret;
	struct net_device *ndev = NULL;		struct net_device *ndev = NULL;
	u16 vid;

	work = kzalloc(sizeof *work, GFP_KERNEL);		work = kzalloc(sizeof *work, GFP_KERNEL);
	if (!work)		if (!work)
	@@ -1897,10 +1941,14 @@ static int cma_resolve_iboe_route(struct rdma_id_private *id_priv)
	goto err2;		goto err2;
	}		}

	vid = rdma_vlan_dev_vlan_id(ndev);		route->path_rec->vlan_id = rdma_vlan_dev_vlan_id(ndev);
			memcpy(route->path_rec->dmac, addr->dev_addr.dst_dev_addr, ETH_ALEN);
			memcpy(route->path_rec->smac, ndev->dev_addr, ndev->addr_len);

	iboe_mac_vlan_to_ll(&route->path_rec->sgid, addr->dev_addr.src_dev_addr, vid);		rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.src_addr,
	iboe_mac_vlan_to_ll(&route->path_rec->dgid, addr->dev_addr.dst_dev_addr, vid);		&route->path_rec->sgid);
			rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.dst_addr,
			&route->path_rec->dgid);

	route->path_rec->hop_limit = 1;		route->path_rec->hop_limit = 1;
	route->path_rec->reversible = 1;		route->path_rec->reversible = 1;
	@@ -2063,6 +2111,7 @@ static void addr_handler(int status, struct sockaddr *src_addr,
	RDMA_CM_ADDR_RESOLVED))		RDMA_CM_ADDR_RESOLVED))
	goto out;		goto out;

			memcpy(cma_src_addr(id_priv), src_addr, rdma_addr_size(src_addr));
	if (!status && !id_priv->cma_dev)		if (!status && !id_priv->cma_dev)
	status = cma_acquire_dev(id_priv, NULL);		status = cma_acquire_dev(id_priv, NULL);

	@@ -2072,10 +2121,8 @@ static void addr_handler(int status, struct sockaddr *src_addr,
	goto out;		goto out;
	event.event = RDMA_CM_EVENT_ADDR_ERROR;		event.event = RDMA_CM_EVENT_ADDR_ERROR;
	event.status = status;		event.status = status;
	} else {		} else
	memcpy(cma_src_addr(id_priv), src_addr, rdma_addr_size(src_addr));
	event.event = RDMA_CM_EVENT_ADDR_RESOLVED;		event.event = RDMA_CM_EVENT_ADDR_RESOLVED;
	}

	if (id_priv->id.event_handler(&id_priv->id, &event)) {		if (id_priv->id.event_handler(&id_priv->id, &event)) {
	cma_exch(id_priv, RDMA_CM_DESTROYING);		cma_exch(id_priv, RDMA_CM_DESTROYING);
	@@ -2559,6 +2606,7 @@ int rdma_bind_addr(struct rdma_cm_id id, struct sockaddr addr)
	if (ret)		if (ret)
	goto err1;		goto err1;

			memcpy(cma_src_addr(id_priv), addr, rdma_addr_size(addr));
	if (!cma_any_addr(addr)) {		if (!cma_any_addr(addr)) {
	ret = cma_translate_addr(addr, &id->route.addr.dev_addr);		ret = cma_translate_addr(addr, &id->route.addr.dev_addr);
	if (ret)		if (ret)
	@@ -2569,7 +2617,6 @@ int rdma_bind_addr(struct rdma_cm_id id, struct sockaddr addr)
	goto err1;		goto err1;
	}		}

	memcpy(cma_src_addr(id_priv), addr, rdma_addr_size(addr));
	if (!(id_priv->options & (1 << CMA_OPTION_AFONLY))) {		if (!(id_priv->options & (1 << CMA_OPTION_AFONLY))) {
	if (addr->sa_family == AF_INET)		if (addr->sa_family == AF_INET)
	id_priv->afonly = 1;		id_priv->afonly = 1;
	@@ -3298,7 +3345,8 @@ static int cma_iboe_join_multicast(struct rdma_id_private *id_priv,
	err = -EINVAL;		err = -EINVAL;
	goto out2;		goto out2;
	}		}
	iboe_addr_get_sgid(dev_addr, &mc->multicast.ib->rec.port_gid);		rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.src_addr,
			&mc->multicast.ib->rec.port_gid);
	work->id = id_priv;		work->id = id_priv;
	work->mc = mc;		work->mc = mc;
	INIT_WORK(&work->work, iboe_mcast_work_handler);		INIT_WORK(&work->work, iboe_mcast_work_handler);