[linux-2.6-block.git] / drivers / net / ethernet / marvell / prestera / prestera_router.c

// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
/* Copyright (c) 2019-2021 Marvell International Ltd. All rights reserved */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/inetdevice.h>
#include <net/inet_dscp.h>
#include <net/switchdev.h>
#include <linux/rhashtable.h>

#include "prestera.h"
#include "prestera_router_hw.h"

struct prestera_kern_fib_cache_key {
	struct prestera_ip_addr addr;
	u32 prefix_len;
	u32 kern_tb_id; /* tb_id from kernel (not fixed) */
};

/* Subscribing on neighbours in kernel */
struct prestera_kern_fib_cache {
	struct prestera_kern_fib_cache_key key;
	struct {
		struct prestera_fib_key fib_key;
		enum prestera_fib_type fib_type;
	} lpm_info; /* hold prepared lpm info */
	/* Indicate if route is not overlapped by another table */
	struct rhash_head ht_node; /* node of prestera_router */
	struct fib_info *fi;
	dscp_t kern_dscp;
	u8 kern_type;
	bool reachable;
};

static const struct rhashtable_params __prestera_kern_fib_cache_ht_params = {
	.key_offset  = offsetof(struct prestera_kern_fib_cache, key),
	.head_offset = offsetof(struct prestera_kern_fib_cache, ht_node),
	.key_len     = sizeof(struct prestera_kern_fib_cache_key),
	.automatic_shrinking = true,
};

/* This util to be used, to convert kernel rules for default vr in hw_vr */
static u32 prestera_fix_tb_id(u32 tb_id)
{
	if (tb_id == RT_TABLE_UNSPEC ||
	    tb_id == RT_TABLE_LOCAL ||
	    tb_id == RT_TABLE_DEFAULT)
		tb_id = RT_TABLE_MAIN;

	return tb_id;
}

static void
prestera_util_fen_info2fib_cache_key(struct fib_entry_notifier_info *fen_info,
				     struct prestera_kern_fib_cache_key *key)
{
	memset(key, 0, sizeof(*key));
	key->addr.u.ipv4 = cpu_to_be32(fen_info->dst);
	key->prefix_len = fen_info->dst_len;
	key->kern_tb_id = fen_info->tb_id;
}

static struct prestera_kern_fib_cache *
prestera_kern_fib_cache_find(struct prestera_switch *sw,
			     struct prestera_kern_fib_cache_key *key)
{
	struct prestera_kern_fib_cache *fib_cache;

	fib_cache =
	 rhashtable_lookup_fast(&sw->router->kern_fib_cache_ht, key,
				__prestera_kern_fib_cache_ht_params);
	return fib_cache;
}

static void
prestera_kern_fib_cache_destroy(struct prestera_switch *sw,
				struct prestera_kern_fib_cache *fib_cache)
{
	fib_info_put(fib_cache->fi);
	rhashtable_remove_fast(&sw->router->kern_fib_cache_ht,
			       &fib_cache->ht_node,
			       __prestera_kern_fib_cache_ht_params);
	kfree(fib_cache);
}

/* Operations on fi (offload, etc) must be wrapped in utils.
 * This function just create storage.
 */
static struct prestera_kern_fib_cache *
prestera_kern_fib_cache_create(struct prestera_switch *sw,
			       struct prestera_kern_fib_cache_key *key,
			       struct fib_info *fi, dscp_t dscp, u8 type)
{
	struct prestera_kern_fib_cache *fib_cache;
	int err;

	fib_cache = kzalloc(sizeof(*fib_cache), GFP_KERNEL);
	if (!fib_cache)
		goto err_kzalloc;

	memcpy(&fib_cache->key, key, sizeof(*key));
	fib_info_hold(fi);
	fib_cache->fi = fi;
	fib_cache->kern_dscp = dscp;
	fib_cache->kern_type = type;

	err = rhashtable_insert_fast(&sw->router->kern_fib_cache_ht,
				     &fib_cache->ht_node,
				     __prestera_kern_fib_cache_ht_params);
	if (err)
		goto err_ht_insert;

	return fib_cache;

err_ht_insert:
	fib_info_put(fi);
	kfree(fib_cache);
err_kzalloc:
	return NULL;
}

static void
__prestera_k_arb_fib_lpm_offload_set(struct prestera_switch *sw,
				     struct prestera_kern_fib_cache *fc,
				     bool fail, bool offload, bool trap)
{
	struct fib_rt_info fri;

	if (fc->key.addr.v != PRESTERA_IPV4)
		return;

	fri.fi = fc->fi;
	fri.tb_id = fc->key.kern_tb_id;
	fri.dst = fc->key.addr.u.ipv4;
	fri.dst_len = fc->key.prefix_len;
	fri.dscp = fc->kern_dscp;
	fri.type = fc->kern_type;
	/* flags begin */
	fri.offload = offload;
	fri.trap = trap;
	fri.offload_failed = fail;
	/* flags end */
	fib_alias_hw_flags_set(&init_net, &fri);
}

static int
__prestera_pr_k_arb_fc_lpm_info_calc(struct prestera_switch *sw,
				     struct prestera_kern_fib_cache *fc)
{
	memset(&fc->lpm_info, 0, sizeof(fc->lpm_info));

	switch (fc->fi->fib_type) {
	case RTN_UNICAST:
		fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_TRAP;
		break;
	/* Unsupported. Leave it for kernel: */
	case RTN_BROADCAST:
	case RTN_MULTICAST:
	/* Routes we must trap by design: */
	case RTN_LOCAL:
	case RTN_UNREACHABLE:
	case RTN_PROHIBIT:
		fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_TRAP;
		break;
	case RTN_BLACKHOLE:
		fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_DROP;
		break;
	default:
		dev_err(sw->dev->dev, "Unsupported fib_type");
		return -EOPNOTSUPP;
	}

	fc->lpm_info.fib_key.addr = fc->key.addr;
	fc->lpm_info.fib_key.prefix_len = fc->key.prefix_len;
	fc->lpm_info.fib_key.tb_id = prestera_fix_tb_id(fc->key.kern_tb_id);

	return 0;
}

static int __prestera_k_arb_f_lpm_set(struct prestera_switch *sw,
				      struct prestera_kern_fib_cache *fc,
				      bool enabled)
{
	struct prestera_fib_node *fib_node;

	fib_node = prestera_fib_node_find(sw, &fc->lpm_info.fib_key);
	if (fib_node)
		prestera_fib_node_destroy(sw, fib_node);

	if (!enabled)
		return 0;

	fib_node = prestera_fib_node_create(sw, &fc->lpm_info.fib_key,
					    fc->lpm_info.fib_type);

	if (!fib_node) {
		dev_err(sw->dev->dev, "fib_node=NULL %pI4n/%d kern_tb_id = %d",
			&fc->key.addr.u.ipv4, fc->key.prefix_len,
			fc->key.kern_tb_id);
		return -ENOENT;
	}

	return 0;
}

static int __prestera_k_arb_fc_apply(struct prestera_switch *sw,
				     struct prestera_kern_fib_cache *fc)
{
	int err;

	err = __prestera_pr_k_arb_fc_lpm_info_calc(sw, fc);
	if (err)
		return err;

	err = __prestera_k_arb_f_lpm_set(sw, fc, fc->reachable);
	if (err) {
		__prestera_k_arb_fib_lpm_offload_set(sw, fc,
						     true, false, false);
		return err;
	}

	switch (fc->lpm_info.fib_type) {
	case PRESTERA_FIB_TYPE_TRAP:
		__prestera_k_arb_fib_lpm_offload_set(sw, fc, false,
						     false, fc->reachable);
		break;
	case PRESTERA_FIB_TYPE_DROP:
		__prestera_k_arb_fib_lpm_offload_set(sw, fc, false, true,
						     fc->reachable);
		break;
	case PRESTERA_FIB_TYPE_INVALID:
		break;
	}

	return 0;
}

static struct prestera_kern_fib_cache *
__prestera_k_arb_util_fib_overlaps(struct prestera_switch *sw,
				   struct prestera_kern_fib_cache *fc)
{
	struct prestera_kern_fib_cache_key fc_key;
	struct prestera_kern_fib_cache *rfc;

	/* TODO: parse kernel rules */
	rfc = NULL;
	if (fc->key.kern_tb_id == RT_TABLE_LOCAL) {
		memcpy(&fc_key, &fc->key, sizeof(fc_key));
		fc_key.kern_tb_id = RT_TABLE_MAIN;
		rfc = prestera_kern_fib_cache_find(sw, &fc_key);
	}

	return rfc;
}

static struct prestera_kern_fib_cache *
__prestera_k_arb_util_fib_overlapped(struct prestera_switch *sw,
				     struct prestera_kern_fib_cache *fc)
{
	struct prestera_kern_fib_cache_key fc_key;
	struct prestera_kern_fib_cache *rfc;

	/* TODO: parse kernel rules */
	rfc = NULL;
	if (fc->key.kern_tb_id == RT_TABLE_MAIN) {
		memcpy(&fc_key, &fc->key, sizeof(fc_key));
		fc_key.kern_tb_id = RT_TABLE_LOCAL;
		rfc = prestera_kern_fib_cache_find(sw, &fc_key);
	}

	return rfc;
}

static int
prestera_k_arb_fib_evt(struct prestera_switch *sw,
		       bool replace, /* replace or del */
		       struct fib_entry_notifier_info *fen_info)
{
	struct prestera_kern_fib_cache *tfib_cache, *bfib_cache; /* top/btm */
	struct prestera_kern_fib_cache_key fc_key;
	struct prestera_kern_fib_cache *fib_cache;
	int err;

	prestera_util_fen_info2fib_cache_key(fen_info, &fc_key);
	fib_cache = prestera_kern_fib_cache_find(sw, &fc_key);
	if (fib_cache) {
		fib_cache->reachable = false;
		err = __prestera_k_arb_fc_apply(sw, fib_cache);
		if (err)
			dev_err(sw->dev->dev,
				"Applying destroyed fib_cache failed");

		bfib_cache = __prestera_k_arb_util_fib_overlaps(sw, fib_cache);
		tfib_cache = __prestera_k_arb_util_fib_overlapped(sw, fib_cache);
		if (!tfib_cache && bfib_cache) {
			bfib_cache->reachable = true;
			err = __prestera_k_arb_fc_apply(sw, bfib_cache);
			if (err)
				dev_err(sw->dev->dev,
					"Applying fib_cache btm failed");
		}

		prestera_kern_fib_cache_destroy(sw, fib_cache);
	}

	if (replace) {
		fib_cache = prestera_kern_fib_cache_create(sw, &fc_key,
							   fen_info->fi,
							   fen_info->dscp,
							   fen_info->type);
		if (!fib_cache) {
			dev_err(sw->dev->dev, "fib_cache == NULL");
			return -ENOENT;
		}

		bfib_cache = __prestera_k_arb_util_fib_overlaps(sw, fib_cache);
		tfib_cache = __prestera_k_arb_util_fib_overlapped(sw, fib_cache);
		if (!tfib_cache)
			fib_cache->reachable = true;

		if (bfib_cache) {
			bfib_cache->reachable = false;
			err = __prestera_k_arb_fc_apply(sw, bfib_cache);
			if (err)
				dev_err(sw->dev->dev,
					"Applying fib_cache btm failed");
		}

		err = __prestera_k_arb_fc_apply(sw, fib_cache);
		if (err)
			dev_err(sw->dev->dev, "Applying fib_cache failed");
	}

	return 0;
}

static int __prestera_inetaddr_port_event(struct net_device *port_dev,
					  unsigned long event,
					  struct netlink_ext_ack *extack)
{
	struct prestera_port *port = netdev_priv(port_dev);
	struct prestera_rif_entry_key re_key = {};
	struct prestera_rif_entry *re;
	u32 kern_tb_id;
	int err;

	err = prestera_is_valid_mac_addr(port, port_dev->dev_addr);
	if (err) {
		NL_SET_ERR_MSG_MOD(extack, "RIF MAC must have the same prefix");
		return err;
	}

	kern_tb_id = l3mdev_fib_table(port_dev);
	re_key.iface.type = PRESTERA_IF_PORT_E;
	re_key.iface.dev_port.hw_dev_num  = port->dev_id;
	re_key.iface.dev_port.port_num  = port->hw_id;
	re = prestera_rif_entry_find(port->sw, &re_key);

	switch (event) {
	case NETDEV_UP:
		if (re) {
			NL_SET_ERR_MSG_MOD(extack, "RIF already exist");
			return -EEXIST;
		}
		re = prestera_rif_entry_create(port->sw, &re_key,
					       prestera_fix_tb_id(kern_tb_id),
					       port_dev->dev_addr);
		if (!re) {
			NL_SET_ERR_MSG_MOD(extack, "Can't create RIF");
			return -EINVAL;
		}
		dev_hold(port_dev);
		break;
	case NETDEV_DOWN:
		if (!re) {
			NL_SET_ERR_MSG_MOD(extack, "Can't find RIF");
			return -EEXIST;
		}
		prestera_rif_entry_destroy(port->sw, re);
		dev_put(port_dev);
		break;
	}

	return 0;
}

static int __prestera_inetaddr_event(struct prestera_switch *sw,
				     struct net_device *dev,
				     unsigned long event,
				     struct netlink_ext_ack *extack)
{
	if (!prestera_netdev_check(dev) || netif_is_bridge_port(dev) ||
	    netif_is_lag_port(dev) || netif_is_ovs_port(dev))
		return 0;

	return __prestera_inetaddr_port_event(dev, event, extack);
}

static int __prestera_inetaddr_cb(struct notifier_block *nb,
				  unsigned long event, void *ptr)
{
	struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
	struct net_device *dev = ifa->ifa_dev->dev;
	struct prestera_router *router = container_of(nb,
						      struct prestera_router,
						      inetaddr_nb);
	struct in_device *idev;
	int err = 0;

	if (event != NETDEV_DOWN)
		goto out;

	/* Ignore if this is not latest address */
	idev = __in_dev_get_rtnl(dev);
	if (idev && idev->ifa_list)
		goto out;

	err = __prestera_inetaddr_event(router->sw, dev, event, NULL);
out:
	return notifier_from_errno(err);
}

static int __prestera_inetaddr_valid_cb(struct notifier_block *nb,
					unsigned long event, void *ptr)
{
	struct in_validator_info *ivi = (struct in_validator_info *)ptr;
	struct net_device *dev = ivi->ivi_dev->dev;
	struct prestera_router *router = container_of(nb,
						      struct prestera_router,
						      inetaddr_valid_nb);
	struct in_device *idev;
	int err = 0;

	if (event != NETDEV_UP)
		goto out;

	/* Ignore if this is not first address */
	idev = __in_dev_get_rtnl(dev);
	if (idev && idev->ifa_list)
		goto out;

	if (ipv4_is_multicast(ivi->ivi_addr)) {
		NL_SET_ERR_MSG_MOD(ivi->extack,
				   "Multicast addr on RIF is not supported");
		err = -EINVAL;
		goto out;
	}

	err = __prestera_inetaddr_event(router->sw, dev, event, ivi->extack);
out:
	return notifier_from_errno(err);
}

struct prestera_fib_event_work {
	struct work_struct work;
	struct prestera_switch *sw;
	struct fib_entry_notifier_info fen_info;
	unsigned long event;
};

static void __prestera_router_fib_event_work(struct work_struct *work)
{
	struct prestera_fib_event_work *fib_work =
			container_of(work, struct prestera_fib_event_work, work);
	struct prestera_switch *sw = fib_work->sw;
	int err;

	rtnl_lock();

	switch (fib_work->event) {
	case FIB_EVENT_ENTRY_REPLACE:
		err = prestera_k_arb_fib_evt(sw, true, &fib_work->fen_info);
		if (err)
			goto err_out;

		break;
	case FIB_EVENT_ENTRY_DEL:
		err = prestera_k_arb_fib_evt(sw, false, &fib_work->fen_info);
		if (err)
			goto err_out;

		break;
	}

	goto out;

err_out:
	dev_err(sw->dev->dev, "Error when processing %pI4h/%d",
		&fib_work->fen_info.dst,
		fib_work->fen_info.dst_len);
out:
	fib_info_put(fib_work->fen_info.fi);
	rtnl_unlock();
	kfree(fib_work);
}

/* Called with rcu_read_lock() */
static int __prestera_router_fib_event(struct notifier_block *nb,
				       unsigned long event, void *ptr)
{
	struct prestera_fib_event_work *fib_work;
	struct fib_entry_notifier_info *fen_info;
	struct fib_notifier_info *info = ptr;
	struct prestera_router *router;

	if (info->family != AF_INET)
		return NOTIFY_DONE;

	router = container_of(nb, struct prestera_router, fib_nb);

	switch (event) {
	case FIB_EVENT_ENTRY_REPLACE:
	case FIB_EVENT_ENTRY_DEL:
		fen_info = container_of(info, struct fib_entry_notifier_info,
					info);
		if (!fen_info->fi)
			return NOTIFY_DONE;

		fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
		if (WARN_ON(!fib_work))
			return NOTIFY_BAD;

		fib_info_hold(fen_info->fi);
		fib_work->fen_info = *fen_info;
		fib_work->event = event;
		fib_work->sw = router->sw;
		INIT_WORK(&fib_work->work, __prestera_router_fib_event_work);
		prestera_queue_work(&fib_work->work);
		break;
	default:
		return NOTIFY_DONE;
	}

	return NOTIFY_DONE;
}

int prestera_router_init(struct prestera_switch *sw)
{
	struct prestera_router *router;
	int err;

	router = kzalloc(sizeof(*sw->router), GFP_KERNEL);
	if (!router)
		return -ENOMEM;

	sw->router = router;
	router->sw = sw;

	err = prestera_router_hw_init(sw);
	if (err)
		goto err_router_lib_init;

	err = rhashtable_init(&router->kern_fib_cache_ht,
			      &__prestera_kern_fib_cache_ht_params);
	if (err)
		goto err_kern_fib_cache_ht_init;

	router->inetaddr_valid_nb.notifier_call = __prestera_inetaddr_valid_cb;
	err = register_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
	if (err)
		goto err_register_inetaddr_validator_notifier;

	router->inetaddr_nb.notifier_call = __prestera_inetaddr_cb;
	err = register_inetaddr_notifier(&router->inetaddr_nb);
	if (err)
		goto err_register_inetaddr_notifier;

	router->fib_nb.notifier_call = __prestera_router_fib_event;
	err = register_fib_notifier(&init_net, &router->fib_nb,
				    /* TODO: flush fib entries */ NULL, NULL);
	if (err)
		goto err_register_fib_notifier;

	return 0;

err_register_fib_notifier:
	unregister_inetaddr_notifier(&router->inetaddr_nb);
err_register_inetaddr_notifier:
	unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
err_register_inetaddr_validator_notifier:
	rhashtable_destroy(&router->kern_fib_cache_ht);
err_kern_fib_cache_ht_init:
	prestera_router_hw_fini(sw);
err_router_lib_init:
	kfree(sw->router);
	return err;
}

void prestera_router_fini(struct prestera_switch *sw)
{
	unregister_fib_notifier(&init_net, &sw->router->fib_nb);
	unregister_inetaddr_notifier(&sw->router->inetaddr_nb);
	unregister_inetaddr_validator_notifier(&sw->router->inetaddr_valid_nb);
	rhashtable_destroy(&sw->router->kern_fib_cache_ht);
	prestera_router_hw_fini(sw);
	kfree(sw->router);
	sw->router = NULL;
}
Commit	Line	Data
69204174 YO	1	// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
	2	/* Copyright (c) 2019-2021 Marvell International Ltd. All rights reserved */
	3
	4	#include <linux/kernel.h>
	5	#include <linux/types.h>
da3c1639	6	#include <linux/inetdevice.h>
888ade8f	7	#include <net/inet_dscp.h>
15fa9e8c	8	#include <net/switchdev.h>
4394fbcb	9	#include <linux/rhashtable.h>
69204174 YO	10
69204174 YO	11	#include "prestera.h"
bca5859b	12	#include "prestera_router_hw.h"
69204174	13
4394fbcb YO	14	struct prestera_kern_fib_cache_key {
	15	struct prestera_ip_addr addr;
	16	u32 prefix_len;
	17	u32 kern_tb_id; /* tb_id from kernel (not fixed) */
	18	};
	19
	20	/* Subscribing on neighbours in kernel */
	21	struct prestera_kern_fib_cache {
	22	struct prestera_kern_fib_cache_key key;
	23	struct {
	24	struct prestera_fib_key fib_key;
	25	enum prestera_fib_type fib_type;
	26	} lpm_info; /* hold prepared lpm info */
	27	/* Indicate if route is not overlapped by another table */
	28	struct rhash_head ht_node; /* node of prestera_router */
	29	struct fib_info *fi;
9f6982e9	30	dscp_t kern_dscp;
4394fbcb YO	31	u8 kern_type;
	32	bool reachable;
	33	};
	34
	35	static const struct rhashtable_params __prestera_kern_fib_cache_ht_params = {
	36	.key_offset = offsetof(struct prestera_kern_fib_cache, key),
	37	.head_offset = offsetof(struct prestera_kern_fib_cache, ht_node),
	38	.key_len = sizeof(struct prestera_kern_fib_cache_key),
	39	.automatic_shrinking = true,
	40	};
	41
15fa9e8c YO	42	/* This util to be used, to convert kernel rules for default vr in hw_vr */
	43	static u32 prestera_fix_tb_id(u32 tb_id)
	44	{
	45	if (tb_id == RT_TABLE_UNSPEC \|\|
	46	tb_id == RT_TABLE_LOCAL \|\|
	47	tb_id == RT_TABLE_DEFAULT)
	48	tb_id = RT_TABLE_MAIN;
	49
	50	return tb_id;
	51	}
	52
4394fbcb YO	53	static void
	54	prestera_util_fen_info2fib_cache_key(struct fib_entry_notifier_info *fen_info,
	55	struct prestera_kern_fib_cache_key *key)
	56	{
	57	memset(key, 0, sizeof(*key));
	58	key->addr.u.ipv4 = cpu_to_be32(fen_info->dst);
	59	key->prefix_len = fen_info->dst_len;
	60	key->kern_tb_id = fen_info->tb_id;
	61	}
	62
	63	static struct prestera_kern_fib_cache *
	64	prestera_kern_fib_cache_find(struct prestera_switch *sw,
	65	struct prestera_kern_fib_cache_key *key)
	66	{
	67	struct prestera_kern_fib_cache *fib_cache;
	68
	69	fib_cache =
	70	rhashtable_lookup_fast(&sw->router->kern_fib_cache_ht, key,
	71	__prestera_kern_fib_cache_ht_params);
37f40f81	72	return fib_cache;
4394fbcb YO	73	}
	74
	75	static void
	76	prestera_kern_fib_cache_destroy(struct prestera_switch *sw,
	77	struct prestera_kern_fib_cache *fib_cache)
	78	{
	79	fib_info_put(fib_cache->fi);
	80	rhashtable_remove_fast(&sw->router->kern_fib_cache_ht,
	81	&fib_cache->ht_node,
	82	__prestera_kern_fib_cache_ht_params);
	83	kfree(fib_cache);
	84	}
	85
	86	/* Operations on fi (offload, etc) must be wrapped in utils.
	87	* This function just create storage.
	88	*/
	89	static struct prestera_kern_fib_cache *
	90	prestera_kern_fib_cache_create(struct prestera_switch *sw,
	91	struct prestera_kern_fib_cache_key *key,
568a3f33	92	struct fib_info *fi, dscp_t dscp, u8 type)
4394fbcb YO	93	{
	94	struct prestera_kern_fib_cache *fib_cache;
	95	int err;
	96
	97	fib_cache = kzalloc(sizeof(*fib_cache), GFP_KERNEL);
	98	if (!fib_cache)
	99	goto err_kzalloc;
	100
	101	memcpy(&fib_cache->key, key, sizeof(*key));
	102	fib_info_hold(fi);
	103	fib_cache->fi = fi;
9f6982e9	104	fib_cache->kern_dscp = dscp;
4394fbcb YO	105	fib_cache->kern_type = type;
	106
	107	err = rhashtable_insert_fast(&sw->router->kern_fib_cache_ht,
	108	&fib_cache->ht_node,
	109	__prestera_kern_fib_cache_ht_params);
	110	if (err)
	111	goto err_ht_insert;
	112
	113	return fib_cache;
	114
	115	err_ht_insert:
	116	fib_info_put(fi);
	117	kfree(fib_cache);
	118	err_kzalloc:
	119	return NULL;
	120	}
	121
	122	static void
	123	__prestera_k_arb_fib_lpm_offload_set(struct prestera_switch *sw,
	124	struct prestera_kern_fib_cache *fc,
	125	bool fail, bool offload, bool trap)
	126	{
	127	struct fib_rt_info fri;
	128
	129	if (fc->key.addr.v != PRESTERA_IPV4)
	130	return;
	131
	132	fri.fi = fc->fi;
	133	fri.tb_id = fc->key.kern_tb_id;
	134	fri.dst = fc->key.addr.u.ipv4;
	135	fri.dst_len = fc->key.prefix_len;
9f6982e9	136	fri.dscp = fc->kern_dscp;
4394fbcb YO	137	fri.type = fc->kern_type;
	138	/* flags begin */
	139	fri.offload = offload;
	140	fri.trap = trap;
	141	fri.offload_failed = fail;
	142	/* flags end */
	143	fib_alias_hw_flags_set(&init_net, &fri);
	144	}
	145
	146	static int
	147	__prestera_pr_k_arb_fc_lpm_info_calc(struct prestera_switch *sw,
	148	struct prestera_kern_fib_cache *fc)
	149	{
	150	memset(&fc->lpm_info, 0, sizeof(fc->lpm_info));
	151
	152	switch (fc->fi->fib_type) {
	153	case RTN_UNICAST:
	154	fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_TRAP;
	155	break;
	156	/* Unsupported. Leave it for kernel: */
	157	case RTN_BROADCAST:
	158	case RTN_MULTICAST:
	159	/* Routes we must trap by design: */
	160	case RTN_LOCAL:
	161	case RTN_UNREACHABLE:
	162	case RTN_PROHIBIT:
	163	fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_TRAP;
	164	break;
	165	case RTN_BLACKHOLE:
	166	fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_DROP;
	167	break;
	168	default:
	169	dev_err(sw->dev->dev, "Unsupported fib_type");
	170	return -EOPNOTSUPP;
	171	}
	172
	173	fc->lpm_info.fib_key.addr = fc->key.addr;
	174	fc->lpm_info.fib_key.prefix_len = fc->key.prefix_len;
	175	fc->lpm_info.fib_key.tb_id = prestera_fix_tb_id(fc->key.kern_tb_id);
	176
	177	return 0;
	178	}
	179
	180	static int __prestera_k_arb_f_lpm_set(struct prestera_switch *sw,
	181	struct prestera_kern_fib_cache *fc,
	182	bool enabled)
	183	{
	184	struct prestera_fib_node *fib_node;
	185
	186	fib_node = prestera_fib_node_find(sw, &fc->lpm_info.fib_key);
	187	if (fib_node)
	188	prestera_fib_node_destroy(sw, fib_node);
	189
	190	if (!enabled)
	191	return 0;
	192
	193	fib_node = prestera_fib_node_create(sw, &fc->lpm_info.fib_key,
	194	fc->lpm_info.fib_type);
	195
	196	if (!fib_node) {
	197	dev_err(sw->dev->dev, "fib_node=NULL %pI4n/%d kern_tb_id = %d",
	198	&fc->key.addr.u.ipv4, fc->key.prefix_len,
	199	fc->key.kern_tb_id);
	200	return -ENOENT;
201	}
202
203	return 0;
204	}
205
206	static int __prestera_k_arb_fc_apply(struct prestera_switch *sw,
207	struct prestera_kern_fib_cache *fc)
208	{
209	int err;
210
211	err = __prestera_pr_k_arb_fc_lpm_info_calc(sw, fc);
212	if (err)
213	return err;
214
215	err = __prestera_k_arb_f_lpm_set(sw, fc, fc->reachable);
216	if (err) {
217	__prestera_k_arb_fib_lpm_offload_set(sw, fc,
218	true, false, false);
219	return err;
220	}
221
222	switch (fc->lpm_info.fib_type) {
223	case PRESTERA_FIB_TYPE_TRAP:
224	__prestera_k_arb_fib_lpm_offload_set(sw, fc, false,
225	false, fc->reachable);
226	break;
227	case PRESTERA_FIB_TYPE_DROP:
228	__prestera_k_arb_fib_lpm_offload_set(sw, fc, false, true,
229	fc->reachable);
230	break;
231	case PRESTERA_FIB_TYPE_INVALID:
232	break;
233	}
234
235	return 0;
236	}
237
238	static struct prestera_kern_fib_cache *
239	__prestera_k_arb_util_fib_overlaps(struct prestera_switch *sw,
240	struct prestera_kern_fib_cache *fc)
241	{
242	struct prestera_kern_fib_cache_key fc_key;
243	struct prestera_kern_fib_cache *rfc;
244
245	/* TODO: parse kernel rules */
246	rfc = NULL;
247	if (fc->key.kern_tb_id == RT_TABLE_LOCAL) {
248	memcpy(&fc_key, &fc->key, sizeof(fc_key));
249	fc_key.kern_tb_id = RT_TABLE_MAIN;
250	rfc = prestera_kern_fib_cache_find(sw, &fc_key);
251	}
252
253	return rfc;
254	}
255
256	static struct prestera_kern_fib_cache *
257	__prestera_k_arb_util_fib_overlapped(struct prestera_switch *sw,
258	struct prestera_kern_fib_cache *fc)
259	{
260	struct prestera_kern_fib_cache_key fc_key;
261	struct prestera_kern_fib_cache *rfc;
262
263	/* TODO: parse kernel rules */
264	rfc = NULL;
265	if (fc->key.kern_tb_id == RT_TABLE_MAIN) {
266	memcpy(&fc_key, &fc->key, sizeof(fc_key));
267	fc_key.kern_tb_id = RT_TABLE_LOCAL;
268	rfc = prestera_kern_fib_cache_find(sw, &fc_key);
269	}
270
271	return rfc;
272	}
273
274	static int
275	prestera_k_arb_fib_evt(struct prestera_switch *sw,
276	bool replace, /* replace or del */
277	struct fib_entry_notifier_info *fen_info)
278	{
279	struct prestera_kern_fib_cache tfib_cache, bfib_cache; /* top/btm */
280	struct prestera_kern_fib_cache_key fc_key;
281	struct prestera_kern_fib_cache *fib_cache;
282	int err;
283
284	prestera_util_fen_info2fib_cache_key(fen_info, &fc_key);
285	fib_cache = prestera_kern_fib_cache_find(sw, &fc_key);
286	if (fib_cache) {
287	fib_cache->reachable = false;
288	err = __prestera_k_arb_fc_apply(sw, fib_cache);
289	if (err)
290	dev_err(sw->dev->dev,
291	"Applying destroyed fib_cache failed");
292
293	bfib_cache = __prestera_k_arb_util_fib_overlaps(sw, fib_cache);
294	tfib_cache = __prestera_k_arb_util_fib_overlapped(sw, fib_cache);
295	if (!tfib_cache && bfib_cache) {
296	bfib_cache->reachable = true;
297	err = __prestera_k_arb_fc_apply(sw, bfib_cache);
298	if (err)
299	dev_err(sw->dev->dev,
300	"Applying fib_cache btm failed");
301	}
302
303	prestera_kern_fib_cache_destroy(sw, fib_cache);
304	}
305
306	if (replace) {
307	fib_cache = prestera_kern_fib_cache_create(sw, &fc_key,
308	fen_info->fi,
568a3f33	309	fen_info->dscp,
4394fbcb YO	310	fen_info->type);
	311	if (!fib_cache) {
	312	dev_err(sw->dev->dev, "fib_cache == NULL");
	313	return -ENOENT;
	314	}
	315
	316	bfib_cache = __prestera_k_arb_util_fib_overlaps(sw, fib_cache);
	317	tfib_cache = __prestera_k_arb_util_fib_overlapped(sw, fib_cache);
	318	if (!tfib_cache)
	319	fib_cache->reachable = true;
	320
	321	if (bfib_cache) {
	322	bfib_cache->reachable = false;
	323	err = __prestera_k_arb_fc_apply(sw, bfib_cache);
	324	if (err)
	325	dev_err(sw->dev->dev,
	326	"Applying fib_cache btm failed");
	327	}
	328
	329	err = __prestera_k_arb_fc_apply(sw, fib_cache);
	330	if (err)
	331	dev_err(sw->dev->dev, "Applying fib_cache failed");
	332	}
	333
	334	return 0;
	335	}
	336
da3c1639 YO	337	static int __prestera_inetaddr_port_event(struct net_device *port_dev,
	338	unsigned long event,
	339	struct netlink_ext_ack *extack)
	340	{
	341	struct prestera_port *port = netdev_priv(port_dev);
15fa9e8c	342	struct prestera_rif_entry_key re_key = {};
32d098bb	343	struct prestera_rif_entry *re;
15fa9e8c	344	u32 kern_tb_id;
32d098bb	345	int err;
da3c1639 YO	346
	347	err = prestera_is_valid_mac_addr(port, port_dev->dev_addr);
	348	if (err) {
	349	NL_SET_ERR_MSG_MOD(extack, "RIF MAC must have the same prefix");
	350	return err;
	351	}
	352
15fa9e8c YO	353	kern_tb_id = l3mdev_fib_table(port_dev);
	354	re_key.iface.type = PRESTERA_IF_PORT_E;
	355	re_key.iface.dev_port.hw_dev_num = port->dev_id;
	356	re_key.iface.dev_port.port_num = port->hw_id;
	357	re = prestera_rif_entry_find(port->sw, &re_key);
	358
da3c1639 YO	359	switch (event) {
da3c1639 YO	360	case NETDEV_UP:
15fa9e8c	361	if (re) {
32d098bb	362	NL_SET_ERR_MSG_MOD(extack, "RIF already exist");
15fa9e8c YO	363	return -EEXIST;
	364	}
	365	re = prestera_rif_entry_create(port->sw, &re_key,
	366	prestera_fix_tb_id(kern_tb_id),
	367	port_dev->dev_addr);
	368	if (!re) {
32d098bb	369	NL_SET_ERR_MSG_MOD(extack, "Can't create RIF");
15fa9e8c YO	370	return -EINVAL;
	371	}
	372	dev_hold(port_dev);
	373	break;
da3c1639	374	case NETDEV_DOWN:
15fa9e8c	375	if (!re) {
32d098bb	376	NL_SET_ERR_MSG_MOD(extack, "Can't find RIF");
15fa9e8c YO	377	return -EEXIST;
	378	}
	379	prestera_rif_entry_destroy(port->sw, re);
	380	dev_put(port_dev);
da3c1639 YO	381	break;
	382	}
	383
	384	return 0;
	385	}
	386
	387	static int __prestera_inetaddr_event(struct prestera_switch *sw,
	388	struct net_device *dev,
	389	unsigned long event,
	390	struct netlink_ext_ack *extack)
	391	{
32d098bb YO	392	if (!prestera_netdev_check(dev) \|\| netif_is_bridge_port(dev) \|\|
	393	netif_is_lag_port(dev) \|\| netif_is_ovs_port(dev))
	394	return 0;
da3c1639	395
32d098bb	396	return __prestera_inetaddr_port_event(dev, event, extack);
da3c1639 YO	397	}
	398
	399	static int __prestera_inetaddr_cb(struct notifier_block *nb,
	400	unsigned long event, void *ptr)
	401	{
	402	struct in_ifaddr ifa = (struct in_ifaddr )ptr;
	403	struct net_device *dev = ifa->ifa_dev->dev;
	404	struct prestera_router *router = container_of(nb,
	405	struct prestera_router,
	406	inetaddr_nb);
	407	struct in_device *idev;
	408	int err = 0;
	409
	410	if (event != NETDEV_DOWN)
	411	goto out;
	412
	413	/* Ignore if this is not latest address */
	414	idev = __in_dev_get_rtnl(dev);
	415	if (idev && idev->ifa_list)
	416	goto out;
	417
	418	err = __prestera_inetaddr_event(router->sw, dev, event, NULL);
	419	out:
	420	return notifier_from_errno(err);
	421	}
	422
	423	static int __prestera_inetaddr_valid_cb(struct notifier_block *nb,
	424	unsigned long event, void *ptr)
	425	{
	426	struct in_validator_info ivi = (struct in_validator_info )ptr;
	427	struct net_device *dev = ivi->ivi_dev->dev;
	428	struct prestera_router *router = container_of(nb,
	429	struct prestera_router,
	430	inetaddr_valid_nb);
	431	struct in_device *idev;
	432	int err = 0;
	433
	434	if (event != NETDEV_UP)
	435	goto out;
	436
	437	/* Ignore if this is not first address */
	438	idev = __in_dev_get_rtnl(dev);
	439	if (idev && idev->ifa_list)
	440	goto out;
	441
	442	if (ipv4_is_multicast(ivi->ivi_addr)) {
32d098bb YO	443	NL_SET_ERR_MSG_MOD(ivi->extack,
32d098bb YO	444	"Multicast addr on RIF is not supported");
da3c1639 YO	445	err = -EINVAL;
	446	goto out;
	447	}
	448
	449	err = __prestera_inetaddr_event(router->sw, dev, event, ivi->extack);
	450	out:
	451	return notifier_from_errno(err);
	452	}
	453
4394fbcb YO	454	struct prestera_fib_event_work {
	455	struct work_struct work;
	456	struct prestera_switch *sw;
	457	struct fib_entry_notifier_info fen_info;
	458	unsigned long event;
	459	};
	460
	461	static void __prestera_router_fib_event_work(struct work_struct *work)
	462	{
	463	struct prestera_fib_event_work *fib_work =
	464	container_of(work, struct prestera_fib_event_work, work);
	465	struct prestera_switch *sw = fib_work->sw;
	466	int err;
	467
	468	rtnl_lock();
	469
	470	switch (fib_work->event) {
	471	case FIB_EVENT_ENTRY_REPLACE:
	472	err = prestera_k_arb_fib_evt(sw, true, &fib_work->fen_info);
	473	if (err)
	474	goto err_out;
	475
	476	break;
	477	case FIB_EVENT_ENTRY_DEL:
	478	err = prestera_k_arb_fib_evt(sw, false, &fib_work->fen_info);
	479	if (err)
	480	goto err_out;
	481
	482	break;
	483	}
	484
	485	goto out;
	486
	487	err_out:
	488	dev_err(sw->dev->dev, "Error when processing %pI4h/%d",
	489	&fib_work->fen_info.dst,
	490	fib_work->fen_info.dst_len);
	491	out:
	492	fib_info_put(fib_work->fen_info.fi);
	493	rtnl_unlock();
	494	kfree(fib_work);
	495	}
	496
	497	/* Called with rcu_read_lock() */
	498	static int __prestera_router_fib_event(struct notifier_block *nb,
	499	unsigned long event, void *ptr)
	500	{
	501	struct prestera_fib_event_work *fib_work;
	502	struct fib_entry_notifier_info *fen_info;
	503	struct fib_notifier_info *info = ptr;
	504	struct prestera_router *router;
	505
	506	if (info->family != AF_INET)
	507	return NOTIFY_DONE;
	508
	509	router = container_of(nb, struct prestera_router, fib_nb);
	510
	511	switch (event) {
	512	case FIB_EVENT_ENTRY_REPLACE:
	513	case FIB_EVENT_ENTRY_DEL:
	514	fen_info = container_of(info, struct fib_entry_notifier_info,
	515	info);
	516	if (!fen_info->fi)
	517	return NOTIFY_DONE;
518
519	fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
520	if (WARN_ON(!fib_work))
521	return NOTIFY_BAD;
522
523	fib_info_hold(fen_info->fi);
524	fib_work->fen_info = *fen_info;
525	fib_work->event = event;
526	fib_work->sw = router->sw;
527	INIT_WORK(&fib_work->work, __prestera_router_fib_event_work);
528	prestera_queue_work(&fib_work->work);
529	break;
530	default:
531	return NOTIFY_DONE;
532	}
533
534	return NOTIFY_DONE;
535	}
536
69204174 YO	537	int prestera_router_init(struct prestera_switch *sw)
	538	{
	539	struct prestera_router *router;
bca5859b	540	int err;
69204174 YO	541
	542	router = kzalloc(sizeof(*sw->router), GFP_KERNEL);
	543	if (!router)
	544	return -ENOMEM;
	545
	546	sw->router = router;
	547	router->sw = sw;
	548
bca5859b YO	549	err = prestera_router_hw_init(sw);
	550	if (err)
	551	goto err_router_lib_init;
	552
4394fbcb YO	553	err = rhashtable_init(&router->kern_fib_cache_ht,
	554	&__prestera_kern_fib_cache_ht_params);
	555	if (err)
	556	goto err_kern_fib_cache_ht_init;
	557
da3c1639 YO	558	router->inetaddr_valid_nb.notifier_call = __prestera_inetaddr_valid_cb;
	559	err = register_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
	560	if (err)
	561	goto err_register_inetaddr_validator_notifier;
	562
	563	router->inetaddr_nb.notifier_call = __prestera_inetaddr_cb;
	564	err = register_inetaddr_notifier(&router->inetaddr_nb);
	565	if (err)
	566	goto err_register_inetaddr_notifier;
	567
4394fbcb YO	568	router->fib_nb.notifier_call = __prestera_router_fib_event;
	569	err = register_fib_notifier(&init_net, &router->fib_nb,
	570	/* TODO: flush fib entries */ NULL, NULL);
	571	if (err)
	572	goto err_register_fib_notifier;
	573
69204174	574	return 0;
bca5859b	575
4394fbcb YO	576	err_register_fib_notifier:
4394fbcb YO	577	unregister_inetaddr_notifier(&router->inetaddr_nb);
da3c1639 YO	578	err_register_inetaddr_notifier:
	579	unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
	580	err_register_inetaddr_validator_notifier:
4394fbcb YO	581	rhashtable_destroy(&router->kern_fib_cache_ht);
4394fbcb YO	582	err_kern_fib_cache_ht_init:
e179f045	583	prestera_router_hw_fini(sw);
bca5859b YO	584	err_router_lib_init:
	585	kfree(sw->router);
	586	return err;
69204174 YO	587	}
	588
	589	void prestera_router_fini(struct prestera_switch *sw)
	590	{
f946964a	591	unregister_fib_notifier(&init_net, &sw->router->fib_nb);
da3c1639 YO	592	unregister_inetaddr_notifier(&sw->router->inetaddr_nb);
da3c1639 YO	593	unregister_inetaddr_validator_notifier(&sw->router->inetaddr_valid_nb);
4394fbcb	594	rhashtable_destroy(&sw->router->kern_fib_cache_ht);
e179f045	595	prestera_router_hw_fini(sw);
69204174 YO	596	kfree(sw->router);
	597	sw->router = NULL;
	598	}