mirrors
/
linux-stable
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'net-marvell-prestera-add-nexthop-routes-offloading' 

Yevhen Orlov says:

====================
net: marvell: prestera: add nexthop routes offloading

Add support for nexthop routes for Marvell Prestera driver.
Subscribe on NEIGH_UPDATE events.

Add features:
 - Support connected route adding
   e.g.: "ip address add 1.1.1.1/24 dev sw1p1"
   e.g.: "ip route add 6.6.6/24 dev sw1p1"
 - Support nexthop route adding
   e.g.: "ip route add 5.5.5/24 via 1.1.1.2"
 - Support ECMP route adding
   e.g.: "ip route add 5.5.5/24 nexthop via 1.1.1.2 nexthop via 1.1.1.3"
 - Support "offload" and "trap" flags per each nexthop
 - Support "offload" flag for neighbours

Limitations:
 - Only "local" and "main" tables supported
 - Only generic interfaces supported for router (no bridges or vlans)

Flags meaning:
  ip route add 5.5.5/24 nexthop via 2.2.2.2 nexthop via 2.2.2.3
  ip route show
  ...
  5.5.5.0/24 rt_offload
        nexthop via 2.2.2.2 dev sw1p31 weight 1 trap
        nexthop via 2.2.2.3 dev sw1p31 weight 1 trap
  ...
  # When you just add route - lpm entry became occupied
  # in HW ("rt_offload" flag), but related to nexthops neighbours
  # still not resolved ("trap" flag).
  #
  # After some time...
  ip route show
  ...
  5.5.5.0/24 rt_offload
        nexthop via 2.2.2.2 dev sw1p31 weight 1 offload
        nexthop via 2.2.2.3 dev sw1p31 weight 1 offload
  ...
  # You will see, that appropriate neighbours was resolved and nexthop
  # entries occupied in HW too ("offload" flag)

Co-developed-by: Taras Chornyi <tchornyi@marvell.com>
Signed-off-by: Taras Chornyi <tchornyi@marvell.com>
Co-developed-by: Oleksandr Mazur <oleksandr.mazur@plvision.eu>
Signed-off-by: Oleksandr Mazur <oleksandr.mazur@plvision.eu>
Signed-off-by: Yevhen Orlov <yevhen.orlov@plvision.eu>

Changes for v2:
* Add more reviewers in CC
* Check if route nexthop or direct with fib_nh_gw_family instead of fib_nh_scope
  This is needed after,
  747c143072 ("ip: fix dflt addr selection for connected nexthop"),
  because direct route is now with the same scope as nexthop (RT_SCOPE_LINK)

Changes for v3:
* Resolve "unused functions" warnings, after
  patch ("net: marvell: prestera: Add heplers to interact ... "), and before
  patch ("net: marvell: prestera: Add neighbour cache accounting")

Changes for v4:
* Rebase to the latest master to resolve patch applying issues

Changes for v5:
* Repack structures to prevent holes
* Remove unused variables
* Fix misspeling issues

Changes for v6:
* Rebase on top of master
* Fix smatch warnings

Changes for v7:
* Rebase on top of master
* Refactor: use "fib_lookup" instead of "fib_new_table"+"fib_table_lookup",
  according to Paolo Abeni suggestion
* Refactor: use "rhashtable_free_and_destroy" instead of rhashtable
  walk, according to Paolo Abeni suggestion
====================

Link: https://lore.kernel.org/r/20221001093417.22388-1-yevhen.orlov@plvision.eu
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Jakub Kicinski 2022-10-03 17:14:56 -07:00
parent 899b8cd0d3 ae15ed6e40
commit 46a275a561
7 changed files with 1683 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
drivers/net/ethernet/marvell/prestera/prestera.h
View File

@ -306,17 +306,27 @@ struct prestera_switch {
struct prestera_counter *counter;
u8 lag_member_max;
u8 lag_max;
u32 size_tbl_router_nexthop;
};
struct prestera_router {
struct prestera_switch *sw;
struct list_head vr_list;
struct list_head rif_entry_list;
struct rhashtable nh_neigh_ht;
struct rhashtable nexthop_group_ht;
struct rhashtable fib_ht;
struct rhashtable kern_neigh_cache_ht;
struct rhashtable kern_fib_cache_ht;
struct notifier_block inetaddr_nb;
struct notifier_block inetaddr_valid_nb;
struct notifier_block fib_nb;
struct notifier_block netevent_nb;
u8 *nhgrp_hw_state_cache; /* Bitmap cached hw state of nhs */
unsigned long nhgrp_hw_cache_kick; /* jiffies */
struct {
struct delayed_work dw;
} neighs_update;
};
struct prestera_rxtx_params {
@ -362,6 +372,8 @@ int prestera_port_cfg_mac_write(struct prestera_port *port,
struct prestera_port *prestera_port_dev_lower_find(struct net_device *dev);
void prestera_queue_work(struct work_struct *work);
void prestera_queue_delayed_work(struct delayed_work *work, unsigned long delay);
void prestera_queue_drain(void);
int prestera_port_learning_set(struct prestera_port *port, bool learn_enable);
int prestera_port_uc_flood_set(struct prestera_port *port, bool flood);

130
drivers/net/ethernet/marvell/prestera/prestera_hw.c
View File

@ -10,11 +10,14 @@
#include "prestera_hw.h"
#include "prestera_acl.h"
#include "prestera_counter.h"
#include "prestera_router_hw.h"
#define PRESTERA_SWITCH_INIT_TIMEOUT_MS (30 * 1000)
#define PRESTERA_MIN_MTU 64
#define PRESTERA_MSG_CHUNK_SIZE 1024
enum prestera_cmd_type_t {
PRESTERA_CMD_TYPE_SWITCH_INIT = 0x1,
PRESTERA_CMD_TYPE_SWITCH_ATTR_SET = 0x2,
@ -57,6 +60,10 @@ enum prestera_cmd_type_t {
PRESTERA_CMD_TYPE_ROUTER_RIF_DELETE = 0x601,
PRESTERA_CMD_TYPE_ROUTER_LPM_ADD = 0x610,
PRESTERA_CMD_TYPE_ROUTER_LPM_DELETE = 0x611,
PRESTERA_CMD_TYPE_ROUTER_NH_GRP_SET = 0x622,
PRESTERA_CMD_TYPE_ROUTER_NH_GRP_BLK_GET = 0x645,
PRESTERA_CMD_TYPE_ROUTER_NH_GRP_ADD = 0x623,
PRESTERA_CMD_TYPE_ROUTER_NH_GRP_DELETE = 0x624,
PRESTERA_CMD_TYPE_ROUTER_VR_CREATE = 0x630,
PRESTERA_CMD_TYPE_ROUTER_VR_DELETE = 0x631,
@ -542,6 +549,14 @@ struct prestera_msg_ip_addr {
u8 __pad[3];
};
struct prestera_msg_nh {
struct prestera_msg_iface oif;
__le32 hw_id;
u8 mac[ETH_ALEN];
u8 is_active;
u8 pad;
};
struct prestera_msg_rif_req {
struct prestera_msg_cmd cmd;
struct prestera_msg_iface iif;
@ -567,6 +582,34 @@ struct prestera_msg_lpm_req {
u8 __pad[2];
};
struct prestera_msg_nh_req {
struct prestera_msg_cmd cmd;
struct prestera_msg_nh nh[PRESTERA_NHGR_SIZE_MAX];
__le32 size;
__le32 grp_id;
};
struct prestera_msg_nh_chunk_req {
struct prestera_msg_cmd cmd;
__le32 offset;
};
struct prestera_msg_nh_chunk_resp {
struct prestera_msg_ret ret;
u8 hw_state[PRESTERA_MSG_CHUNK_SIZE];
};
struct prestera_msg_nh_grp_req {
struct prestera_msg_cmd cmd;
__le32 grp_id;
__le32 size;
};
struct prestera_msg_nh_grp_resp {
struct prestera_msg_ret ret;
__le32 grp_id;
};
struct prestera_msg_vr_req {
struct prestera_msg_cmd cmd;
__le16 vr_id;
@ -729,11 +772,15 @@ static void prestera_hw_build_tests(void)
BUILD_BUG_ON(sizeof(struct prestera_msg_flood_domain_ports_reset_req) != 8);
BUILD_BUG_ON(sizeof(struct prestera_msg_mdb_create_req) != 16);
BUILD_BUG_ON(sizeof(struct prestera_msg_mdb_destroy_req) != 16);
BUILD_BUG_ON(sizeof(struct prestera_msg_nh_req) != 124);
BUILD_BUG_ON(sizeof(struct prestera_msg_nh_chunk_req) != 8);
BUILD_BUG_ON(sizeof(struct prestera_msg_nh_grp_req) != 12);
/* structure that are part of req/resp fw messages */
BUILD_BUG_ON(sizeof(struct prestera_msg_iface) != 16);
BUILD_BUG_ON(sizeof(struct prestera_msg_ip_addr) != 20);
BUILD_BUG_ON(sizeof(struct prestera_msg_flood_domain_port) != 12);
BUILD_BUG_ON(sizeof(struct prestera_msg_nh) != 28);
/* check responses */
BUILD_BUG_ON(sizeof(struct prestera_msg_common_resp) != 8);
@ -750,6 +797,8 @@ static void prestera_hw_build_tests(void)
BUILD_BUG_ON(sizeof(struct prestera_msg_vr_resp) != 12);
BUILD_BUG_ON(sizeof(struct prestera_msg_policer_resp) != 12);
BUILD_BUG_ON(sizeof(struct prestera_msg_flood_domain_create_resp) != 12);
BUILD_BUG_ON(sizeof(struct prestera_msg_nh_chunk_resp) != 1032);
BUILD_BUG_ON(sizeof(struct prestera_msg_nh_grp_resp) != 12);
/* check events */
BUILD_BUG_ON(sizeof(struct prestera_msg_event_port) != 20);
@ -1027,6 +1076,8 @@ int prestera_hw_switch_init(struct prestera_switch *sw)
sw->id = resp.switch_id;
sw->lag_member_max = resp.lag_member_max;
sw->lag_max = resp.lag_max;
sw->size_tbl_router_nexthop =
__le32_to_cpu(resp.size_tbl_router_nexthop);
return 0;
}
@ -2037,6 +2088,85 @@ int prestera_hw_lpm_del(struct prestera_switch *sw, u16 vr_id,
sizeof(req));
}
int prestera_hw_nh_entries_set(struct prestera_switch *sw, int count,
struct prestera_neigh_info *nhs, u32 grp_id)
{
struct prestera_msg_nh_req req = { .size = __cpu_to_le32((u32)count),
.grp_id = __cpu_to_le32(grp_id) };
int i, err;
for (i = 0; i < count; i++) {
req.nh[i].is_active = nhs[i].connected;
memcpy(&req.nh[i].mac, nhs[i].ha, ETH_ALEN);
err = prestera_iface_to_msg(&nhs[i].iface, &req.nh[i].oif);
if (err)
return err;
}
return prestera_cmd(sw, PRESTERA_CMD_TYPE_ROUTER_NH_GRP_SET, &req.cmd,
sizeof(req));
}
int prestera_hw_nhgrp_blk_get(struct prestera_switch *sw,
u8 *hw_state, u32 buf_size /* Buffer in bytes */)
{
static struct prestera_msg_nh_chunk_resp resp;
struct prestera_msg_nh_chunk_req req;
u32 buf_offset;
int err;
memset(&hw_state[0], 0, buf_size);
buf_offset = 0;
while (1) {
if (buf_offset >= buf_size)
break;
memset(&req, 0, sizeof(req));
req.offset = __cpu_to_le32(buf_offset * 8); /* 8 bits in u8 */
err = prestera_cmd_ret(sw,
PRESTERA_CMD_TYPE_ROUTER_NH_GRP_BLK_GET,
&req.cmd, sizeof(req), &resp.ret,
sizeof(resp));
if (err)
return err;
memcpy(&hw_state[buf_offset], &resp.hw_state[0],
buf_offset + PRESTERA_MSG_CHUNK_SIZE > buf_size ?
buf_size - buf_offset : PRESTERA_MSG_CHUNK_SIZE);
buf_offset += PRESTERA_MSG_CHUNK_SIZE;
}
return 0;
}
int prestera_hw_nh_group_create(struct prestera_switch *sw, u16 nh_count,
u32 *grp_id)
{
struct prestera_msg_nh_grp_req req = { .size = __cpu_to_le32((u32)nh_count) };
struct prestera_msg_nh_grp_resp resp;
int err;
err = prestera_cmd_ret(sw, PRESTERA_CMD_TYPE_ROUTER_NH_GRP_ADD,
&req.cmd, sizeof(req), &resp.ret, sizeof(resp));
if (err)
return err;
*grp_id = __le32_to_cpu(resp.grp_id);
return err;
}
int prestera_hw_nh_group_delete(struct prestera_switch *sw, u16 nh_count,
u32 grp_id)
{
struct prestera_msg_nh_grp_req req = {
.grp_id = __cpu_to_le32(grp_id),
.size = __cpu_to_le32(nh_count)
};
return prestera_cmd(sw, PRESTERA_CMD_TYPE_ROUTER_NH_GRP_DELETE,
&req.cmd, sizeof(req));
}
int prestera_hw_rxtx_init(struct prestera_switch *sw,
struct prestera_rxtx_params *params)
{

11
drivers/net/ethernet/marvell/prestera/prestera_hw.h
View File

@ -146,6 +146,7 @@ struct prestera_counter_stats;
struct prestera_iface;
struct prestera_flood_domain;
struct prestera_mdb_entry;
struct prestera_neigh_info;
/* Switch API */
int prestera_hw_switch_init(struct prestera_switch *sw);
@ -266,6 +267,16 @@ int prestera_hw_lpm_add(struct prestera_switch *sw, u16 vr_id,
int prestera_hw_lpm_del(struct prestera_switch *sw, u16 vr_id,
__be32 dst, u32 dst_len);
/* NH API */
int prestera_hw_nh_entries_set(struct prestera_switch *sw, int count,
struct prestera_neigh_info *nhs, u32 grp_id);
int prestera_hw_nhgrp_blk_get(struct prestera_switch *sw,
u8 *hw_state, u32 buf_size /* Buffer in bytes */);
int prestera_hw_nh_group_create(struct prestera_switch *sw, u16 nh_count,
u32 *grp_id);
int prestera_hw_nh_group_delete(struct prestera_switch *sw, u16 nh_count,
u32 grp_id);
/* Event handlers */
int prestera_hw_event_handler_register(struct prestera_switch *sw,
enum prestera_event_type type,

11
drivers/net/ethernet/marvell/prestera/prestera_main.c
View File

@ -36,6 +36,17 @@ void prestera_queue_work(struct work_struct *work)
queue_work(prestera_owq, work);
}
void prestera_queue_delayed_work(struct delayed_work *work, unsigned long delay)
{
queue_delayed_work(prestera_wq, work, delay);
}
void prestera_queue_drain(void)
{
drain_workqueue(prestera_wq);
drain_workqueue(prestera_owq);
}
int prestera_port_learning_set(struct prestera_port *port, bool learn)
{
return prestera_hw_port_learning_set(port, learn);

1119
drivers/net/ethernet/marvell/prestera/prestera_router.c
View File

File diff suppressed because it is too large Load Diff

366
drivers/net/ethernet/marvell/prestera/prestera_router_hw.c
View File

@ -8,10 +8,16 @@
#include "prestera_router_hw.h"
#include "prestera_acl.h"
/* +--+
* +------->|vr|<-+
* | +--+ |
* | |
/* Nexthop is pointed
* to port (not rif)
* +-------+
* +>|nexthop|
* | +-------+
* |
* +--+ +-----++
* +------->|vr|<-+ +>|nh_grp|
* | +--+ | | +------+
* | | |
* +-+-------+ +--+---+-+
* |rif_entry| |fib_node|
* +---------+ +--------+
@ -23,6 +29,8 @@
#define PRESTERA_NHGR_UNUSED (0)
#define PRESTERA_NHGR_DROP (0xFFFFFFFF)
/* Need to merge it with router_manager */
#define PRESTERA_NH_ACTIVE_JIFFER_FILTER 3000 /* ms */
static const struct rhashtable_params __prestera_fib_ht_params = {
.key_offset = offsetof(struct prestera_fib_node, key),
@ -31,10 +39,45 @@ static const struct rhashtable_params __prestera_fib_ht_params = {
.automatic_shrinking = true,
};
static const struct rhashtable_params __prestera_nh_neigh_ht_params = {
.key_offset = offsetof(struct prestera_nh_neigh, key),
.key_len = sizeof(struct prestera_nh_neigh_key),
.head_offset = offsetof(struct prestera_nh_neigh, ht_node),
};
static const struct rhashtable_params __prestera_nexthop_group_ht_params = {
.key_offset = offsetof(struct prestera_nexthop_group, key),
.key_len = sizeof(struct prestera_nexthop_group_key),
.head_offset = offsetof(struct prestera_nexthop_group, ht_node),
};
static int prestera_nexthop_group_set(struct prestera_switch *sw,
struct prestera_nexthop_group *nh_grp);
static bool
prestera_nexthop_group_util_hw_state(struct prestera_switch *sw,
struct prestera_nexthop_group *nh_grp);
static void prestera_fib_node_destroy_ht_cb(void *ptr, void *arg);
/* TODO: move to router.h as macros */
static bool prestera_nh_neigh_key_is_valid(struct prestera_nh_neigh_key *key)
{
return memchr_inv(key, 0, sizeof(*key)) ? true : false;
}
int prestera_router_hw_init(struct prestera_switch *sw)
{
int err;
err = rhashtable_init(&sw->router->nh_neigh_ht,
&__prestera_nh_neigh_ht_params);
if (err)
goto err_nh_neigh_ht_init;
err = rhashtable_init(&sw->router->nexthop_group_ht,
&__prestera_nexthop_group_ht_params);
if (err)
goto err_nexthop_grp_ht_init;
err = rhashtable_init(&sw->router->fib_ht,
&__prestera_fib_ht_params);
if (err)
@ -43,15 +86,25 @@ int prestera_router_hw_init(struct prestera_switch *sw)
INIT_LIST_HEAD(&sw->router->vr_list);
INIT_LIST_HEAD(&sw->router->rif_entry_list);
return 0;
err_fib_ht_init:
rhashtable_destroy(&sw->router->nexthop_group_ht);
err_nexthop_grp_ht_init:
rhashtable_destroy(&sw->router->nh_neigh_ht);
err_nh_neigh_ht_init:
return 0;
}
void prestera_router_hw_fini(struct prestera_switch *sw)
{
rhashtable_free_and_destroy(&sw->router->fib_ht,
prestera_fib_node_destroy_ht_cb, sw);
WARN_ON(!list_empty(&sw->router->vr_list));
WARN_ON(!list_empty(&sw->router->rif_entry_list));
rhashtable_destroy(&sw->router->fib_ht);
rhashtable_destroy(&sw->router->nexthop_group_ht);
rhashtable_destroy(&sw->router->nh_neigh_ht);
}
static struct prestera_vr *__prestera_vr_find(struct prestera_switch *sw,
@ -232,6 +285,286 @@ err_kzalloc:
return NULL;
}
static void __prestera_nh_neigh_destroy(struct prestera_switch *sw,
struct prestera_nh_neigh *neigh)
{
rhashtable_remove_fast(&sw->router->nh_neigh_ht,
&neigh->ht_node,
__prestera_nh_neigh_ht_params);
kfree(neigh);
}
static struct prestera_nh_neigh *
__prestera_nh_neigh_create(struct prestera_switch *sw,
struct prestera_nh_neigh_key *key)
{
struct prestera_nh_neigh *neigh;
int err;
neigh = kzalloc(sizeof(*neigh), GFP_KERNEL);
if (!neigh)
goto err_kzalloc;
memcpy(&neigh->key, key, sizeof(*key));
neigh->info.connected = false;
INIT_LIST_HEAD(&neigh->nexthop_group_list);
err = rhashtable_insert_fast(&sw->router->nh_neigh_ht,
&neigh->ht_node,
__prestera_nh_neigh_ht_params);
if (err)
goto err_rhashtable_insert;
return neigh;
err_rhashtable_insert:
kfree(neigh);
err_kzalloc:
return NULL;
}
struct prestera_nh_neigh *
prestera_nh_neigh_find(struct prestera_switch *sw,
struct prestera_nh_neigh_key *key)
{
struct prestera_nh_neigh *nh_neigh;
nh_neigh = rhashtable_lookup_fast(&sw->router->nh_neigh_ht,
key, __prestera_nh_neigh_ht_params);
return IS_ERR(nh_neigh) ? NULL : nh_neigh;
}
struct prestera_nh_neigh *
prestera_nh_neigh_get(struct prestera_switch *sw,
struct prestera_nh_neigh_key *key)
{
struct prestera_nh_neigh *neigh;
neigh = prestera_nh_neigh_find(sw, key);
if (!neigh)
return __prestera_nh_neigh_create(sw, key);
return neigh;
}
void prestera_nh_neigh_put(struct prestera_switch *sw,
struct prestera_nh_neigh *neigh)
{
if (list_empty(&neigh->nexthop_group_list))
__prestera_nh_neigh_destroy(sw, neigh);
}
/* Updates new prestera_neigh_info */
int prestera_nh_neigh_set(struct prestera_switch *sw,
struct prestera_nh_neigh *neigh)
{
struct prestera_nh_neigh_head *nh_head;
struct prestera_nexthop_group *nh_grp;
int err;
list_for_each_entry(nh_head, &neigh->nexthop_group_list, head) {
nh_grp = nh_head->this;
err = prestera_nexthop_group_set(sw, nh_grp);
if (err)
return err;
}
return 0;
}
bool prestera_nh_neigh_util_hw_state(struct prestera_switch *sw,
struct prestera_nh_neigh *nh_neigh)
{
bool state;
struct prestera_nh_neigh_head *nh_head, *tmp;
state = false;
list_for_each_entry_safe(nh_head, tmp,
&nh_neigh->nexthop_group_list, head) {
state = prestera_nexthop_group_util_hw_state(sw, nh_head->this);
if (state)
goto out;
}
out:
return state;
}
static struct prestera_nexthop_group *
__prestera_nexthop_group_create(struct prestera_switch *sw,
struct prestera_nexthop_group_key *key)
{
struct prestera_nexthop_group *nh_grp;
struct prestera_nh_neigh *nh_neigh;
int nh_cnt, err, gid;
nh_grp = kzalloc(sizeof(*nh_grp), GFP_KERNEL);
if (!nh_grp)
goto err_kzalloc;
memcpy(&nh_grp->key, key, sizeof(*key));
for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {
if (!prestera_nh_neigh_key_is_valid(&nh_grp->key.neigh[nh_cnt]))
break;
nh_neigh = prestera_nh_neigh_get(sw,
&nh_grp->key.neigh[nh_cnt]);
if (!nh_neigh)
goto err_nh_neigh_get;
nh_grp->nh_neigh_head[nh_cnt].neigh = nh_neigh;
nh_grp->nh_neigh_head[nh_cnt].this = nh_grp;
list_add(&nh_grp->nh_neigh_head[nh_cnt].head,
&nh_neigh->nexthop_group_list);
}
err = prestera_hw_nh_group_create(sw, nh_cnt, &nh_grp->grp_id);
if (err)
goto err_nh_group_create;
err = prestera_nexthop_group_set(sw, nh_grp);
if (err)
goto err_nexthop_group_set;
err = rhashtable_insert_fast(&sw->router->nexthop_group_ht,
&nh_grp->ht_node,
__prestera_nexthop_group_ht_params);
if (err)
goto err_ht_insert;
/* reset cache for created group */
gid = nh_grp->grp_id;
sw->router->nhgrp_hw_state_cache[gid / 8] &= ~BIT(gid % 8);
return nh_grp;
err_ht_insert:
err_nexthop_group_set:
prestera_hw_nh_group_delete(sw, nh_cnt, nh_grp->grp_id);
err_nh_group_create:
err_nh_neigh_get:
for (nh_cnt--; nh_cnt >= 0; nh_cnt--) {
list_del(&nh_grp->nh_neigh_head[nh_cnt].head);
prestera_nh_neigh_put(sw, nh_grp->nh_neigh_head[nh_cnt].neigh);
}
kfree(nh_grp);
err_kzalloc:
return NULL;
}
static void
__prestera_nexthop_group_destroy(struct prestera_switch *sw,
struct prestera_nexthop_group *nh_grp)
{
struct prestera_nh_neigh *nh_neigh;
int nh_cnt;
rhashtable_remove_fast(&sw->router->nexthop_group_ht,
&nh_grp->ht_node,
__prestera_nexthop_group_ht_params);
for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {
nh_neigh = nh_grp->nh_neigh_head[nh_cnt].neigh;
if (!nh_neigh)
break;
list_del(&nh_grp->nh_neigh_head[nh_cnt].head);
prestera_nh_neigh_put(sw, nh_neigh);
}
prestera_hw_nh_group_delete(sw, nh_cnt, nh_grp->grp_id);
kfree(nh_grp);
}
static struct prestera_nexthop_group *
__prestera_nexthop_group_find(struct prestera_switch *sw,
struct prestera_nexthop_group_key *key)
{
struct prestera_nexthop_group *nh_grp;
nh_grp = rhashtable_lookup_fast(&sw->router->nexthop_group_ht,
key, __prestera_nexthop_group_ht_params);
return IS_ERR(nh_grp) ? NULL : nh_grp;
}
static struct prestera_nexthop_group *
prestera_nexthop_group_get(struct prestera_switch *sw,
struct prestera_nexthop_group_key *key)
{
struct prestera_nexthop_group *nh_grp;
nh_grp = __prestera_nexthop_group_find(sw, key);
if (nh_grp) {
refcount_inc(&nh_grp->refcount);
} else {
nh_grp = __prestera_nexthop_group_create(sw, key);
if (IS_ERR(nh_grp))
return ERR_CAST(nh_grp);
refcount_set(&nh_grp->refcount, 1);
}
return nh_grp;
}
static void prestera_nexthop_group_put(struct prestera_switch *sw,
struct prestera_nexthop_group *nh_grp)
{
if (refcount_dec_and_test(&nh_grp->refcount))
__prestera_nexthop_group_destroy(sw, nh_grp);
}
/* Updates with new nh_neigh's info */
static int prestera_nexthop_group_set(struct prestera_switch *sw,
struct prestera_nexthop_group *nh_grp)
{
struct prestera_neigh_info info[PRESTERA_NHGR_SIZE_MAX];
struct prestera_nh_neigh *neigh;
int nh_cnt;
memset(&info[0], 0, sizeof(info));
for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {
neigh = nh_grp->nh_neigh_head[nh_cnt].neigh;
if (!neigh)
break;
memcpy(&info[nh_cnt], &neigh->info, sizeof(neigh->info));
}
return prestera_hw_nh_entries_set(sw, nh_cnt, &info[0], nh_grp->grp_id);
}
static bool
prestera_nexthop_group_util_hw_state(struct prestera_switch *sw,
struct prestera_nexthop_group *nh_grp)
{
int err;
u32 buf_size = sw->size_tbl_router_nexthop / 8 + 1;
u32 gid = nh_grp->grp_id;
u8 *cache = sw->router->nhgrp_hw_state_cache;
/* Antijitter
* Prevent situation, when we read state of nh_grp twice in short time,
* and state bit is still cleared on second call. So just stuck active
* state for PRESTERA_NH_ACTIVE_JIFFER_FILTER, after last occurred.
*/
if (!time_before(jiffies, sw->router->nhgrp_hw_cache_kick +
msecs_to_jiffies(PRESTERA_NH_ACTIVE_JIFFER_FILTER))) {
err = prestera_hw_nhgrp_blk_get(sw, cache, buf_size);
if (err) {
pr_err("Failed to get hw state nh_grp's");
return false;
}
sw->router->nhgrp_hw_cache_kick = jiffies;
}
if (cache[gid / 8] & BIT(gid % 8))
return true;
return false;
}
struct prestera_fib_node *
prestera_fib_node_find(struct prestera_switch *sw, struct prestera_fib_key *key)
{
@ -251,6 +584,9 @@ static void __prestera_fib_node_destruct(struct prestera_switch *sw,
prestera_hw_lpm_del(sw, vr->hw_vr_id, fib_node->key.addr.u.ipv4,
fib_node->key.prefix_len);
switch (fib_node->info.type) {
case PRESTERA_FIB_TYPE_UC_NH:
prestera_nexthop_group_put(sw, fib_node->info.nh_grp);
break;
case PRESTERA_FIB_TYPE_TRAP:
break;
case PRESTERA_FIB_TYPE_DROP:
@ -272,10 +608,20 @@ void prestera_fib_node_destroy(struct prestera_switch *sw,
kfree(fib_node);
}
static void prestera_fib_node_destroy_ht_cb(void *ptr, void *arg)
{
struct prestera_fib_node *node = ptr;
struct prestera_switch *sw = arg;
__prestera_fib_node_destruct(sw, node);
kfree(node);
}
struct prestera_fib_node *
prestera_fib_node_create(struct prestera_switch *sw,
struct prestera_fib_key *key,
enum prestera_fib_type fib_type)
enum prestera_fib_type fib_type,
struct prestera_nexthop_group_key *nh_grp_key)
{
struct prestera_fib_node *fib_node;
u32 grp_id;
@ -302,6 +648,14 @@ prestera_fib_node_create(struct prestera_switch *sw,
case PRESTERA_FIB_TYPE_DROP:
grp_id = PRESTERA_NHGR_DROP;
break;
case PRESTERA_FIB_TYPE_UC_NH:
fib_node->info.nh_grp = prestera_nexthop_group_get(sw,
nh_grp_key);
if (!fib_node->info.nh_grp)
goto err_nh_grp_get;
grp_id = fib_node->info.nh_grp->grp_id;
break;
default:
pr_err("Unsupported fib_type %d", fib_type);
goto err_nh_grp_get;
@ -323,6 +677,8 @@ err_ht_insert:
prestera_hw_lpm_del(sw, vr->hw_vr_id, key->addr.u.ipv4,
key->prefix_len);
err_lpm_add:
if (fib_type == PRESTERA_FIB_TYPE_UC_NH)
prestera_nexthop_group_put(sw, fib_node->info.nh_grp);
err_nh_grp_get:
prestera_vr_put(sw, vr);
err_vr_get:

76
drivers/net/ethernet/marvell/prestera/prestera_router_hw.h
View File

@ -31,6 +31,63 @@ struct prestera_ip_addr {
PRESTERA_IPV4 = 0,
PRESTERA_IPV6
} v;
#define PRESTERA_IP_ADDR_PLEN(V) ((V) == PRESTERA_IPV4 ? 32 : \
/* (V) == PRESTERA_IPV6 ? */ 128 /* : 0 */)
};
struct prestera_nh_neigh_key {
struct prestera_ip_addr addr;
/* Seems like rif is obsolete, because there is iface in info ?
* Key can contain functional fields, or fields, which is used to
* filter duplicate objects on logical level (before you pass it to
* HW)... also key can be used to cover hardware restrictions.
* In our case rif - is logical interface (even can be VLAN), which
* is used in combination with IP address (which is also not related to
* hardware nexthop) to provide logical compression of created nexthops.
* You even can imagine, that rif+IPaddr is just cookie.
*/
/* struct prestera_rif *rif; */
/* Use just as cookie, to divide ARP domains (in order with addr) */
void *rif;
};
/* Used for hw call */
struct prestera_neigh_info {
struct prestera_iface iface;
unsigned char ha[ETH_ALEN];
u8 connected; /* bool. indicate, if mac/oif valid */
u8 __pad[1];
};
/* Used to notify nh about neigh change */
struct prestera_nh_neigh {
struct prestera_nh_neigh_key key;
struct prestera_neigh_info info;
struct rhash_head ht_node; /* node of prestera_vr */
struct list_head nexthop_group_list;
};
#define PRESTERA_NHGR_SIZE_MAX 4
struct prestera_nexthop_group {
struct prestera_nexthop_group_key {
struct prestera_nh_neigh_key neigh[PRESTERA_NHGR_SIZE_MAX];
} key;
/* Store intermediate object here.
* This prevent overhead kzalloc call.
*/
/* nh_neigh is used only to notify nexthop_group */
struct prestera_nh_neigh_head {
struct prestera_nexthop_group *this;
struct list_head head;
/* ptr to neigh is not necessary.
* It used to prevent lookup of nh_neigh by key (n) on destroy
*/
struct prestera_nh_neigh *neigh;
} nh_neigh_head[PRESTERA_NHGR_SIZE_MAX];
struct rhash_head ht_node; /* node of prestera_vr */
refcount_t refcount;
u32 grp_id; /* hw */
};
struct prestera_fib_key {
@ -44,12 +101,16 @@ struct prestera_fib_info {
struct list_head vr_node;
enum prestera_fib_type {
PRESTERA_FIB_TYPE_INVALID = 0,
/* must be pointer to nh_grp id */
PRESTERA_FIB_TYPE_UC_NH,
/* It can be connected route
* and will be overlapped with neighbours
*/
PRESTERA_FIB_TYPE_TRAP,
PRESTERA_FIB_TYPE_DROP
} type;
/* Valid only if type = UC_NH*/
struct prestera_nexthop_group *nh_grp;
};
struct prestera_fib_node {
@ -67,6 +128,18 @@ struct prestera_rif_entry *
prestera_rif_entry_create(struct prestera_switch *sw,
struct prestera_rif_entry_key *k,
u32 tb_id, const unsigned char *addr);
struct prestera_nh_neigh *
prestera_nh_neigh_find(struct prestera_switch *sw,
struct prestera_nh_neigh_key *key);
struct prestera_nh_neigh *
prestera_nh_neigh_get(struct prestera_switch *sw,
struct prestera_nh_neigh_key *key);
void prestera_nh_neigh_put(struct prestera_switch *sw,
struct prestera_nh_neigh *neigh);
int prestera_nh_neigh_set(struct prestera_switch *sw,
struct prestera_nh_neigh *neigh);
bool prestera_nh_neigh_util_hw_state(struct prestera_switch *sw,
struct prestera_nh_neigh *nh_neigh);
struct prestera_fib_node *prestera_fib_node_find(struct prestera_switch *sw,
struct prestera_fib_key *key);
void prestera_fib_node_destroy(struct prestera_switch *sw,
@ -74,7 +147,8 @@ void prestera_fib_node_destroy(struct prestera_switch *sw,
struct prestera_fib_node *
prestera_fib_node_create(struct prestera_switch *sw,
struct prestera_fib_key *key,
enum prestera_fib_type fib_type);
enum prestera_fib_type fib_type,
struct prestera_nexthop_group_key *nh_grp_key);
int prestera_router_hw_init(struct prestera_switch *sw);
void prestera_router_hw_fini(struct prestera_switch *sw);