[deliverable/linux.git] / drivers / infiniband / core / addr.c

/*
 * Copyright (c) 2005 Voltaire Inc.  All rights reserved.
 * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
 * Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved.
 * Copyright (c) 2005 Intel Corporation.  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
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/mutex.h>
#include <linux/inetdevice.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/module.h>
#include <net/arp.h>
#include <net/neighbour.h>
#include <net/route.h>
#include <net/netevent.h>
#include <net/addrconf.h>
#include <net/ip6_route.h>
#include <rdma/ib_addr.h>
#include <rdma/ib.h>

MODULE_AUTHOR("Sean Hefty");
MODULE_DESCRIPTION("IB Address Translation");
MODULE_LICENSE("Dual BSD/GPL");

struct addr_req {
	struct list_head list;
	struct sockaddr_storage src_addr;
	struct sockaddr_storage dst_addr;
	struct rdma_dev_addr *addr;
	struct rdma_addr_client *client;
	void *context;
	void (*callback)(int status, struct sockaddr *src_addr,
			 struct rdma_dev_addr *addr, void *context);
	unsigned long timeout;
	int status;
};

static void process_req(struct work_struct *work);

static DEFINE_MUTEX(lock);
static LIST_HEAD(req_list);
static DECLARE_DELAYED_WORK(work, process_req);
static struct workqueue_struct *addr_wq;

int rdma_addr_size(struct sockaddr *addr)
{
	switch (addr->sa_family) {
	case AF_INET:
		return sizeof(struct sockaddr_in);
	case AF_INET6:
		return sizeof(struct sockaddr_in6);
	case AF_IB:
		return sizeof(struct sockaddr_ib);
	default:
		return 0;
	}
}
EXPORT_SYMBOL(rdma_addr_size);

static struct rdma_addr_client self;

void rdma_addr_register_client(struct rdma_addr_client *client)
{
	atomic_set(&client->refcount, 1);
	init_completion(&client->comp);
}
EXPORT_SYMBOL(rdma_addr_register_client);

static inline void put_client(struct rdma_addr_client *client)
{
	if (atomic_dec_and_test(&client->refcount))
		complete(&client->comp);
}

void rdma_addr_unregister_client(struct rdma_addr_client *client)
{
	put_client(client);
	wait_for_completion(&client->comp);
}
EXPORT_SYMBOL(rdma_addr_unregister_client);

int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev,
		     const unsigned char *dst_dev_addr)
{
	dev_addr->dev_type = dev->type;
	memcpy(dev_addr->src_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
	memcpy(dev_addr->broadcast, dev->broadcast, MAX_ADDR_LEN);
	if (dst_dev_addr)
		memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
	dev_addr->bound_dev_if = dev->ifindex;
	return 0;
}
EXPORT_SYMBOL(rdma_copy_addr);

int rdma_translate_ip(const struct sockaddr *addr,
		      struct rdma_dev_addr *dev_addr,
		      u16 *vlan_id)
{
	struct net_device *dev;
	int ret = -EADDRNOTAVAIL;

	if (dev_addr->bound_dev_if) {
		dev = dev_get_by_index(dev_addr->net, dev_addr->bound_dev_if);
		if (!dev)
			return -ENODEV;
		ret = rdma_copy_addr(dev_addr, dev, NULL);
		dev_put(dev);
		return ret;
	}

	switch (addr->sa_family) {
	case AF_INET:
		dev = ip_dev_find(dev_addr->net,
			((const struct sockaddr_in *)addr)->sin_addr.s_addr);

		if (!dev)
			return ret;

		ret = rdma_copy_addr(dev_addr, dev, NULL);
		if (vlan_id)
			*vlan_id = rdma_vlan_dev_vlan_id(dev);
		dev_put(dev);
		break;
#if IS_ENABLED(CONFIG_IPV6)
	case AF_INET6:
		rcu_read_lock();
		for_each_netdev_rcu(dev_addr->net, dev) {
			if (ipv6_chk_addr(dev_addr->net,
					  &((const struct sockaddr_in6 *)addr)->sin6_addr,
					  dev, 1)) {
				ret = rdma_copy_addr(dev_addr, dev, NULL);
				if (vlan_id)
					*vlan_id = rdma_vlan_dev_vlan_id(dev);
				break;
			}
		}
		rcu_read_unlock();
		break;
#endif
	}
	return ret;
}
EXPORT_SYMBOL(rdma_translate_ip);

static void set_timeout(unsigned long time)
{
	unsigned long delay;

	delay = time - jiffies;
	if ((long)delay < 0)
		delay = 0;

	mod_delayed_work(addr_wq, &work, delay);
}

static void queue_req(struct addr_req *req)
{
	struct addr_req *temp_req;

	mutex_lock(&lock);
	list_for_each_entry_reverse(temp_req, &req_list, list) {
		if (time_after_eq(req->timeout, temp_req->timeout))
			break;
	}

	list_add(&req->list, &temp_req->list);

	if (req_list.next == &req->list)
		set_timeout(req->timeout);
	mutex_unlock(&lock);
}

static int dst_fetch_ha(struct dst_entry *dst, struct rdma_dev_addr *dev_addr,
			const void *daddr)
{
	struct neighbour *n;
	int ret;

	n = dst_neigh_lookup(dst, daddr);

	rcu_read_lock();
	if (!n || !(n->nud_state & NUD_VALID)) {
		if (n)
			neigh_event_send(n, NULL);
		ret = -ENODATA;
	} else {
		ret = rdma_copy_addr(dev_addr, dst->dev, n->ha);
	}
	rcu_read_unlock();

	if (n)
		neigh_release(n);

	return ret;
}

static int addr4_resolve(struct sockaddr_in *src_in,
			 const struct sockaddr_in *dst_in,
			 struct rdma_dev_addr *addr,
			 struct rtable **prt)
{
	__be32 src_ip = src_in->sin_addr.s_addr;
	__be32 dst_ip = dst_in->sin_addr.s_addr;
	struct rtable *rt;
	struct flowi4 fl4;
	int ret;

	memset(&fl4, 0, sizeof(fl4));
	fl4.daddr = dst_ip;
	fl4.saddr = src_ip;
	fl4.flowi4_oif = addr->bound_dev_if;
	rt = ip_route_output_key(addr->net, &fl4);
	if (IS_ERR(rt)) {
		ret = PTR_ERR(rt);
		goto out;
	}
	src_in->sin_family = AF_INET;
	src_in->sin_addr.s_addr = fl4.saddr;

	/* If there's a gateway, we're definitely in RoCE v2 (as RoCE v1 isn't
	 * routable) and we could set the network type accordingly.
	 */
	if (rt->rt_uses_gateway)
		addr->network = RDMA_NETWORK_IPV4;

	addr->hoplimit = ip4_dst_hoplimit(&rt->dst);

	*prt = rt;
	return 0;
out:
	return ret;
}

#if IS_ENABLED(CONFIG_IPV6)
static int addr6_resolve(struct sockaddr_in6 *src_in,
			 const struct sockaddr_in6 *dst_in,
			 struct rdma_dev_addr *addr,
			 struct dst_entry **pdst)
{
	struct flowi6 fl6;
	struct dst_entry *dst;
	struct rt6_info *rt;
	int ret;

	memset(&fl6, 0, sizeof fl6);
	fl6.daddr = dst_in->sin6_addr;
	fl6.saddr = src_in->sin6_addr;
	fl6.flowi6_oif = addr->bound_dev_if;

	dst = ip6_route_output(addr->net, NULL, &fl6);
	if ((ret = dst->error))
		goto put;

	rt = (struct rt6_info *)dst;
	if (ipv6_addr_any(&fl6.saddr)) {
		ret = ipv6_dev_get_saddr(addr->net, ip6_dst_idev(dst)->dev,
					 &fl6.daddr, 0, &fl6.saddr);
		if (ret)
			goto put;

		src_in->sin6_family = AF_INET6;
		src_in->sin6_addr = fl6.saddr;
	}

	/* If there's a gateway, we're definitely in RoCE v2 (as RoCE v1 isn't
	 * routable) and we could set the network type accordingly.
	 */
	if (rt->rt6i_flags & RTF_GATEWAY)
		addr->network = RDMA_NETWORK_IPV6;

	addr->hoplimit = ip6_dst_hoplimit(dst);

	*pdst = dst;
	return 0;
put:
	dst_release(dst);
	return ret;
}
#else
static int addr6_resolve(struct sockaddr_in6 *src_in,
			 const struct sockaddr_in6 *dst_in,
			 struct rdma_dev_addr *addr,
			 struct dst_entry **pdst)
{
	return -EADDRNOTAVAIL;
}
#endif

static int addr_resolve_neigh(struct dst_entry *dst,
			      const struct sockaddr *dst_in,
			      struct rdma_dev_addr *addr)
{
	if (dst->dev->flags & IFF_LOOPBACK) {
		int ret;

		ret = rdma_translate_ip(dst_in, addr, NULL);
		if (!ret)
			memcpy(addr->dst_dev_addr, addr->src_dev_addr,
			       MAX_ADDR_LEN);

		return ret;
	}

	/* If the device doesn't do ARP internally */
	if (!(dst->dev->flags & IFF_NOARP)) {
		const struct sockaddr_in *dst_in4 =
			(const struct sockaddr_in *)dst_in;
		const struct sockaddr_in6 *dst_in6 =
			(const struct sockaddr_in6 *)dst_in;

		return dst_fetch_ha(dst, addr,
				    dst_in->sa_family == AF_INET ?
				    (const void *)&dst_in4->sin_addr.s_addr :
				    (const void *)&dst_in6->sin6_addr);
	}

	return rdma_copy_addr(addr, dst->dev, NULL);
}

static int addr_resolve(struct sockaddr *src_in,
			const struct sockaddr *dst_in,
			struct rdma_dev_addr *addr,
			bool resolve_neigh)
{
	struct net_device *ndev;
	struct dst_entry *dst;
	int ret;

	if (src_in->sa_family == AF_INET) {
		struct rtable *rt = NULL;
		const struct sockaddr_in *dst_in4 =
			(const struct sockaddr_in *)dst_in;

		ret = addr4_resolve((struct sockaddr_in *)src_in,
				    dst_in4, addr, &rt);
		if (ret)
			return ret;

		if (resolve_neigh)
			ret = addr_resolve_neigh(&rt->dst, dst_in, addr);

		ndev = rt->dst.dev;
		dev_hold(ndev);

		ip_rt_put(rt);
	} else {
		const struct sockaddr_in6 *dst_in6 =
			(const struct sockaddr_in6 *)dst_in;

		ret = addr6_resolve((struct sockaddr_in6 *)src_in,
				    dst_in6, addr,
				    &dst);
		if (ret)
			return ret;

		if (resolve_neigh)
			ret = addr_resolve_neigh(dst, dst_in, addr);

		ndev = dst->dev;
		dev_hold(ndev);

		dst_release(dst);
	}

	addr->bound_dev_if = ndev->ifindex;
	addr->net = dev_net(ndev);
	dev_put(ndev);

	return ret;
}

static void process_req(struct work_struct *work)
{
	struct addr_req *req, *temp_req;
	struct sockaddr *src_in, *dst_in;
	struct list_head done_list;

	INIT_LIST_HEAD(&done_list);

	mutex_lock(&lock);
	list_for_each_entry_safe(req, temp_req, &req_list, list) {
		if (req->status == -ENODATA) {
			src_in = (struct sockaddr *) &req->src_addr;
			dst_in = (struct sockaddr *) &req->dst_addr;
			req->status = addr_resolve(src_in, dst_in, req->addr,
						   true);
			if (req->status && time_after_eq(jiffies, req->timeout))
				req->status = -ETIMEDOUT;
			else if (req->status == -ENODATA)
				continue;
		}
		list_move_tail(&req->list, &done_list);
	}

	if (!list_empty(&req_list)) {
		req = list_entry(req_list.next, struct addr_req, list);
		set_timeout(req->timeout);
	}
	mutex_unlock(&lock);

	list_for_each_entry_safe(req, temp_req, &done_list, list) {
		list_del(&req->list);
		req->callback(req->status, (struct sockaddr *) &req->src_addr,
			req->addr, req->context);
		put_client(req->client);
		kfree(req);
	}
}

int rdma_resolve_ip(struct rdma_addr_client *client,
		    struct sockaddr *src_addr, struct sockaddr *dst_addr,
		    struct rdma_dev_addr *addr, int timeout_ms,
		    void (*callback)(int status, struct sockaddr *src_addr,
				     struct rdma_dev_addr *addr, void *context),
		    void *context)
{
	struct sockaddr *src_in, *dst_in;
	struct addr_req *req;
	int ret = 0;

	req = kzalloc(sizeof *req, GFP_KERNEL);
	if (!req)
		return -ENOMEM;

	src_in = (struct sockaddr *) &req->src_addr;
	dst_in = (struct sockaddr *) &req->dst_addr;

	if (src_addr) {
		if (src_addr->sa_family != dst_addr->sa_family) {
			ret = -EINVAL;
			goto err;
		}

		memcpy(src_in, src_addr, rdma_addr_size(src_addr));
	} else {
		src_in->sa_family = dst_addr->sa_family;
	}

	memcpy(dst_in, dst_addr, rdma_addr_size(dst_addr));
	req->addr = addr;
	req->callback = callback;
	req->context = context;
	req->client = client;
	atomic_inc(&client->refcount);

	req->status = addr_resolve(src_in, dst_in, addr, true);
	switch (req->status) {
	case 0:
		req->timeout = jiffies;
		queue_req(req);
		break;
	case -ENODATA:
		req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
		queue_req(req);
		break;
	default:
		ret = req->status;
		atomic_dec(&client->refcount);
		goto err;
	}
	return ret;
err:
	kfree(req);
	return ret;
}
EXPORT_SYMBOL(rdma_resolve_ip);

int rdma_resolve_ip_route(struct sockaddr *src_addr,
			  const struct sockaddr *dst_addr,
			  struct rdma_dev_addr *addr)
{
	struct sockaddr_storage ssrc_addr = {};
	struct sockaddr *src_in = (struct sockaddr *)&ssrc_addr;

	if (src_addr) {
		if (src_addr->sa_family != dst_addr->sa_family)
			return -EINVAL;

		memcpy(src_in, src_addr, rdma_addr_size(src_addr));
	} else {
		src_in->sa_family = dst_addr->sa_family;
	}

	return addr_resolve(src_in, dst_addr, addr, false);
}
EXPORT_SYMBOL(rdma_resolve_ip_route);

void rdma_addr_cancel(struct rdma_dev_addr *addr)
{
	struct addr_req *req, *temp_req;

	mutex_lock(&lock);
	list_for_each_entry_safe(req, temp_req, &req_list, list) {
		if (req->addr == addr) {
			req->status = -ECANCELED;
			req->timeout = jiffies;
			list_move(&req->list, &req_list);
			set_timeout(req->timeout);
			break;
		}
	}
	mutex_unlock(&lock);
}
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_l2_eth_by_grh(const union ib_gid *sgid,
				 const union ib_gid *dgid,
				 u8 *dmac, u16 *vlan_id, int *if_index,
				 int *hoplimit)
{
	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;


	rdma_gid2ip(&sgid_addr._sockaddr, sgid);
	rdma_gid2ip(&dgid_addr._sockaddr, dgid);

	memset(&dev_addr, 0, sizeof(dev_addr));
	if (if_index)
		dev_addr.bound_dev_if = *if_index;
	dev_addr.net = &init_net;

	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 (if_index)
		*if_index = dev_addr.bound_dev_if;
	if (vlan_id)
		*vlan_id = rdma_vlan_dev_vlan_id(dev);
	if (hoplimit)
		*hoplimit = dev_addr.hoplimit;
	dev_put(dev);
	return ret;
}
EXPORT_SYMBOL(rdma_addr_find_l2_eth_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;

	rdma_gid2ip(&gid_addr._sockaddr, sgid);

	memset(&dev_addr, 0, sizeof(dev_addr));
	dev_addr.net = &init_net;
	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,
	void *ctx)
{
	if (event == NETEVENT_NEIGH_UPDATE) {
		struct neighbour *neigh = ctx;

		if (neigh->nud_state & NUD_VALID) {
			set_timeout(jiffies);
		}
	}
	return 0;
}

static struct notifier_block nb = {
	.notifier_call = netevent_callback
};

static int __init addr_init(void)
{
	addr_wq = create_singlethread_workqueue("ib_addr");
	if (!addr_wq)
		return -ENOMEM;

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

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

module_init(addr_init);
module_exit(addr_cleanup);
Commit	Line	Data
7025fcd3 SH	1	/*
	2	* Copyright (c) 2005 Voltaire Inc. All rights reserved.
	3	* Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
	4	* Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved.
	5	* Copyright (c) 2005 Intel Corporation. All rights reserved.
	6	*
a9474917 SH	7	* This software is available to you under a choice of one of two
	8	* licenses. You may choose to be licensed under the terms of the GNU
	9	* General Public License (GPL) Version 2, available from the file
	10	* COPYING in the main directory of this source tree, or the
	11	* OpenIB.org BSD license below:
7025fcd3	12	*
a9474917 SH	13	* Redistribution and use in source and binary forms, with or
	14	* without modification, are permitted provided that the following
	15	* conditions are met:
7025fcd3	16	*
a9474917 SH	17	* - Redistributions of source code must retain the above
	18	* copyright notice, this list of conditions and the following
	19	* disclaimer.
7025fcd3	20	*
a9474917 SH	21	* - Redistributions in binary form must reproduce the above
	22	* copyright notice, this list of conditions and the following
	23	* disclaimer in the documentation and/or other materials
	24	* provided with the distribution.
7025fcd3	25	*
a9474917 SH	26	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	27	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	28	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	29	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	30	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	31	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	32	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	33	* SOFTWARE.
7025fcd3 SH	34	*/
	35
	36	#include <linux/mutex.h>
	37	#include <linux/inetdevice.h>
5a0e3ad6	38	#include <linux/slab.h>
7025fcd3	39	#include <linux/workqueue.h>
e4dd23d7	40	#include <linux/module.h>
7025fcd3 SH	41	#include <net/arp.h>
	42	#include <net/neighbour.h>
	43	#include <net/route.h>
e795d092	44	#include <net/netevent.h>
38617c64 AS	45	#include <net/addrconf.h>
38617c64 AS	46	#include <net/ip6_route.h>
7025fcd3	47	#include <rdma/ib_addr.h>
ef560861	48	#include <rdma/ib.h>
7025fcd3 SH	49
	50	MODULE_AUTHOR("Sean Hefty");
	51	MODULE_DESCRIPTION("IB Address Translation");
	52	MODULE_LICENSE("Dual BSD/GPL");
	53
	54	struct addr_req {
	55	struct list_head list;
38617c64 AS	56	struct sockaddr_storage src_addr;
38617c64 AS	57	struct sockaddr_storage dst_addr;
7025fcd3	58	struct rdma_dev_addr *addr;
7a118df3	59	struct rdma_addr_client *client;
7025fcd3 SH	60	void *context;
	61	void (callback)(int status, struct sockaddr src_addr,
	62	struct rdma_dev_addr addr, void context);
	63	unsigned long timeout;
	64	int status;
	65	};
	66
c4028958	67	static void process_req(struct work_struct *work);
7025fcd3 SH	68
	69	static DEFINE_MUTEX(lock);
	70	static LIST_HEAD(req_list);
c4028958	71	static DECLARE_DELAYED_WORK(work, process_req);
7025fcd3 SH	72	static struct workqueue_struct *addr_wq;
7025fcd3 SH	73
ef560861 SH	74	int rdma_addr_size(struct sockaddr *addr)
	75	{
	76	switch (addr->sa_family) {
	77	case AF_INET:
	78	return sizeof(struct sockaddr_in);
	79	case AF_INET6:
	80	return sizeof(struct sockaddr_in6);
	81	case AF_IB:
	82	return sizeof(struct sockaddr_ib);
	83	default:
	84	return 0;
	85	}
	86	}
	87	EXPORT_SYMBOL(rdma_addr_size);
	88
dd5f03be MB	89	static struct rdma_addr_client self;
dd5f03be MB	90
7a118df3 SH	91	void rdma_addr_register_client(struct rdma_addr_client *client)
	92	{
	93	atomic_set(&client->refcount, 1);
	94	init_completion(&client->comp);
	95	}
	96	EXPORT_SYMBOL(rdma_addr_register_client);
	97
	98	static inline void put_client(struct rdma_addr_client *client)
	99	{
	100	if (atomic_dec_and_test(&client->refcount))
	101	complete(&client->comp);
	102	}
	103
	104	void rdma_addr_unregister_client(struct rdma_addr_client *client)
	105	{
	106	put_client(client);
	107	wait_for_completion(&client->comp);
	108	}
	109	EXPORT_SYMBOL(rdma_addr_unregister_client);
	110
07ebafba TT	111	int rdma_copy_addr(struct rdma_dev_addr dev_addr, struct net_device dev,
07ebafba TT	112	const unsigned char *dst_dev_addr)
7025fcd3	113	{
c4315d85	114	dev_addr->dev_type = dev->type;
7025fcd3 SH	115	memcpy(dev_addr->src_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
	116	memcpy(dev_addr->broadcast, dev->broadcast, MAX_ADDR_LEN);
	117	if (dst_dev_addr)
	118	memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
6266ed6e	119	dev_addr->bound_dev_if = dev->ifindex;
7025fcd3 SH	120	return 0;
7025fcd3 SH	121	}
07ebafba	122	EXPORT_SYMBOL(rdma_copy_addr);
7025fcd3	123
20029832 MB	124	int rdma_translate_ip(const struct sockaddr *addr,
20029832 MB	125	struct rdma_dev_addr *dev_addr,
dd5f03be	126	u16 *vlan_id)
7025fcd3 SH	127	{
7025fcd3 SH	128	struct net_device *dev;
38617c64	129	int ret = -EADDRNOTAVAIL;
7025fcd3	130
6266ed6e	131	if (dev_addr->bound_dev_if) {
565edd1d	132	dev = dev_get_by_index(dev_addr->net, dev_addr->bound_dev_if);
6266ed6e SH	133	if (!dev)
	134	return -ENODEV;
	135	ret = rdma_copy_addr(dev_addr, dev, NULL);
	136	dev_put(dev);
	137	return ret;
	138	}
	139
38617c64 AS	140	switch (addr->sa_family) {
38617c64 AS	141	case AF_INET:
565edd1d	142	dev = ip_dev_find(dev_addr->net,
20029832	143	((const struct sockaddr_in *)addr)->sin_addr.s_addr);
38617c64 AS	144
	145	if (!dev)
	146	return ret;
7025fcd3	147
38617c64	148	ret = rdma_copy_addr(dev_addr, dev, NULL);
dd5f03be MB	149	if (vlan_id)
dd5f03be MB	150	*vlan_id = rdma_vlan_dev_vlan_id(dev);
38617c64 AS	151	dev_put(dev);
38617c64 AS	152	break;
d90f9b35	153	#if IS_ENABLED(CONFIG_IPV6)
38617c64	154	case AF_INET6:
22f4fbd9	155	rcu_read_lock();
565edd1d GS	156	for_each_netdev_rcu(dev_addr->net, dev) {
565edd1d GS	157	if (ipv6_chk_addr(dev_addr->net,
20029832	158	&((const struct sockaddr_in6 *)addr)->sin6_addr,
38617c64 AS	159	dev, 1)) {
38617c64 AS	160	ret = rdma_copy_addr(dev_addr, dev, NULL);
dd5f03be MB	161	if (vlan_id)
dd5f03be MB	162	*vlan_id = rdma_vlan_dev_vlan_id(dev);
38617c64 AS	163	break;
	164	}
	165	}
22f4fbd9	166	rcu_read_unlock();
38617c64	167	break;
2c4ab624	168	#endif
38617c64	169	}
7025fcd3 SH	170	return ret;
	171	}
	172	EXPORT_SYMBOL(rdma_translate_ip);
	173
	174	static void set_timeout(unsigned long time)
	175	{
	176	unsigned long delay;
	177
7025fcd3	178	delay = time - jiffies;
346f98b4 OK	179	if ((long)delay < 0)
346f98b4 OK	180	delay = 0;
7025fcd3	181
41f63c53	182	mod_delayed_work(addr_wq, &work, delay);
7025fcd3 SH	183	}
	184
	185	static void queue_req(struct addr_req *req)
	186	{
	187	struct addr_req *temp_req;
	188
	189	mutex_lock(&lock);
	190	list_for_each_entry_reverse(temp_req, &req_list, list) {
f115db48	191	if (time_after_eq(req->timeout, temp_req->timeout))
7025fcd3 SH	192	break;
	193	}
	194
	195	list_add(&req->list, &temp_req->list);
	196
	197	if (req_list.next == &req->list)
	198	set_timeout(req->timeout);
	199	mutex_unlock(&lock);
	200	}
	201
20029832 MB	202	static int dst_fetch_ha(struct dst_entry dst, struct rdma_dev_addr dev_addr,
20029832 MB	203	const void *daddr)
51d45974 DM	204	{
	205	struct neighbour *n;
	206	int ret;
	207
02b61955 DM	208	n = dst_neigh_lookup(dst, daddr);
02b61955 DM	209
51d45974	210	rcu_read_lock();
51d45974 DM	211	if (!n \|\| !(n->nud_state & NUD_VALID)) {
	212	if (n)
	213	neigh_event_send(n, NULL);
	214	ret = -ENODATA;
	215	} else {
02b61955	216	ret = rdma_copy_addr(dev_addr, dst->dev, n->ha);
51d45974 DM	217	}
	218	rcu_read_unlock();
	219
02b61955 DM	220	if (n)
	221	neigh_release(n);
	222
51d45974 DM	223	return ret;
	224	}
	225
923c100e	226	static int addr4_resolve(struct sockaddr_in *src_in,
20029832 MB	227	const struct sockaddr_in *dst_in,
	228	struct rdma_dev_addr *addr,
	229	struct rtable **prt)
7025fcd3	230	{
1b90c137 AV	231	__be32 src_ip = src_in->sin_addr.s_addr;
1b90c137 AV	232	__be32 dst_ip = dst_in->sin_addr.s_addr;
7025fcd3	233	struct rtable *rt;
5fc3590c	234	struct flowi4 fl4;
7025fcd3 SH	235	int ret;
7025fcd3 SH	236
5fc3590c DM	237	memset(&fl4, 0, sizeof(fl4));
	238	fl4.daddr = dst_ip;
	239	fl4.saddr = src_ip;
	240	fl4.flowi4_oif = addr->bound_dev_if;
565edd1d	241	rt = ip_route_output_key(addr->net, &fl4);
b23dd4fe DM	242	if (IS_ERR(rt)) {
b23dd4fe DM	243	ret = PTR_ERR(rt);
7025fcd3	244	goto out;
b23dd4fe	245	}
923c100e	246	src_in->sin_family = AF_INET;
5fc3590c	247	src_in->sin_addr.s_addr = fl4.saddr;
923c100e	248
c865f246 SK	249	/* If there's a gateway, we're definitely in RoCE v2 (as RoCE v1 isn't
	250	* routable) and we could set the network type accordingly.
	251	*/
	252	if (rt->rt_uses_gateway)
	253	addr->network = RDMA_NETWORK_IPV4;
	254
c3efe750 MB	255	addr->hoplimit = ip4_dst_hoplimit(&rt->dst);
c3efe750 MB	256
20029832 MB	257	*prt = rt;
20029832 MB	258	return 0;
7025fcd3 SH	259	out:
	260	return ret;
	261	}
	262
d90f9b35	263	#if IS_ENABLED(CONFIG_IPV6)
d14714df	264	static int addr6_resolve(struct sockaddr_in6 *src_in,
20029832 MB	265	const struct sockaddr_in6 *dst_in,
	266	struct rdma_dev_addr *addr,
	267	struct dst_entry **pdst)
38617c64	268	{
4c9483b2	269	struct flowi6 fl6;
38617c64	270	struct dst_entry *dst;
c865f246	271	struct rt6_info *rt;
d14714df	272	int ret;
38617c64	273
4c9483b2	274	memset(&fl6, 0, sizeof fl6);
4e3fd7a0 AD	275	fl6.daddr = dst_in->sin6_addr;
4e3fd7a0 AD	276	fl6.saddr = src_in->sin6_addr;
4c9483b2	277	fl6.flowi6_oif = addr->bound_dev_if;
38617c64	278
565edd1d	279	dst = ip6_route_output(addr->net, NULL, &fl6);
d14714df SH	280	if ((ret = dst->error))
	281	goto put;
	282
c865f246	283	rt = (struct rt6_info *)dst;
4c9483b2	284	if (ipv6_addr_any(&fl6.saddr)) {
565edd1d	285	ret = ipv6_dev_get_saddr(addr->net, ip6_dst_idev(dst)->dev,
4c9483b2	286	&fl6.daddr, 0, &fl6.saddr);
d14714df SH	287	if (ret)
d14714df SH	288	goto put;
38617c64	289
d14714df	290	src_in->sin6_family = AF_INET6;
4e3fd7a0	291	src_in->sin6_addr = fl6.saddr;
d14714df SH	292	}
d14714df SH	293
c865f246 SK	294	/* If there's a gateway, we're definitely in RoCE v2 (as RoCE v1 isn't
	295	* routable) and we could set the network type accordingly.
	296	*/
	297	if (rt->rt6i_flags & RTF_GATEWAY)
	298	addr->network = RDMA_NETWORK_IPV6;
	299
c3efe750 MB	300	addr->hoplimit = ip6_dst_hoplimit(dst);
c3efe750 MB	301
20029832 MB	302	*pdst = dst;
20029832 MB	303	return 0;
d14714df	304	put:
38617c64 AS	305	dst_release(dst);
	306	return ret;
	307	}
2c4ab624	308	#else
d14714df	309	static int addr6_resolve(struct sockaddr_in6 *src_in,
20029832 MB	310	const struct sockaddr_in6 *dst_in,
	311	struct rdma_dev_addr *addr,
	312	struct dst_entry **pdst)
2c4ab624 RD	313	{
	314	return -EADDRNOTAVAIL;
	315	}
	316	#endif
38617c64	317
20029832 MB	318	static int addr_resolve_neigh(struct dst_entry *dst,
	319	const struct sockaddr *dst_in,
	320	struct rdma_dev_addr *addr)
	321	{
	322	if (dst->dev->flags & IFF_LOOPBACK) {
	323	int ret;
	324
	325	ret = rdma_translate_ip(dst_in, addr, NULL);
	326	if (!ret)
	327	memcpy(addr->dst_dev_addr, addr->src_dev_addr,
	328	MAX_ADDR_LEN);
	329
	330	return ret;
	331	}
	332
	333	/* If the device doesn't do ARP internally */
	334	if (!(dst->dev->flags & IFF_NOARP)) {
	335	const struct sockaddr_in *dst_in4 =
	336	(const struct sockaddr_in *)dst_in;
	337	const struct sockaddr_in6 *dst_in6 =
	338	(const struct sockaddr_in6 *)dst_in;
	339
	340	return dst_fetch_ha(dst, addr,
	341	dst_in->sa_family == AF_INET ?
	342	(const void *)&dst_in4->sin_addr.s_addr :
	343	(const void *)&dst_in6->sin6_addr);
	344	}
	345
	346	return rdma_copy_addr(addr, dst->dev, NULL);
	347	}
	348
923c100e	349	static int addr_resolve(struct sockaddr *src_in,
20029832 MB	350	const struct sockaddr *dst_in,
	351	struct rdma_dev_addr *addr,
	352	bool resolve_neigh)
38617c64	353	{
20029832 MB	354	struct net_device *ndev;
	355	struct dst_entry *dst;
	356	int ret;
	357
38617c64	358	if (src_in->sa_family == AF_INET) {
20029832 MB	359	struct rtable *rt = NULL;
	360	const struct sockaddr_in *dst_in4 =
	361	(const struct sockaddr_in *)dst_in;
	362
	363	ret = addr4_resolve((struct sockaddr_in *)src_in,
	364	dst_in4, addr, &rt);
	365	if (ret)
	366	return ret;
	367
	368	if (resolve_neigh)
	369	ret = addr_resolve_neigh(&rt->dst, dst_in, addr);
	370
	371	ndev = rt->dst.dev;
	372	dev_hold(ndev);
	373
	374	ip_rt_put(rt);
	375	} else {
	376	const struct sockaddr_in6 *dst_in6 =
	377	(const struct sockaddr_in6 *)dst_in;
	378
	379	ret = addr6_resolve((struct sockaddr_in6 *)src_in,
	380	dst_in6, addr,
	381	&dst);
	382	if (ret)
	383	return ret;
	384
	385	if (resolve_neigh)
	386	ret = addr_resolve_neigh(dst, dst_in, addr);
	387
	388	ndev = dst->dev;
	389	dev_hold(ndev);
	390
	391	dst_release(dst);
	392	}
	393
	394	addr->bound_dev_if = ndev->ifindex;
	395	addr->net = dev_net(ndev);
	396	dev_put(ndev);
	397
	398	return ret;
38617c64 AS	399	}
38617c64 AS	400
c4028958	401	static void process_req(struct work_struct *work)
7025fcd3 SH	402	{
7025fcd3 SH	403	struct addr_req req, temp_req;
38617c64	404	struct sockaddr src_in, dst_in;
7025fcd3 SH	405	struct list_head done_list;
	406
	407	INIT_LIST_HEAD(&done_list);
	408
	409	mutex_lock(&lock);
	410	list_for_each_entry_safe(req, temp_req, &req_list, list) {
c78bb844	411	if (req->status == -ENODATA) {
38617c64 AS	412	src_in = (struct sockaddr *) &req->src_addr;
38617c64 AS	413	dst_in = (struct sockaddr *) &req->dst_addr;
20029832 MB	414	req->status = addr_resolve(src_in, dst_in, req->addr,
20029832 MB	415	true);
c78bb844 KK	416	if (req->status && time_after_eq(jiffies, req->timeout))
	417	req->status = -ETIMEDOUT;
	418	else if (req->status == -ENODATA)
	419	continue;
7025fcd3	420	}
04699a1f	421	list_move_tail(&req->list, &done_list);
7025fcd3 SH	422	}
	423
	424	if (!list_empty(&req_list)) {
	425	req = list_entry(req_list.next, struct addr_req, list);
	426	set_timeout(req->timeout);
	427	}
	428	mutex_unlock(&lock);
	429
	430	list_for_each_entry_safe(req, temp_req, &done_list, list) {
	431	list_del(&req->list);
38617c64 AS	432	req->callback(req->status, (struct sockaddr *) &req->src_addr,
38617c64 AS	433	req->addr, req->context);
7a118df3	434	put_client(req->client);
7025fcd3 SH	435	kfree(req);
	436	}
	437	}
	438
7a118df3 SH	439	int rdma_resolve_ip(struct rdma_addr_client *client,
7a118df3 SH	440	struct sockaddr src_addr, struct sockaddr dst_addr,
7025fcd3 SH	441	struct rdma_dev_addr *addr, int timeout_ms,
	442	void (callback)(int status, struct sockaddr src_addr,
	443	struct rdma_dev_addr addr, void context),
	444	void *context)
	445	{
38617c64	446	struct sockaddr src_in, dst_in;
7025fcd3 SH	447	struct addr_req *req;
	448	int ret = 0;
	449
dd00cc48	450	req = kzalloc(sizeof *req, GFP_KERNEL);
7025fcd3 SH	451	if (!req)
7025fcd3 SH	452	return -ENOMEM;
7025fcd3	453
d2e08862 SH	454	src_in = (struct sockaddr *) &req->src_addr;
	455	dst_in = (struct sockaddr *) &req->dst_addr;
	456
	457	if (src_addr) {
	458	if (src_addr->sa_family != dst_addr->sa_family) {
	459	ret = -EINVAL;
	460	goto err;
	461	}
	462
ef560861	463	memcpy(src_in, src_addr, rdma_addr_size(src_addr));
d2e08862 SH	464	} else {
	465	src_in->sa_family = dst_addr->sa_family;
	466	}
	467
ef560861	468	memcpy(dst_in, dst_addr, rdma_addr_size(dst_addr));
7025fcd3 SH	469	req->addr = addr;
	470	req->callback = callback;
	471	req->context = context;
7a118df3 SH	472	req->client = client;
7a118df3 SH	473	atomic_inc(&client->refcount);
7025fcd3	474
20029832	475	req->status = addr_resolve(src_in, dst_in, addr, true);
7025fcd3 SH	476	switch (req->status) {
	477	case 0:
	478	req->timeout = jiffies;
	479	queue_req(req);
	480	break;
	481	case -ENODATA:
	482	req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
	483	queue_req(req);
7025fcd3 SH	484	break;
	485	default:
	486	ret = req->status;
7a118df3	487	atomic_dec(&client->refcount);
d2e08862	488	goto err;
7025fcd3 SH	489	}
7025fcd3 SH	490	return ret;
d2e08862 SH	491	err:
	492	kfree(req);
	493	return ret;
7025fcd3 SH	494	}
	495	EXPORT_SYMBOL(rdma_resolve_ip);
	496
20029832 MB	497	int rdma_resolve_ip_route(struct sockaddr *src_addr,
	498	const struct sockaddr *dst_addr,
	499	struct rdma_dev_addr *addr)
	500	{
	501	struct sockaddr_storage ssrc_addr = {};
	502	struct sockaddr src_in = (struct sockaddr )&ssrc_addr;
	503
9506902b MB	504	if (src_addr) {
	505	if (src_addr->sa_family != dst_addr->sa_family)
	506	return -EINVAL;
20029832	507
20029832	508	memcpy(src_in, src_addr, rdma_addr_size(src_addr));
9506902b	509	} else {
20029832	510	src_in->sa_family = dst_addr->sa_family;
9506902b	511	}
20029832 MB	512
	513	return addr_resolve(src_in, dst_addr, addr, false);
	514	}
	515	EXPORT_SYMBOL(rdma_resolve_ip_route);
	516
7025fcd3 SH	517	void rdma_addr_cancel(struct rdma_dev_addr *addr)
	518	{
	519	struct addr_req req, temp_req;
	520
	521	mutex_lock(&lock);
	522	list_for_each_entry_safe(req, temp_req, &req_list, list) {
	523	if (req->addr == addr) {
	524	req->status = -ECANCELED;
	525	req->timeout = jiffies;
04699a1f	526	list_move(&req->list, &req_list);
7025fcd3 SH	527	set_timeout(req->timeout);
	528	break;
	529	}
	530	}
	531	mutex_unlock(&lock);
	532	}
	533	EXPORT_SYMBOL(rdma_addr_cancel);
	534
dd5f03be MB	535	struct resolve_cb_context {
	536	struct rdma_dev_addr *addr;
	537	struct completion comp;
	538	};
	539
	540	static void resolve_cb(int status, struct sockaddr *src_addr,
	541	struct rdma_dev_addr addr, void context)
	542	{
	543	memcpy(((struct resolve_cb_context *)context)->addr, addr, sizeof(struct
	544	rdma_dev_addr));
	545	complete(&((struct resolve_cb_context *)context)->comp);
	546	}
	547
f7f4b23e MB	548	int rdma_addr_find_l2_eth_by_grh(const union ib_gid *sgid,
f7f4b23e MB	549	const union ib_gid *dgid,
c3efe750 MB	550	u8 dmac, u16 vlan_id, int *if_index,
c3efe750 MB	551	int *hoplimit)
dd5f03be MB	552	{
	553	int ret = 0;
	554	struct rdma_dev_addr dev_addr;
	555	struct resolve_cb_context ctx;
	556	struct net_device *dev;
	557
	558	union {
	559	struct sockaddr _sockaddr;
	560	struct sockaddr_in _sockaddr_in;
	561	struct sockaddr_in6 _sockaddr_in6;
	562	} sgid_addr, dgid_addr;
	563
	564
471e7058 HL	565	rdma_gid2ip(&sgid_addr._sockaddr, sgid);
471e7058 HL	566	rdma_gid2ip(&dgid_addr._sockaddr, dgid);
dd5f03be MB	567
dd5f03be MB	568	memset(&dev_addr, 0, sizeof(dev_addr));
20029832 MB	569	if (if_index)
20029832 MB	570	dev_addr.bound_dev_if = *if_index;
565edd1d	571	dev_addr.net = &init_net;
dd5f03be MB	572
	573	ctx.addr = &dev_addr;
	574	init_completion(&ctx.comp);
	575	ret = rdma_resolve_ip(&self, &sgid_addr._sockaddr, &dgid_addr._sockaddr,
	576	&dev_addr, 1000, resolve_cb, &ctx);
	577	if (ret)
	578	return ret;
	579
	580	wait_for_completion(&ctx.comp);
	581
	582	memcpy(dmac, dev_addr.dst_dev_addr, ETH_ALEN);
	583	dev = dev_get_by_index(&init_net, dev_addr.bound_dev_if);
	584	if (!dev)
	585	return -ENODEV;
20029832 MB	586	if (if_index)
20029832 MB	587	*if_index = dev_addr.bound_dev_if;
dd5f03be MB	588	if (vlan_id)
dd5f03be MB	589	*vlan_id = rdma_vlan_dev_vlan_id(dev);
c3efe750 MB	590	if (hoplimit)
c3efe750 MB	591	*hoplimit = dev_addr.hoplimit;
dd5f03be MB	592	dev_put(dev);
	593	return ret;
	594	}
f7f4b23e	595	EXPORT_SYMBOL(rdma_addr_find_l2_eth_by_grh);
dd5f03be MB	596
	597	int rdma_addr_find_smac_by_sgid(union ib_gid sgid, u8 smac, u16 *vlan_id)
	598	{
	599	int ret = 0;
	600	struct rdma_dev_addr dev_addr;
	601	union {
	602	struct sockaddr _sockaddr;
	603	struct sockaddr_in _sockaddr_in;
	604	struct sockaddr_in6 _sockaddr_in6;
	605	} gid_addr;
	606
471e7058	607	rdma_gid2ip(&gid_addr._sockaddr, sgid);
dd5f03be	608
dd5f03be	609	memset(&dev_addr, 0, sizeof(dev_addr));
565edd1d	610	dev_addr.net = &init_net;
dd5f03be MB	611	ret = rdma_translate_ip(&gid_addr._sockaddr, &dev_addr, vlan_id);
	612	if (ret)
	613	return ret;
	614
	615	memcpy(smac, dev_addr.src_dev_addr, ETH_ALEN);
	616	return ret;
	617	}
	618	EXPORT_SYMBOL(rdma_addr_find_smac_by_sgid);
	619
3cd96564	620	static int netevent_callback(struct notifier_block *self, unsigned long event,
e795d092	621	void *ctx)
7025fcd3	622	{
3cd96564	623	if (event == NETEVENT_NEIGH_UPDATE) {
e795d092	624	struct neighbour *neigh = ctx;
7025fcd3	625
1f126670	626	if (neigh->nud_state & NUD_VALID) {
e795d092 TT	627	set_timeout(jiffies);
	628	}
	629	}
7025fcd3 SH	630	return 0;
	631	}
	632
e795d092 TT	633	static struct notifier_block nb = {
e795d092 TT	634	.notifier_call = netevent_callback
7025fcd3 SH	635	};
7025fcd3 SH	636
716abb1f	637	static int __init addr_init(void)
7025fcd3	638	{
c7f743a6	639	addr_wq = create_singlethread_workqueue("ib_addr");
7025fcd3 SH	640	if (!addr_wq)
	641	return -ENOMEM;
	642
e795d092	643	register_netevent_notifier(&nb);
dd5f03be	644	rdma_addr_register_client(&self);
7025fcd3 SH	645	return 0;
	646	}
	647
716abb1f	648	static void __exit addr_cleanup(void)
7025fcd3	649	{
dd5f03be	650	rdma_addr_unregister_client(&self);
e795d092	651	unregister_netevent_notifier(&nb);
7025fcd3 SH	652	destroy_workqueue(addr_wq);
	653	}
	654
	655	module_init(addr_init);
	656	module_exit(addr_cleanup);