Attachment #236319 for bug #266054

Lines 467-477 int Link Here

(-)b/sys/dev/irdma/fbsd_kcompat.c (-1 / +3 lines)
467	irdma_resolve_neigh_lpb_chk(struct irdma_device iwdev, struct irdma_cm_node cm_node,	467	irdma_resolve_neigh_lpb_chk(struct irdma_device iwdev, struct irdma_cm_node cm_node,
468	struct irdma_cm_info *cm_info)	468	struct irdma_cm_info *cm_info)
469	{	469	{
		470	struct rdma_cm_id rdma_id = (struct rdma_cm_id )cm_node->cm_id->context;
		471	struct vnet *vnet = rdma_id->route.addr.dev_addr.net;
470	int arpindex;	472	int arpindex;
471	int oldarpindex;	473	int oldarpindex;
472		474
473	if ((cm_node->ipv4 &&	475	if ((cm_node->ipv4 &&
474	irdma_ipv4_is_lpb(cm_node->loc_addr[0], cm_node->rem_addr[0])) \|\|	476	irdma_ipv4_is_lpb(vnet, cm_node->loc_addr[0], cm_node->rem_addr[0])) \|\|
475	(!cm_node->ipv4 &&	477	(!cm_node->ipv4 &&
476	irdma_ipv6_is_lpb(cm_node->loc_addr, cm_node->rem_addr))) {	478	irdma_ipv6_is_lpb(cm_node->loc_addr, cm_node->rem_addr))) {
477	cm_node->do_lpb = true;	479	cm_node->do_lpb = true;

Lines 2055-2063 irdma_add_hte_node(struct irdma_cm_core *cm_core, Link Here

(-)b/sys/dev/irdma/irdma_cm.c (-3 / +12 lines)
2055	* @rem_addr: remote address	2055	* @rem_addr: remote address
2056	*/	2056	*/
2057	bool	2057	bool
2058	irdma_ipv4_is_lpb(u32 loc_addr, u32 rem_addr)	2058	irdma_ipv4_is_lpb(struct vnet *vnet, u32 loc_addr, u32 rem_addr)
2059	{	2059	{
2060	return ipv4_is_loopback(htonl(rem_addr)) \|\| (loc_addr == rem_addr);	2060	bool ret;
		2061
		2062	CURVNET_SET_QUIET(vnet);
		2063	ret = ipv4_is_loopback(htonl(rem_addr)) \|\| (loc_addr == rem_addr);
		2064	CURVNET_RESTORE();
		2065
		2066	return (ret);
2061	}	2067	}
2062		2068
2063	/**	2069	/**
Lines 2083-2088 irdma_ipv6_is_lpb(u32 loc_addr, u32 rem_addr) Link Here
2083	static int	2089	static int
2084	irdma_cm_create_ah(struct irdma_cm_node *cm_node, bool wait)	2090	irdma_cm_create_ah(struct irdma_cm_node *cm_node, bool wait)
2085	{	2091	{
		2092	struct rdma_cm_id rdma_id = (struct rdma_cm_id )cm_node->cm_id->context;
		2093	struct vnet *vnet = rdma_id->route.addr.dev_addr.net;
2086	struct irdma_ah_info ah_info = {0};	2094	struct irdma_ah_info ah_info = {0};
2087	struct irdma_device *iwdev = cm_node->iwdev;	2095	struct irdma_device *iwdev = cm_node->iwdev;
2088		2096
Lines 2096-2102 irdma_cm_create_ah(struct irdma_cm_node *cm_node, bool wait) Link Here
2096	ah_info.ipv4_valid = true;	2104	ah_info.ipv4_valid = true;
2097	ah_info.dest_ip_addr[0] = cm_node->rem_addr[0];	2105	ah_info.dest_ip_addr[0] = cm_node->rem_addr[0];
2098	ah_info.src_ip_addr[0] = cm_node->loc_addr[0];	2106	ah_info.src_ip_addr[0] = cm_node->loc_addr[0];
2099	ah_info.do_lpbk = irdma_ipv4_is_lpb(ah_info.src_ip_addr[0],	2107	ah_info.do_lpbk = irdma_ipv4_is_lpb(vnet,
		2108	ah_info.src_ip_addr[0],
2100	ah_info.dest_ip_addr[0]);	2109	ah_info.dest_ip_addr[0]);
2101	} else {	2110	} else {
2102	memcpy(ah_info.dest_ip_addr, cm_node->rem_addr,	2111	memcpy(ah_info.dest_ip_addr, cm_node->rem_addr,

Lines 441-447 void irdma_cm_teardown_connections(struct irdma_device iwdev, u32 ipaddr, Link Here

(-)b/sys/dev/irdma/irdma_cm.h (-1 / +1 lines)
441	bool disconnect_all);	441	bool disconnect_all);
442	int irdma_cm_start(struct irdma_device *dev);	442	int irdma_cm_start(struct irdma_device *dev);
443	int irdma_cm_stop(struct irdma_device *dev);	443	int irdma_cm_stop(struct irdma_device *dev);
444	bool irdma_ipv4_is_lpb(u32 loc_addr, u32 rem_addr);	444	bool irdma_ipv4_is_lpb(struct vnet *, u32 loc_addr, u32 rem_addr);
445	bool irdma_ipv6_is_lpb(u32 loc_addr, u32 rem_addr);	445	bool irdma_ipv6_is_lpb(u32 loc_addr, u32 rem_addr);
446	int irdma_arp_table(struct irdma_pci_f rf, u32 ip_addr,	446	int irdma_arp_table(struct irdma_pci_f rf, u32 ip_addr,
447	u8 *mac_addr, u32 action);	447	u8 *mac_addr, u32 action);




}

static void
irdma_fill_ah_info(struct vnet *vnet,
		   struct irdma_ah_info *ah_info,
		   const struct ib_gid_attr *sgid_attr,
		   struct sockaddr *sgid_addr, struct sockaddr *dgid_addr,
		   u8 *dmac, u8 net_type)

		    ntohl(((struct sockaddr_in *)dgid_addr)->sin_addr.s_addr);
		ah_info->src_ip_addr[0] =
		    ntohl(((struct sockaddr_in *)sgid_addr)->sin_addr.s_addr);
		ah_info->do_lpbk = irdma_ipv4_is_lpb(vnet,
						     ah_info->src_ip_addr[0],
						     ah_info->dest_ip_addr[0]);
		if (ipv4_is_multicast(((struct sockaddr_in *)dgid_addr)->sin_addr.s_addr)) {
			irdma_mcast_mac_v4(ah_info->dest_ip_addr, dmac);


	ether_addr_copy(dmac, attr->dmac);

	irdma_fill_ah_info(iwdev->netdev->if_vnet,
			   ah_info, &sgid_attr, &sgid_addr.saddr, &dgid_addr.saddr,
			   dmac, ah->av.net_type);

	err = irdma_create_ah_vlan_tag(iwdev, ah_info, &sgid_attr, dmac);




	}
}

static inline bool cma_any_addr(struct vnet *vnet, struct sockaddr *addr)
{
	bool ret;

	CURVNET_SET_QUIET(vnet);
	ret = cma_zero_addr(addr) || cma_loopback_addr(addr);
	CURVNET_RESTORE();

	return (ret);
}

static int cma_addr_cmp(struct sockaddr *src, struct sockaddr *dst)

{
	__be32 ip4_addr;
	struct in6_addr ip6_addr;
	struct vnet *vnet = id_priv->id.route.addr.dev_addr.net;

	switch (addr->sa_family) {
	case AF_INET:
		ip4_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
		if (sdp_get_ip_ver(hdr) != 4)
			return false;
		if (!cma_any_addr(vnet, addr) &&
		    hdr->dst_addr.ip4.addr != ip4_addr)
			return false;
		break;

		if (sdp_get_ip_ver(hdr) != 6)
			return false;
		cma_ip6_clear_scope_id(&ip6_addr);
		if (!cma_any_addr(vnet, addr) &&
		    memcmp(&hdr->dst_addr.ip6, &ip6_addr, sizeof(ip6_addr)))
			return false;
		break;

{
	const struct cma_hdr *hdr = vhdr;
	struct sockaddr *addr = cma_src_addr(id_priv);
	struct vnet *vnet = id_priv->id.route.addr.dev_addr.net;
	__be32 ip4_addr;
	struct in6_addr ip6_addr;

	if (cma_any_addr(vnet, addr) && !id_priv->afonly)
		return true;

	if (id_priv->id.ps == RDMA_PS_SDP)

		ip4_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
		if (cma_get_ip_ver(hdr) != 4)
			return false;
		if (!cma_any_addr(vnet, addr) &&
		    hdr->dst_addr.ip4.addr != ip4_addr)
			return false;
		break;

		if (cma_get_ip_ver(hdr) != 6)
			return false;
		cma_ip6_clear_scope_id(&ip6_addr);
		if (!cma_any_addr(vnet, addr) &&
		    memcmp(&hdr->dst_addr.ip6, &ip6_addr, sizeof(ip6_addr)))
			return false;
		break;

static void cma_cancel_operation(struct rdma_id_private *id_priv,
				 enum rdma_cm_state state)
{
  	struct vnet *vnet = id_priv->id.route.addr.dev_addr.net;

	switch (state) {
	case RDMA_CM_ADDR_QUERY:
		rdma_addr_cancel(&id_priv->id.route.addr.dev_addr);

		cma_cancel_route(id_priv);
		break;
	case RDMA_CM_LISTEN:
		if (cma_any_addr(vnet, cma_src_addr(id_priv)) && !id_priv->cma_dev)
			cma_cancel_listens(id_priv);
		break;
	default:

	const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;
	const __be64 service_id =
		      ib_event->param.req_rcvd.primary_path->service_id;
	struct vnet *vnet = listen_id->route.addr.dev_addr.net;
	int ret;

	id = rdma_create_id(vnet,
			    listen_id->event_handler, listen_id->context,
			    listen_id->ps, ib_event->param.req_rcvd.qp_type);
	if (IS_ERR(id))

			goto err;
	} else {
		if (!cma_protocol_roce(listen_id) &&
		    cma_any_addr(vnet, cma_src_addr(id_priv))) {
			rt->addr.dev_addr.dev_type = ARPHRD_INFINIBAND;
			rdma_addr_set_sgid(&rt->addr.dev_addr, &rt->path_rec[0].sgid);
			ib_addr_set_pkey(&rt->addr.dev_addr, be16_to_cpu(rt->path_rec[0].pkey));
		} else if (!cma_any_addr(vnet, cma_src_addr(id_priv))) {
			ret = cma_translate_addr(cma_src_addr(id_priv), &rt->addr.dev_addr);
			if (ret)
				goto err;

	struct rdma_id_private *id_priv;
	struct rdma_cm_id *id;
	const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;
	struct vnet *vnet = listen_id->route.addr.dev_addr.net;
	int ret;

	id = rdma_create_id(vnet, listen_id->event_handler, listen_id->context,
			    listen_id->ps, IB_QPT_UD);
	if (IS_ERR(id))
		return NULL;

		if (ret)
			goto err;
	} else {
		if (!cma_any_addr(vnet, cma_src_addr(id_priv))) {
			ret = cma_translate_addr(cma_src_addr(id_priv),
						 &id->route.addr.dev_addr);
			if (ret)

		      struct sockaddr *dst_addr, int timeout_ms)
{
	struct rdma_id_private *id_priv;
	struct vnet *vnet = id->route.addr.dev_addr.net;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);


	atomic_inc(&id_priv->refcount);
	memcpy(cma_dst_addr(id_priv), dst_addr, rdma_addr_size(dst_addr));
	if (cma_any_addr(vnet, dst_addr)) {
		ret = cma_resolve_loopback(id_priv);
	} else {
		if (dst_addr->sa_family == AF_IB) {

{
	struct rdma_id_private *cur_id;
	struct sockaddr *addr, *cur_addr;
	struct vnet *vnet;

	addr = cma_src_addr(id_priv);
	hlist_for_each_entry(cur_id, &bind_list->owners, node) {

		    (addr->sa_family != cur_addr->sa_family))
			continue;

		vnet = cur_id->id.route.addr.dev_addr.net;
		if (cma_any_addr(vnet, addr) || cma_any_addr(vnet, cur_addr))
			return -EADDRNOTAVAIL;

		if (!cma_addr_cmp(addr, cur_addr))

int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr)
{
	struct rdma_id_private *id_priv;
	struct vnet *vnet = id->route.addr.dev_addr.net;
	int ret;

	if (addr->sa_family != AF_INET && addr->sa_family != AF_INET6 &&

		goto err1;

	memcpy(cma_src_addr(id_priv), addr, rdma_addr_size(addr));
	if (!cma_any_addr(vnet, addr)) {
		ret = cma_translate_addr(addr, &id->route.addr.dev_addr);
		if (ret)
			goto err1;

			id_priv->afonly = 1;
#ifdef INET6
		else if (addr->sa_family == AF_INET6) {
			CURVNET_SET_QUIET(vnet);
			id_priv->afonly = V_ip6_v6only;
			CURVNET_RESTORE();
		}

	struct sockaddr_in *sin = (struct sockaddr_in *) addr;
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) addr;

	if (cma_any_addr(dev_addr->net, addr)) {
		memset(mgid, 0, sizeof *mgid);
	} else if ((addr->sa_family == AF_INET6) &&
		   ((be32_to_cpu(sin6->sin6_addr.s6_addr32[0]) & 0xFFF0FFFF) ==

	kfree(mw);
}

static void cma_iboe_set_mgid(struct vnet *vnet, struct sockaddr *addr,
			      union ib_gid *mgid, enum ib_gid_type gid_type)
{
	struct sockaddr_in *sin = (struct sockaddr_in *)addr;
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;

	if (cma_any_addr(vnet, addr)) {
		memset(mgid, 0, sizeof *mgid);
	} else if (addr->sa_family == AF_INET6) {
		memcpy(mgid, &sin6->sin6_addr, sizeof *mgid);


	gid_type = id_priv->cma_dev->default_gid_type[id_priv->id.port_num -
		   rdma_start_port(id_priv->cma_dev->device)];
	cma_iboe_set_mgid(dev_addr->net, addr, &mc->multicast.ib->rec.mgid, gid_type);

	mc->multicast.ib->rec.pkey = cpu_to_be16(0xffff);
	if (id_priv->id.ps == RDMA_PS_UDP)

Return to bug 266054

Lines 284-290 irdma_dealloc_pd(struct ib_pd ibpd, struct ib_udata udata) Link Here

(-)b/sys/dev/irdma/irdma_kcompat.c (-3 / +6 lines)
284	}	284	}
285		285
286	static void	286	static void
287	irdma_fill_ah_info(struct irdma_ah_info *ah_info,	287	irdma_fill_ah_info(struct vnet *vnet,
		288	struct irdma_ah_info *ah_info,
288	const struct ib_gid_attr *sgid_attr,	289	const struct ib_gid_attr *sgid_attr,
289	struct sockaddr sgid_addr, struct sockaddr dgid_addr,	290	struct sockaddr sgid_addr, struct sockaddr dgid_addr,
290	u8 *dmac, u8 net_type)	291	u8 *dmac, u8 net_type)
Lines 295-301 irdma_fill_ah_info(struct irdma_ah_info *ah_info, Link Here
295	ntohl(((struct sockaddr_in *)dgid_addr)->sin_addr.s_addr);	296	ntohl(((struct sockaddr_in *)dgid_addr)->sin_addr.s_addr);
296	ah_info->src_ip_addr[0] =	297	ah_info->src_ip_addr[0] =
297	ntohl(((struct sockaddr_in *)sgid_addr)->sin_addr.s_addr);	298	ntohl(((struct sockaddr_in *)sgid_addr)->sin_addr.s_addr);
298	ah_info->do_lpbk = irdma_ipv4_is_lpb(ah_info->src_ip_addr[0],	299	ah_info->do_lpbk = irdma_ipv4_is_lpb(vnet,
		300	ah_info->src_ip_addr[0],
299	ah_info->dest_ip_addr[0]);	301	ah_info->dest_ip_addr[0]);
300	if (ipv4_is_multicast(((struct sockaddr_in *)dgid_addr)->sin_addr.s_addr)) {	302	if (ipv4_is_multicast(((struct sockaddr_in *)dgid_addr)->sin_addr.s_addr)) {
301	irdma_mcast_mac_v4(ah_info->dest_ip_addr, dmac);	303	irdma_mcast_mac_v4(ah_info->dest_ip_addr, dmac);
Lines 440-446 irdma_create_ah(struct ib_ah *ib_ah, Link Here
440		442
441	ether_addr_copy(dmac, attr->dmac);	443	ether_addr_copy(dmac, attr->dmac);
442		444
443	irdma_fill_ah_info(ah_info, &sgid_attr, &sgid_addr.saddr, &dgid_addr.saddr,	445	irdma_fill_ah_info(iwdev->netdev->if_vnet,
		446	ah_info, &sgid_attr, &sgid_addr.saddr, &dgid_addr.saddr,
444	dmac, ah->av.net_type);	447	dmac, ah->av.net_type);
445		448
446	err = irdma_create_ah_vlan_tag(iwdev, ah_info, &sgid_attr, dmac);	449	err = irdma_create_ah_vlan_tag(iwdev, ah_info, &sgid_attr, dmac);

Lines 1070-1078 static inline int cma_loopback_addr(struct sockaddr *addr) Link Here

(-)b/sys/ofed/drivers/infiniband/core/ib_cma.c (-23 / +38 lines)
1070	}	1070	}
1071	}	1071	}
1072		1072
1073	static inline int cma_any_addr(struct sockaddr *addr)	1073	static inline bool cma_any_addr(struct vnet vnet, struct sockaddr addr)
1074	{	1074	{
1075	return cma_zero_addr(addr) \|\| cma_loopback_addr(addr);	1075	bool ret;
		1076
		1077	CURVNET_SET_QUIET(vnet);
		1078	ret = cma_zero_addr(addr) \|\| cma_loopback_addr(addr);
		1079	CURVNET_RESTORE();
		1080
		1081	return (ret);
1076	}	1082	}
1077		1083
1078	static int cma_addr_cmp(struct sockaddr src, struct sockaddr dst)	1084	static int cma_addr_cmp(struct sockaddr src, struct sockaddr dst)
Lines 1565-1577 static bool sdp_match_private_data(struct rdma_id_private *id_priv, Link Here
1565	{	1571	{
1566	__be32 ip4_addr;	1572	__be32 ip4_addr;
1567	struct in6_addr ip6_addr;	1573	struct in6_addr ip6_addr;
		1574	struct vnet *vnet = id_priv->id.route.addr.dev_addr.net;
1568		1575
1569	switch (addr->sa_family) {	1576	switch (addr->sa_family) {
1570	case AF_INET:	1577	case AF_INET:
1571	ip4_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;	1578	ip4_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
1572	if (sdp_get_ip_ver(hdr) != 4)	1579	if (sdp_get_ip_ver(hdr) != 4)
1573	return false;	1580	return false;
1574	if (!cma_any_addr(addr) &&	1581	if (!cma_any_addr(vnet, addr) &&
1575	hdr->dst_addr.ip4.addr != ip4_addr)	1582	hdr->dst_addr.ip4.addr != ip4_addr)
1576	return false;	1583	return false;
1577	break;	1584	break;
Lines 1580-1586 static bool sdp_match_private_data(struct rdma_id_private *id_priv, Link Here
1580	if (sdp_get_ip_ver(hdr) != 6)	1587	if (sdp_get_ip_ver(hdr) != 6)
1581	return false;	1588	return false;
1582	cma_ip6_clear_scope_id(&ip6_addr);	1589	cma_ip6_clear_scope_id(&ip6_addr);
1583	if (!cma_any_addr(addr) &&	1590	if (!cma_any_addr(vnet, addr) &&
1584	memcmp(&hdr->dst_addr.ip6, &ip6_addr, sizeof(ip6_addr)))	1591	memcmp(&hdr->dst_addr.ip6, &ip6_addr, sizeof(ip6_addr)))
1585	return false;	1592	return false;
1586	break;	1593	break;
Lines 1598-1607 static bool cma_match_private_data(struct rdma_id_private *id_priv, Link Here
1598	{	1605	{
1599	const struct cma_hdr *hdr = vhdr;	1606	const struct cma_hdr *hdr = vhdr;
1600	struct sockaddr *addr = cma_src_addr(id_priv);	1607	struct sockaddr *addr = cma_src_addr(id_priv);
		1608	struct vnet *vnet = id_priv->id.route.addr.dev_addr.net;
1601	__be32 ip4_addr;	1609	__be32 ip4_addr;
1602	struct in6_addr ip6_addr;	1610	struct in6_addr ip6_addr;
1603		1611
1604	if (cma_any_addr(addr) && !id_priv->afonly)	1612	if (cma_any_addr(vnet, addr) && !id_priv->afonly)
1605	return true;	1613	return true;
1606		1614
1607	if (id_priv->id.ps == RDMA_PS_SDP)	1615	if (id_priv->id.ps == RDMA_PS_SDP)
Lines 1612-1618 static bool cma_match_private_data(struct rdma_id_private *id_priv, Link Here
1612	ip4_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;	1620	ip4_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
1613	if (cma_get_ip_ver(hdr) != 4)	1621	if (cma_get_ip_ver(hdr) != 4)
1614	return false;	1622	return false;
1615	if (!cma_any_addr(addr) &&	1623	if (!cma_any_addr(vnet, addr) &&
1616	hdr->dst_addr.ip4.addr != ip4_addr)	1624	hdr->dst_addr.ip4.addr != ip4_addr)
1617	return false;	1625	return false;
1618	break;	1626	break;
Lines 1621-1627 static bool cma_match_private_data(struct rdma_id_private *id_priv, Link Here
1621	if (cma_get_ip_ver(hdr) != 6)	1629	if (cma_get_ip_ver(hdr) != 6)
1622	return false;	1630	return false;
1623	cma_ip6_clear_scope_id(&ip6_addr);	1631	cma_ip6_clear_scope_id(&ip6_addr);
1624	if (!cma_any_addr(addr) &&	1632	if (!cma_any_addr(vnet, addr) &&
1625	memcmp(&hdr->dst_addr.ip6, &ip6_addr, sizeof(ip6_addr)))	1633	memcmp(&hdr->dst_addr.ip6, &ip6_addr, sizeof(ip6_addr)))
1626	return false;	1634	return false;
1627	break;	1635	break;
Lines 1793-1798 static void cma_cancel_listens(struct rdma_id_private *id_priv) Link Here
1793	static void cma_cancel_operation(struct rdma_id_private *id_priv,	1801	static void cma_cancel_operation(struct rdma_id_private *id_priv,
1794	enum rdma_cm_state state)	1802	enum rdma_cm_state state)
1795	{	1803	{
		1804	struct vnet *vnet = id_priv->id.route.addr.dev_addr.net;
		1805
1796	switch (state) {	1806	switch (state) {
1797	case RDMA_CM_ADDR_QUERY:	1807	case RDMA_CM_ADDR_QUERY:
1798	rdma_addr_cancel(&id_priv->id.route.addr.dev_addr);	1808	rdma_addr_cancel(&id_priv->id.route.addr.dev_addr);
Lines 1801-1807 static void cma_cancel_operation(struct rdma_id_private *id_priv, Link Here
1801	cma_cancel_route(id_priv);	1811	cma_cancel_route(id_priv);
1802	break;	1812	break;
1803	case RDMA_CM_LISTEN:	1813	case RDMA_CM_LISTEN:
1804	if (cma_any_addr(cma_src_addr(id_priv)) && !id_priv->cma_dev)	1814	if (cma_any_addr(vnet, cma_src_addr(id_priv)) && !id_priv->cma_dev)
1805	cma_cancel_listens(id_priv);	1815	cma_cancel_listens(id_priv);
1806	break;	1816	break;
1807	default:	1817	default:
Lines 2039-2047 static struct rdma_id_private cma_new_conn_id(struct rdma_cm_id listen_id, Link Here
2039	const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;	2049	const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;
2040	const __be64 service_id =	2050	const __be64 service_id =
2041	ib_event->param.req_rcvd.primary_path->service_id;	2051	ib_event->param.req_rcvd.primary_path->service_id;
		2052	struct vnet *vnet = listen_id->route.addr.dev_addr.net;
2042	int ret;	2053	int ret;
2043		2054
2044	id = rdma_create_id(listen_id->route.addr.dev_addr.net,	2055	id = rdma_create_id(vnet,
2045	listen_id->event_handler, listen_id->context,	2056	listen_id->event_handler, listen_id->context,
2046	listen_id->ps, ib_event->param.req_rcvd.qp_type);	2057	listen_id->ps, ib_event->param.req_rcvd.qp_type);
2047	if (IS_ERR(id))	2058	if (IS_ERR(id))
Lines 2070-2080 static struct rdma_id_private cma_new_conn_id(struct rdma_cm_id listen_id, Link Here
2070	goto err;	2081	goto err;
2071	} else {	2082	} else {
2072	if (!cma_protocol_roce(listen_id) &&	2083	if (!cma_protocol_roce(listen_id) &&
2073	cma_any_addr(cma_src_addr(id_priv))) {	2084	cma_any_addr(vnet, cma_src_addr(id_priv))) {
2074	rt->addr.dev_addr.dev_type = ARPHRD_INFINIBAND;	2085	rt->addr.dev_addr.dev_type = ARPHRD_INFINIBAND;
2075	rdma_addr_set_sgid(&rt->addr.dev_addr, &rt->path_rec[0].sgid);	2086	rdma_addr_set_sgid(&rt->addr.dev_addr, &rt->path_rec[0].sgid);
2076	ib_addr_set_pkey(&rt->addr.dev_addr, be16_to_cpu(rt->path_rec[0].pkey));	2087	ib_addr_set_pkey(&rt->addr.dev_addr, be16_to_cpu(rt->path_rec[0].pkey));
2077	} else if (!cma_any_addr(cma_src_addr(id_priv))) {	2088	} else if (!cma_any_addr(vnet, cma_src_addr(id_priv))) {
2078	ret = cma_translate_addr(cma_src_addr(id_priv), &rt->addr.dev_addr);	2089	ret = cma_translate_addr(cma_src_addr(id_priv), &rt->addr.dev_addr);
2079	if (ret)	2090	if (ret)
2080	goto err;	2091	goto err;
Lines 2097-2106 static struct rdma_id_private cma_new_udp_id(struct rdma_cm_id listen_id, Link Here
2097	struct rdma_id_private *id_priv;	2108	struct rdma_id_private *id_priv;
2098	struct rdma_cm_id *id;	2109	struct rdma_cm_id *id;
2099	const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;	2110	const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;
2100	struct vnet *net = listen_id->route.addr.dev_addr.net;	2111	struct vnet *vnet = listen_id->route.addr.dev_addr.net;
2101	int ret;	2112	int ret;
2102		2113
2103	id = rdma_create_id(net, listen_id->event_handler, listen_id->context,	2114	id = rdma_create_id(vnet, listen_id->event_handler, listen_id->context,
2104	listen_id->ps, IB_QPT_UD);	2115	listen_id->ps, IB_QPT_UD);
2105	if (IS_ERR(id))	2116	if (IS_ERR(id))
2106	return NULL;	2117	return NULL;
Lines 2117-2123 static struct rdma_id_private cma_new_udp_id(struct rdma_cm_id listen_id, Link Here
2117	if (ret)	2128	if (ret)
2118	goto err;	2129	goto err;
2119	} else {	2130	} else {
2120	if (!cma_any_addr(cma_src_addr(id_priv))) {	2131	if (!cma_any_addr(vnet, cma_src_addr(id_priv))) {
2121	ret = cma_translate_addr(cma_src_addr(id_priv),	2132	ret = cma_translate_addr(cma_src_addr(id_priv),
2122	&id->route.addr.dev_addr);	2133	&id->route.addr.dev_addr);
2123	if (ret)	2134	if (ret)
Lines 3053-3058 int rdma_resolve_addr(struct rdma_cm_id id, struct sockaddr src_addr, Link Here
3053	struct sockaddr *dst_addr, int timeout_ms)	3064	struct sockaddr *dst_addr, int timeout_ms)
3054	{	3065	{
3055	struct rdma_id_private *id_priv;	3066	struct rdma_id_private *id_priv;
		3067	struct vnet *vnet = id->route.addr.dev_addr.net;
3056	int ret;	3068	int ret;
3057		3069
3058	id_priv = container_of(id, struct rdma_id_private, id);	3070	id_priv = container_of(id, struct rdma_id_private, id);
Lines 3070-3076 int rdma_resolve_addr(struct rdma_cm_id id, struct sockaddr src_addr, Link Here
3070		3082
3071	atomic_inc(&id_priv->refcount);	3083	atomic_inc(&id_priv->refcount);
3072	memcpy(cma_dst_addr(id_priv), dst_addr, rdma_addr_size(dst_addr));	3084	memcpy(cma_dst_addr(id_priv), dst_addr, rdma_addr_size(dst_addr));
3073	if (cma_any_addr(dst_addr)) {	3085	if (cma_any_addr(vnet, dst_addr)) {
3074	ret = cma_resolve_loopback(id_priv);	3086	ret = cma_resolve_loopback(id_priv);
3075	} else {	3087	} else {
3076	if (dst_addr->sa_family == AF_IB) {	3088	if (dst_addr->sa_family == AF_IB) {
Lines 3235-3240 static int cma_check_port(struct rdma_bind_list *bind_list, Link Here
3235	{	3247	{
3236	struct rdma_id_private *cur_id;	3248	struct rdma_id_private *cur_id;
3237	struct sockaddr addr, cur_addr;	3249	struct sockaddr addr, cur_addr;
		3250	struct vnet *vnet;
3238		3251
3239	addr = cma_src_addr(id_priv);	3252	addr = cma_src_addr(id_priv);
3240	hlist_for_each_entry(cur_id, &bind_list->owners, node) {	3253	hlist_for_each_entry(cur_id, &bind_list->owners, node) {
Lines 3250-3256 static int cma_check_port(struct rdma_bind_list *bind_list, Link Here
3250	(addr->sa_family != cur_addr->sa_family))	3263	(addr->sa_family != cur_addr->sa_family))
3251	continue;	3264	continue;
3252		3265
3253	if (cma_any_addr(addr) \|\| cma_any_addr(cur_addr))	3266	vnet = cur_id->id.route.addr.dev_addr.net;
		3267	if (cma_any_addr(vnet, addr) \|\| cma_any_addr(vnet, cur_addr))
3254	return -EADDRNOTAVAIL;	3268	return -EADDRNOTAVAIL;
3255		3269
3256	if (!cma_addr_cmp(addr, cur_addr))	3270	if (!cma_addr_cmp(addr, cur_addr))
Lines 3441-3446 EXPORT_SYMBOL(rdma_listen); Link Here
3441	int rdma_bind_addr(struct rdma_cm_id id, struct sockaddr addr)	3455	int rdma_bind_addr(struct rdma_cm_id id, struct sockaddr addr)
3442	{	3456	{
3443	struct rdma_id_private *id_priv;	3457	struct rdma_id_private *id_priv;
		3458	struct vnet *vnet = id->route.addr.dev_addr.net;
3444	int ret;	3459	int ret;
3445		3460
3446	if (addr->sa_family != AF_INET && addr->sa_family != AF_INET6 &&	3461	if (addr->sa_family != AF_INET && addr->sa_family != AF_INET6 &&
Lines 3456-3462 int rdma_bind_addr(struct rdma_cm_id id, struct sockaddr addr) Link Here
3456	goto err1;	3471	goto err1;
3457		3472
3458	memcpy(cma_src_addr(id_priv), addr, rdma_addr_size(addr));	3473	memcpy(cma_src_addr(id_priv), addr, rdma_addr_size(addr));
3459	if (!cma_any_addr(addr)) {	3474	if (!cma_any_addr(vnet, addr)) {
3460	ret = cma_translate_addr(addr, &id->route.addr.dev_addr);	3475	ret = cma_translate_addr(addr, &id->route.addr.dev_addr);
3461	if (ret)	3476	if (ret)
3462	goto err1;	3477	goto err1;
Lines 3471-3477 int rdma_bind_addr(struct rdma_cm_id id, struct sockaddr addr) Link Here
3471	id_priv->afonly = 1;	3486	id_priv->afonly = 1;
3472	#ifdef INET6	3487	#ifdef INET6
3473	else if (addr->sa_family == AF_INET6) {	3488	else if (addr->sa_family == AF_INET6) {
3474	CURVNET_SET_QUIET(id_priv->id.route.addr.dev_addr.net);	3489	CURVNET_SET_QUIET(vnet);
3475	id_priv->afonly = V_ip6_v6only;	3490	id_priv->afonly = V_ip6_v6only;
3476	CURVNET_RESTORE();	3491	CURVNET_RESTORE();
3477	}	3492	}
Lines 4099-4105 static void cma_set_mgid(struct rdma_id_private *id_priv, Link Here
4099	struct sockaddr_in sin = (struct sockaddr_in ) addr;	4114	struct sockaddr_in sin = (struct sockaddr_in ) addr;
4100	struct sockaddr_in6 sin6 = (struct sockaddr_in6 ) addr;	4115	struct sockaddr_in6 sin6 = (struct sockaddr_in6 ) addr;
4101		4116
4102	if (cma_any_addr(addr)) {	4117	if (cma_any_addr(dev_addr->net, addr)) {
4103	memset(mgid, 0, sizeof *mgid);	4118	memset(mgid, 0, sizeof *mgid);
4104	} else if ((addr->sa_family == AF_INET6) &&	4119	} else if ((addr->sa_family == AF_INET6) &&
4105	((be32_to_cpu(sin6->sin6_addr.s6_addr32[0]) & 0xFFF0FFFF) ==	4120	((be32_to_cpu(sin6->sin6_addr.s6_addr32[0]) & 0xFFF0FFFF) ==
Lines 4247-4259 static void iboe_mcast_work_handler(struct work_struct *work) Link Here
4247	kfree(mw);	4262	kfree(mw);
4248	}	4263	}
4249		4264
4250	static void cma_iboe_set_mgid(struct sockaddr addr, union ib_gid mgid,	4265	static void cma_iboe_set_mgid(struct vnet vnet, struct sockaddr addr,
4251	enum ib_gid_type gid_type)	4266	union ib_gid *mgid, enum ib_gid_type gid_type)
4252	{	4267	{
4253	struct sockaddr_in sin = (struct sockaddr_in )addr;	4268	struct sockaddr_in sin = (struct sockaddr_in )addr;
4254	struct sockaddr_in6 sin6 = (struct sockaddr_in6 )addr;	4269	struct sockaddr_in6 sin6 = (struct sockaddr_in6 )addr;
4255		4270
4256	if (cma_any_addr(addr)) {	4271	if (cma_any_addr(vnet, addr)) {
4257	memset(mgid, 0, sizeof *mgid);	4272	memset(mgid, 0, sizeof *mgid);
4258	} else if (addr->sa_family == AF_INET6) {	4273	} else if (addr->sa_family == AF_INET6) {
4259	memcpy(mgid, &sin6->sin6_addr, sizeof *mgid);	4274	memcpy(mgid, &sin6->sin6_addr, sizeof *mgid);
Lines 4304-4310 static int cma_iboe_join_multicast(struct rdma_id_private *id_priv, Link Here
4304		4319
4305	gid_type = id_priv->cma_dev->default_gid_type[id_priv->id.port_num -	4320	gid_type = id_priv->cma_dev->default_gid_type[id_priv->id.port_num -
4306	rdma_start_port(id_priv->cma_dev->device)];	4321	rdma_start_port(id_priv->cma_dev->device)];
4307	cma_iboe_set_mgid(addr, &mc->multicast.ib->rec.mgid, gid_type);	4322	cma_iboe_set_mgid(dev_addr->net, addr, &mc->multicast.ib->rec.mgid, gid_type);
4308		4323
4309	mc->multicast.ib->rec.pkey = cpu_to_be16(0xffff);	4324	mc->multicast.ib->rec.pkey = cpu_to_be16(0xffff);
4310	if (id_priv->id.ps == RDMA_PS_UDP)	4325	if (id_priv->id.ps == RDMA_PS_UDP)