nexthop: Add support for nexthop groups
Allow the creation of nexthop groups which reference other nexthop
objects to create multipath routes:
+--------------+
+------------+ +--------------+ |
| nh nh_grp --->| nh_grp_entry |-+
+------------+ +---------|----+
^ | | +------------+
+----------------+ +--->| nh, weight |
nh_parent +------------+
A group entry points to a nexthop with a weight for that hop within the
group. The nexthop has a list_head, grp_list, for tracking which groups
it is a member of and the group entry has a reference back to the parent.
The grp_list is used when a nexthop is deleted - to efficiently remove
it from groups using it.
If a nexthop group spec is given, no other attributes can be set. Each
nexthop id in a group spec must already exist.
Similar to single nexthops, the specification of a nexthop group can be
updated so that data is managed with rcu locking.
Add path selection function to account for multiple paths and add
ipv{4,6}_good_nh helpers to know that if a neighbor entry exists it is
in a good state.
Update NETDEV event handling to rebalance multipath nexthop groups if
a nexthop is deleted due to a link event (down or unregister).
When a nexthop is removed any groups using it are updated. Groups using a
nexthop a tracked via a grp_list.
Nexthop dumps can be limited to groups only by adding NHA_GROUPS to the
request.
Signed-off-by: David Ahern <dsahern@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David Ahern
David S. Miller
parent
b513bd035f
commit
430a049190
|
|
@ -35,6 +35,9 @@ struct nh_config {
|
|||
struct in6_addr ipv6;
|
||||
} gw;
|
||||
|
||||
struct nlattr *nh_grp;
|
||||
u16 nh_grp_type;
|
||||
|
||||
struct nlattr *nh_encap;
|
||||
u16 nh_encap_type;
|
||||
|
||||
|
|
@ -56,20 +59,39 @@ struct nh_info {
|
|||
};
|
||||
};
|
||||
|
||||
struct nh_grp_entry {
|
||||
struct nexthop *nh;
|
||||
u8 weight;
|
||||
atomic_t upper_bound;
|
||||
|
||||
struct list_head nh_list;
|
||||
struct nexthop *nh_parent; /* nexthop of group with this entry */
|
||||
};
|
||||
|
||||
struct nh_group {
|
||||
u16 num_nh;
|
||||
bool mpath;
|
||||
bool has_v4;
|
||||
struct nh_grp_entry nh_entries[0];
|
||||
};
|
||||
|
||||
struct nexthop {
|
||||
struct rb_node rb_node; /* entry on netns rbtree */
|
||||
struct list_head grp_list; /* nh group entries using this nh */
|
||||
struct net *net;
|
||||
|
||||
u32 id;
|
||||
|
||||
u8 protocol; /* app managing this nh */
|
||||
u8 nh_flags;
|
||||
bool is_group;
|
||||
|
||||
refcount_t refcnt;
|
||||
struct rcu_head rcu;
|
||||
|
||||
union {
|
||||
struct nh_info __rcu *nh_info;
|
||||
struct nh_group __rcu *nh_grp;
|
||||
};
|
||||
};
|
||||
|
||||
|
|
@ -88,12 +110,86 @@ static inline void nexthop_put(struct nexthop *nh)
|
|||
call_rcu(&nh->rcu, nexthop_free_rcu);
|
||||
}
|
||||
|
||||
static inline bool nexthop_is_multipath(const struct nexthop *nh)
|
||||
{
|
||||
if (nh->is_group) {
|
||||
struct nh_group *nh_grp;
|
||||
|
||||
nh_grp = rcu_dereference_rtnl(nh->nh_grp);
|
||||
return nh_grp->mpath;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
struct nexthop *nexthop_select_path(struct nexthop *nh, int hash);
|
||||
|
||||
static inline unsigned int nexthop_num_path(const struct nexthop *nh)
|
||||
{
|
||||
unsigned int rc = 1;
|
||||
|
||||
if (nexthop_is_multipath(nh)) {
|
||||
struct nh_group *nh_grp;
|
||||
|
||||
nh_grp = rcu_dereference_rtnl(nh->nh_grp);
|
||||
rc = nh_grp->num_nh;
|
||||
} else {
|
||||
const struct nh_info *nhi;
|
||||
|
||||
nhi = rcu_dereference_rtnl(nh->nh_info);
|
||||
if (nhi->reject_nh)
|
||||
rc = 0;
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
static inline
|
||||
struct nexthop *nexthop_mpath_select(const struct nexthop *nh, int nhsel)
|
||||
{
|
||||
const struct nh_group *nhg = rcu_dereference_rtnl(nh->nh_grp);
|
||||
|
||||
/* for_nexthops macros in fib_semantics.c grabs a pointer to
|
||||
* the nexthop before checking nhsel
|
||||
*/
|
||||
if (nhsel > nhg->num_nh)
|
||||
return NULL;
|
||||
|
||||
return nhg->nh_entries[nhsel].nh;
|
||||
}
|
||||
|
||||
static inline
|
||||
int nexthop_mpath_fill_node(struct sk_buff *skb, struct nexthop *nh)
|
||||
{
|
||||
struct nh_group *nhg = rtnl_dereference(nh->nh_grp);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < nhg->num_nh; i++) {
|
||||
struct nexthop *nhe = nhg->nh_entries[i].nh;
|
||||
struct nh_info *nhi = rcu_dereference_rtnl(nhe->nh_info);
|
||||
struct fib_nh_common *nhc = &nhi->fib_nhc;
|
||||
int weight = nhg->nh_entries[i].weight;
|
||||
|
||||
if (fib_add_nexthop(skb, nhc, weight) < 0)
|
||||
return -EMSGSIZE;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* called with rcu lock */
|
||||
static inline bool nexthop_is_blackhole(const struct nexthop *nh)
|
||||
{
|
||||
const struct nh_info *nhi;
|
||||
|
||||
nhi = rcu_dereference(nh->nh_info);
|
||||
if (nexthop_is_multipath(nh)) {
|
||||
if (nexthop_num_path(nh) > 1)
|
||||
return false;
|
||||
nh = nexthop_mpath_select(nh, 0);
|
||||
if (!nh)
|
||||
return false;
|
||||
}
|
||||
|
||||
nhi = rcu_dereference_rtnl(nh->nh_info);
|
||||
return nhi->reject_nh;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -8,12 +8,17 @@
|
|||
#include <linux/nexthop.h>
|
||||
#include <linux/rtnetlink.h>
|
||||
#include <linux/slab.h>
|
||||
#include <net/arp.h>
|
||||
#include <net/ipv6_stubs.h>
|
||||
#include <net/lwtunnel.h>
|
||||
#include <net/ndisc.h>
|
||||
#include <net/nexthop.h>
|
||||
#include <net/route.h>
|
||||
#include <net/sock.h>
|
||||
|
||||
static void remove_nexthop(struct net *net, struct nexthop *nh,
|
||||
struct nl_info *nlinfo);
|
||||
|
||||
#define NH_DEV_HASHBITS 8
|
||||
#define NH_DEV_HASHSIZE (1U << NH_DEV_HASHBITS)
|
||||
|
||||
|
|
@ -53,9 +58,20 @@ static void nexthop_devhash_add(struct net *net, struct nh_info *nhi)
|
|||
hlist_add_head(&nhi->dev_hash, head);
|
||||
}
|
||||
|
||||
void nexthop_free_rcu(struct rcu_head *head)
|
||||
static void nexthop_free_mpath(struct nexthop *nh)
|
||||
{
|
||||
struct nh_group *nhg;
|
||||
int i;
|
||||
|
||||
nhg = rcu_dereference_raw(nh->nh_grp);
|
||||
for (i = 0; i < nhg->num_nh; ++i)
|
||||
WARN_ON(nhg->nh_entries[i].nh);
|
||||
|
||||
kfree(nhg);
|
||||
}
|
||||
|
||||
static void nexthop_free_single(struct nexthop *nh)
|
||||
{
|
||||
struct nexthop *nh = container_of(head, struct nexthop, rcu);
|
||||
struct nh_info *nhi;
|
||||
|
||||
nhi = rcu_dereference_raw(nh->nh_info);
|
||||
|
|
@ -68,6 +84,16 @@ void nexthop_free_rcu(struct rcu_head *head)
|
|||
break;
|
||||
}
|
||||
kfree(nhi);
|
||||
}
|
||||
|
||||
void nexthop_free_rcu(struct rcu_head *head)
|
||||
{
|
||||
struct nexthop *nh = container_of(head, struct nexthop, rcu);
|
||||
|
||||
if (nh->is_group)
|
||||
nexthop_free_mpath(nh);
|
||||
else
|
||||
nexthop_free_single(nh);
|
||||
|
||||
kfree(nh);
|
||||
}
|
||||
|
|
@ -78,9 +104,26 @@ static struct nexthop *nexthop_alloc(void)
|
|||
struct nexthop *nh;
|
||||
|
||||
nh = kzalloc(sizeof(struct nexthop), GFP_KERNEL);
|
||||
if (nh) {
|
||||
INIT_LIST_HEAD(&nh->grp_list);
|
||||
}
|
||||
return nh;
|
||||
}
|
||||
|
||||
static struct nh_group *nexthop_grp_alloc(u16 num_nh)
|
||||
{
|
||||
size_t sz = offsetof(struct nexthop, nh_grp)
|
||||
+ sizeof(struct nh_group)
|
||||
+ sizeof(struct nh_grp_entry) * num_nh;
|
||||
struct nh_group *nhg;
|
||||
|
||||
nhg = kzalloc(sz, GFP_KERNEL);
|
||||
if (nhg)
|
||||
nhg->num_nh = num_nh;
|
||||
|
||||
return nhg;
|
||||
}
|
||||
|
||||
static void nh_base_seq_inc(struct net *net)
|
||||
{
|
||||
while (++net->nexthop.seq == 0)
|
||||
|
|
@ -129,6 +172,37 @@ static u32 nh_find_unused_id(struct net *net)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int nla_put_nh_group(struct sk_buff *skb, struct nh_group *nhg)
|
||||
{
|
||||
struct nexthop_grp *p;
|
||||
size_t len = nhg->num_nh * sizeof(*p);
|
||||
struct nlattr *nla;
|
||||
u16 group_type = 0;
|
||||
int i;
|
||||
|
||||
if (nhg->mpath)
|
||||
group_type = NEXTHOP_GRP_TYPE_MPATH;
|
||||
|
||||
if (nla_put_u16(skb, NHA_GROUP_TYPE, group_type))
|
||||
goto nla_put_failure;
|
||||
|
||||
nla = nla_reserve(skb, NHA_GROUP, len);
|
||||
if (!nla)
|
||||
goto nla_put_failure;
|
||||
|
||||
p = nla_data(nla);
|
||||
for (i = 0; i < nhg->num_nh; ++i) {
|
||||
p->id = nhg->nh_entries[i].nh->id;
|
||||
p->weight = nhg->nh_entries[i].weight - 1;
|
||||
p += 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
nla_put_failure:
|
||||
return -EMSGSIZE;
|
||||
}
|
||||
|
||||
static int nh_fill_node(struct sk_buff *skb, struct nexthop *nh,
|
||||
int event, u32 portid, u32 seq, unsigned int nlflags)
|
||||
{
|
||||
|
|
@ -152,6 +226,14 @@ static int nh_fill_node(struct sk_buff *skb, struct nexthop *nh,
|
|||
if (nla_put_u32(skb, NHA_ID, nh->id))
|
||||
goto nla_put_failure;
|
||||
|
||||
if (nh->is_group) {
|
||||
struct nh_group *nhg = rtnl_dereference(nh->nh_grp);
|
||||
|
||||
if (nla_put_nh_group(skb, nhg))
|
||||
goto nla_put_failure;
|
||||
goto out;
|
||||
}
|
||||
|
||||
nhi = rtnl_dereference(nh->nh_info);
|
||||
nhm->nh_family = nhi->family;
|
||||
if (nhi->reject_nh) {
|
||||
|
|
@ -196,15 +278,24 @@ nla_put_failure:
|
|||
return -EMSGSIZE;
|
||||
}
|
||||
|
||||
static size_t nh_nlmsg_size(struct nexthop *nh)
|
||||
static size_t nh_nlmsg_size_grp(struct nexthop *nh)
|
||||
{
|
||||
struct nh_group *nhg = rtnl_dereference(nh->nh_grp);
|
||||
size_t sz = sizeof(struct nexthop_grp) * nhg->num_nh;
|
||||
|
||||
return nla_total_size(sz) +
|
||||
nla_total_size(2); /* NHA_GROUP_TYPE */
|
||||
}
|
||||
|
||||
static size_t nh_nlmsg_size_single(struct nexthop *nh)
|
||||
{
|
||||
struct nh_info *nhi = rtnl_dereference(nh->nh_info);
|
||||
size_t sz = nla_total_size(4); /* NHA_ID */
|
||||
size_t sz;
|
||||
|
||||
/* covers NHA_BLACKHOLE since NHA_OIF and BLACKHOLE
|
||||
* are mutually exclusive
|
||||
*/
|
||||
sz += nla_total_size(4); /* NHA_OIF */
|
||||
sz = nla_total_size(4); /* NHA_OIF */
|
||||
|
||||
switch (nhi->family) {
|
||||
case AF_INET:
|
||||
|
|
@ -227,6 +318,18 @@ static size_t nh_nlmsg_size(struct nexthop *nh)
|
|||
return sz;
|
||||
}
|
||||
|
||||
static size_t nh_nlmsg_size(struct nexthop *nh)
|
||||
{
|
||||
size_t sz = nla_total_size(4); /* NHA_ID */
|
||||
|
||||
if (nh->is_group)
|
||||
sz += nh_nlmsg_size_grp(nh);
|
||||
else
|
||||
sz += nh_nlmsg_size_single(nh);
|
||||
|
||||
return sz;
|
||||
}
|
||||
|
||||
static void nexthop_notify(int event, struct nexthop *nh, struct nl_info *info)
|
||||
{
|
||||
unsigned int nlflags = info->nlh ? info->nlh->nlmsg_flags : 0;
|
||||
|
|
@ -254,17 +357,274 @@ errout:
|
|||
rtnl_set_sk_err(info->nl_net, RTNLGRP_NEXTHOP, err);
|
||||
}
|
||||
|
||||
static void __remove_nexthop(struct net *net, struct nexthop *nh)
|
||||
static bool valid_group_nh(struct nexthop *nh, unsigned int npaths,
|
||||
struct netlink_ext_ack *extack)
|
||||
{
|
||||
struct nh_info *nhi;
|
||||
if (nh->is_group) {
|
||||
struct nh_group *nhg = rtnl_dereference(nh->nh_grp);
|
||||
|
||||
nhi = rtnl_dereference(nh->nh_info);
|
||||
if (nhi->fib_nhc.nhc_dev)
|
||||
hlist_del(&nhi->dev_hash);
|
||||
/* nested multipath (group within a group) is not
|
||||
* supported
|
||||
*/
|
||||
if (nhg->mpath) {
|
||||
NL_SET_ERR_MSG(extack,
|
||||
"Multipath group can not be a nexthop within a group");
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
struct nh_info *nhi = rtnl_dereference(nh->nh_info);
|
||||
|
||||
if (nhi->reject_nh && npaths > 1) {
|
||||
NL_SET_ERR_MSG(extack,
|
||||
"Blackhole nexthop can not be used in a group with more than 1 path");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static int nh_check_attr_group(struct net *net, struct nlattr *tb[],
|
||||
struct netlink_ext_ack *extack)
|
||||
{
|
||||
unsigned int len = nla_len(tb[NHA_GROUP]);
|
||||
struct nexthop_grp *nhg;
|
||||
unsigned int i, j;
|
||||
|
||||
if (len & (sizeof(struct nexthop_grp) - 1)) {
|
||||
NL_SET_ERR_MSG(extack,
|
||||
"Invalid length for nexthop group attribute");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* convert len to number of nexthop ids */
|
||||
len /= sizeof(*nhg);
|
||||
|
||||
nhg = nla_data(tb[NHA_GROUP]);
|
||||
for (i = 0; i < len; ++i) {
|
||||
if (nhg[i].resvd1 || nhg[i].resvd2) {
|
||||
NL_SET_ERR_MSG(extack, "Reserved fields in nexthop_grp must be 0");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (nhg[i].weight > 254) {
|
||||
NL_SET_ERR_MSG(extack, "Invalid value for weight");
|
||||
return -EINVAL;
|
||||
}
|
||||
for (j = i + 1; j < len; ++j) {
|
||||
if (nhg[i].id == nhg[j].id) {
|
||||
NL_SET_ERR_MSG(extack, "Nexthop id can not be used twice in a group");
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
nhg = nla_data(tb[NHA_GROUP]);
|
||||
for (i = 0; i < len; ++i) {
|
||||
struct nexthop *nh;
|
||||
|
||||
nh = nexthop_find_by_id(net, nhg[i].id);
|
||||
if (!nh) {
|
||||
NL_SET_ERR_MSG(extack, "Invalid nexthop id");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (!valid_group_nh(nh, len, extack))
|
||||
return -EINVAL;
|
||||
}
|
||||
for (i = NHA_GROUP + 1; i < __NHA_MAX; ++i) {
|
||||
if (!tb[i])
|
||||
continue;
|
||||
|
||||
NL_SET_ERR_MSG(extack,
|
||||
"No other attributes can be set in nexthop groups");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool ipv6_good_nh(const struct fib6_nh *nh)
|
||||
{
|
||||
int state = NUD_REACHABLE;
|
||||
struct neighbour *n;
|
||||
|
||||
rcu_read_lock_bh();
|
||||
|
||||
n = __ipv6_neigh_lookup_noref_stub(nh->fib_nh_dev, &nh->fib_nh_gw6);
|
||||
if (n)
|
||||
state = n->nud_state;
|
||||
|
||||
rcu_read_unlock_bh();
|
||||
|
||||
return !!(state & NUD_VALID);
|
||||
}
|
||||
|
||||
static bool ipv4_good_nh(const struct fib_nh *nh)
|
||||
{
|
||||
int state = NUD_REACHABLE;
|
||||
struct neighbour *n;
|
||||
|
||||
rcu_read_lock_bh();
|
||||
|
||||
n = __ipv4_neigh_lookup_noref(nh->fib_nh_dev,
|
||||
(__force u32)nh->fib_nh_gw4);
|
||||
if (n)
|
||||
state = n->nud_state;
|
||||
|
||||
rcu_read_unlock_bh();
|
||||
|
||||
return !!(state & NUD_VALID);
|
||||
}
|
||||
|
||||
struct nexthop *nexthop_select_path(struct nexthop *nh, int hash)
|
||||
{
|
||||
struct nexthop *rc = NULL;
|
||||
struct nh_group *nhg;
|
||||
int i;
|
||||
|
||||
if (!nh->is_group)
|
||||
return nh;
|
||||
|
||||
nhg = rcu_dereference(nh->nh_grp);
|
||||
for (i = 0; i < nhg->num_nh; ++i) {
|
||||
struct nh_grp_entry *nhge = &nhg->nh_entries[i];
|
||||
struct nh_info *nhi;
|
||||
|
||||
if (hash > atomic_read(&nhge->upper_bound))
|
||||
continue;
|
||||
|
||||
/* nexthops always check if it is good and does
|
||||
* not rely on a sysctl for this behavior
|
||||
*/
|
||||
nhi = rcu_dereference(nhge->nh->nh_info);
|
||||
switch (nhi->family) {
|
||||
case AF_INET:
|
||||
if (ipv4_good_nh(&nhi->fib_nh))
|
||||
return nhge->nh;
|
||||
break;
|
||||
case AF_INET6:
|
||||
if (ipv6_good_nh(&nhi->fib6_nh))
|
||||
return nhge->nh;
|
||||
break;
|
||||
}
|
||||
|
||||
if (!rc)
|
||||
rc = nhge->nh;
|
||||
}
|
||||
|
||||
return rc;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nexthop_select_path);
|
||||
|
||||
static void nh_group_rebalance(struct nh_group *nhg)
|
||||
{
|
||||
int total = 0;
|
||||
int w = 0;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < nhg->num_nh; ++i)
|
||||
total += nhg->nh_entries[i].weight;
|
||||
|
||||
for (i = 0; i < nhg->num_nh; ++i) {
|
||||
struct nh_grp_entry *nhge = &nhg->nh_entries[i];
|
||||
int upper_bound;
|
||||
|
||||
w += nhge->weight;
|
||||
upper_bound = DIV_ROUND_CLOSEST_ULL((u64)w << 31, total) - 1;
|
||||
atomic_set(&nhge->upper_bound, upper_bound);
|
||||
}
|
||||
}
|
||||
|
||||
static void remove_nh_grp_entry(struct nh_grp_entry *nhge,
|
||||
struct nh_group *nhg,
|
||||
struct nl_info *nlinfo)
|
||||
{
|
||||
struct nexthop *nh = nhge->nh;
|
||||
struct nh_grp_entry *nhges;
|
||||
bool found = false;
|
||||
int i;
|
||||
|
||||
WARN_ON(!nh);
|
||||
|
||||
nhges = nhg->nh_entries;
|
||||
for (i = 0; i < nhg->num_nh; ++i) {
|
||||
if (found) {
|
||||
nhges[i-1].nh = nhges[i].nh;
|
||||
nhges[i-1].weight = nhges[i].weight;
|
||||
list_del(&nhges[i].nh_list);
|
||||
list_add(&nhges[i-1].nh_list, &nhges[i-1].nh->grp_list);
|
||||
} else if (nhg->nh_entries[i].nh == nh) {
|
||||
found = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (WARN_ON(!found))
|
||||
return;
|
||||
|
||||
nhg->num_nh--;
|
||||
nhg->nh_entries[nhg->num_nh].nh = NULL;
|
||||
|
||||
nh_group_rebalance(nhg);
|
||||
|
||||
nexthop_put(nh);
|
||||
|
||||
if (nlinfo)
|
||||
nexthop_notify(RTM_NEWNEXTHOP, nhge->nh_parent, nlinfo);
|
||||
}
|
||||
|
||||
static void remove_nexthop_from_groups(struct net *net, struct nexthop *nh,
|
||||
struct nl_info *nlinfo)
|
||||
{
|
||||
struct nh_grp_entry *nhge, *tmp;
|
||||
|
||||
list_for_each_entry_safe(nhge, tmp, &nh->grp_list, nh_list) {
|
||||
struct nh_group *nhg;
|
||||
|
||||
list_del(&nhge->nh_list);
|
||||
nhg = rtnl_dereference(nhge->nh_parent->nh_grp);
|
||||
remove_nh_grp_entry(nhge, nhg, nlinfo);
|
||||
|
||||
/* if this group has no more entries then remove it */
|
||||
if (!nhg->num_nh)
|
||||
remove_nexthop(net, nhge->nh_parent, nlinfo);
|
||||
}
|
||||
}
|
||||
|
||||
static void remove_nexthop_group(struct nexthop *nh, struct nl_info *nlinfo)
|
||||
{
|
||||
struct nh_group *nhg = rcu_dereference_rtnl(nh->nh_grp);
|
||||
int i, num_nh = nhg->num_nh;
|
||||
|
||||
for (i = 0; i < num_nh; ++i) {
|
||||
struct nh_grp_entry *nhge = &nhg->nh_entries[i];
|
||||
|
||||
if (WARN_ON(!nhge->nh))
|
||||
continue;
|
||||
|
||||
list_del(&nhge->nh_list);
|
||||
nexthop_put(nhge->nh);
|
||||
nhge->nh = NULL;
|
||||
nhg->num_nh--;
|
||||
}
|
||||
}
|
||||
|
||||
static void __remove_nexthop(struct net *net, struct nexthop *nh,
|
||||
struct nl_info *nlinfo)
|
||||
{
|
||||
if (nh->is_group) {
|
||||
remove_nexthop_group(nh, nlinfo);
|
||||
} else {
|
||||
struct nh_info *nhi;
|
||||
|
||||
nhi = rtnl_dereference(nh->nh_info);
|
||||
if (nhi->fib_nhc.nhc_dev)
|
||||
hlist_del(&nhi->dev_hash);
|
||||
|
||||
remove_nexthop_from_groups(net, nh, nlinfo);
|
||||
}
|
||||
}
|
||||
|
||||
static void remove_nexthop(struct net *net, struct nexthop *nh,
|
||||
bool skip_fib, struct nl_info *nlinfo)
|
||||
struct nl_info *nlinfo)
|
||||
{
|
||||
/* remove from the tree */
|
||||
rb_erase(&nh->rb_node, &net->nexthop.rb_root);
|
||||
|
|
@ -272,7 +632,7 @@ static void remove_nexthop(struct net *net, struct nexthop *nh,
|
|||
if (nlinfo)
|
||||
nexthop_notify(RTM_DELNEXTHOP, nh, nlinfo);
|
||||
|
||||
__remove_nexthop(net, nh);
|
||||
__remove_nexthop(net, nh, nlinfo);
|
||||
nh_base_seq_inc(net);
|
||||
|
||||
nexthop_put(nh);
|
||||
|
|
@ -353,7 +713,7 @@ static void nexthop_flush_dev(struct net_device *dev)
|
|||
if (nhi->fib_nhc.nhc_dev != dev)
|
||||
continue;
|
||||
|
||||
remove_nexthop(net, nhi->nh_parent, false, NULL);
|
||||
remove_nexthop(net, nhi->nh_parent, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -366,11 +726,69 @@ static void flush_all_nexthops(struct net *net)
|
|||
|
||||
while ((node = rb_first(root))) {
|
||||
nh = rb_entry(node, struct nexthop, rb_node);
|
||||
remove_nexthop(net, nh, false, NULL);
|
||||
remove_nexthop(net, nh, NULL);
|
||||
cond_resched();
|
||||
}
|
||||
}
|
||||
|
||||
static struct nexthop *nexthop_create_group(struct net *net,
|
||||
struct nh_config *cfg)
|
||||
{
|
||||
struct nlattr *grps_attr = cfg->nh_grp;
|
||||
struct nexthop_grp *entry = nla_data(grps_attr);
|
||||
struct nh_group *nhg;
|
||||
struct nexthop *nh;
|
||||
int i;
|
||||
|
||||
nh = nexthop_alloc();
|
||||
if (!nh)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
|
||||
nh->is_group = 1;
|
||||
|
||||
nhg = nexthop_grp_alloc(nla_len(grps_attr) / sizeof(*entry));
|
||||
if (!nhg) {
|
||||
kfree(nh);
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
|
||||
for (i = 0; i < nhg->num_nh; ++i) {
|
||||
struct nexthop *nhe;
|
||||
struct nh_info *nhi;
|
||||
|
||||
nhe = nexthop_find_by_id(net, entry[i].id);
|
||||
if (!nexthop_get(nhe))
|
||||
goto out_no_nh;
|
||||
|
||||
nhi = rtnl_dereference(nhe->nh_info);
|
||||
if (nhi->family == AF_INET)
|
||||
nhg->has_v4 = true;
|
||||
|
||||
nhg->nh_entries[i].nh = nhe;
|
||||
nhg->nh_entries[i].weight = entry[i].weight + 1;
|
||||
list_add(&nhg->nh_entries[i].nh_list, &nhe->grp_list);
|
||||
nhg->nh_entries[i].nh_parent = nh;
|
||||
}
|
||||
|
||||
if (cfg->nh_grp_type == NEXTHOP_GRP_TYPE_MPATH) {
|
||||
nhg->mpath = 1;
|
||||
nh_group_rebalance(nhg);
|
||||
}
|
||||
|
||||
rcu_assign_pointer(nh->nh_grp, nhg);
|
||||
|
||||
return nh;
|
||||
|
||||
out_no_nh:
|
||||
for (; i >= 0; --i)
|
||||
nexthop_put(nhg->nh_entries[i].nh);
|
||||
|
||||
kfree(nhg);
|
||||
kfree(nh);
|
||||
|
||||
return ERR_PTR(-ENOENT);
|
||||
}
|
||||
|
||||
static int nh_create_ipv4(struct net *net, struct nexthop *nh,
|
||||
struct nh_info *nhi, struct nh_config *cfg,
|
||||
struct netlink_ext_ack *extack)
|
||||
|
|
@ -506,7 +924,11 @@ static struct nexthop *nexthop_add(struct net *net, struct nh_config *cfg,
|
|||
}
|
||||
}
|
||||
|
||||
nh = nexthop_create(net, cfg, extack);
|
||||
if (cfg->nh_grp)
|
||||
nh = nexthop_create_group(net, cfg);
|
||||
else
|
||||
nh = nexthop_create(net, cfg, extack);
|
||||
|
||||
if (IS_ERR(nh))
|
||||
return nh;
|
||||
|
||||
|
|
@ -517,7 +939,7 @@ static struct nexthop *nexthop_add(struct net *net, struct nh_config *cfg,
|
|||
|
||||
err = insert_nexthop(net, nh, cfg, extack);
|
||||
if (err) {
|
||||
__remove_nexthop(net, nh);
|
||||
__remove_nexthop(net, nh, NULL);
|
||||
nexthop_put(nh);
|
||||
nh = ERR_PTR(err);
|
||||
}
|
||||
|
|
@ -552,6 +974,10 @@ static int rtm_to_nh_config(struct net *net, struct sk_buff *skb,
|
|||
case AF_INET:
|
||||
case AF_INET6:
|
||||
break;
|
||||
case AF_UNSPEC:
|
||||
if (tb[NHA_GROUP])
|
||||
break;
|
||||
/* fallthrough */
|
||||
default:
|
||||
NL_SET_ERR_MSG(extack, "Invalid address family");
|
||||
goto out;
|
||||
|
|
@ -575,6 +1001,27 @@ static int rtm_to_nh_config(struct net *net, struct sk_buff *skb,
|
|||
if (tb[NHA_ID])
|
||||
cfg->nh_id = nla_get_u32(tb[NHA_ID]);
|
||||
|
||||
if (tb[NHA_GROUP]) {
|
||||
if (nhm->nh_family != AF_UNSPEC) {
|
||||
NL_SET_ERR_MSG(extack, "Invalid family for group");
|
||||
goto out;
|
||||
}
|
||||
cfg->nh_grp = tb[NHA_GROUP];
|
||||
|
||||
cfg->nh_grp_type = NEXTHOP_GRP_TYPE_MPATH;
|
||||
if (tb[NHA_GROUP_TYPE])
|
||||
cfg->nh_grp_type = nla_get_u16(tb[NHA_GROUP_TYPE]);
|
||||
|
||||
if (cfg->nh_grp_type > NEXTHOP_GRP_TYPE_MAX) {
|
||||
NL_SET_ERR_MSG(extack, "Invalid group type");
|
||||
goto out;
|
||||
}
|
||||
err = nh_check_attr_group(net, tb, extack);
|
||||
|
||||
/* no other attributes should be set */
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (tb[NHA_BLACKHOLE]) {
|
||||
if (tb[NHA_GATEWAY] || tb[NHA_OIF] ||
|
||||
tb[NHA_ENCAP] || tb[NHA_ENCAP_TYPE]) {
|
||||
|
|
@ -752,7 +1199,7 @@ static int rtm_del_nexthop(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|||
if (!nh)
|
||||
return -ENOENT;
|
||||
|
||||
remove_nexthop(net, nh, false, &nlinfo);
|
||||
remove_nexthop(net, nh, &nlinfo);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -796,15 +1243,21 @@ errout_free:
|
|||
goto out;
|
||||
}
|
||||
|
||||
static bool nh_dump_filtered(struct nexthop *nh, int dev_idx,
|
||||
int master_idx, u8 family)
|
||||
static bool nh_dump_filtered(struct nexthop *nh, int dev_idx, int master_idx,
|
||||
bool group_filter, u8 family)
|
||||
{
|
||||
const struct net_device *dev;
|
||||
const struct nh_info *nhi;
|
||||
|
||||
if (group_filter && !nh->is_group)
|
||||
return true;
|
||||
|
||||
if (!dev_idx && !master_idx && !family)
|
||||
return false;
|
||||
|
||||
if (nh->is_group)
|
||||
return true;
|
||||
|
||||
nhi = rtnl_dereference(nh->nh_info);
|
||||
if (family && nhi->family != family)
|
||||
return true;
|
||||
|
|
@ -827,8 +1280,8 @@ static bool nh_dump_filtered(struct nexthop *nh, int dev_idx,
|
|||
return false;
|
||||
}
|
||||
|
||||
static int nh_valid_dump_req(const struct nlmsghdr *nlh,
|
||||
int *dev_idx, int *master_idx,
|
||||
static int nh_valid_dump_req(const struct nlmsghdr *nlh, int *dev_idx,
|
||||
int *master_idx, bool *group_filter,
|
||||
struct netlink_callback *cb)
|
||||
{
|
||||
struct netlink_ext_ack *extack = cb->extack;
|
||||
|
|
@ -863,6 +1316,9 @@ static int nh_valid_dump_req(const struct nlmsghdr *nlh,
|
|||
}
|
||||
*master_idx = idx;
|
||||
break;
|
||||
case NHA_GROUPS:
|
||||
*group_filter = true;
|
||||
break;
|
||||
default:
|
||||
NL_SET_ERR_MSG(extack, "Unsupported attribute in dump request");
|
||||
return -EINVAL;
|
||||
|
|
@ -885,11 +1341,13 @@ static int rtm_dump_nexthop(struct sk_buff *skb, struct netlink_callback *cb)
|
|||
int dev_filter_idx = 0, master_idx = 0;
|
||||
struct net *net = sock_net(skb->sk);
|
||||
struct rb_root *root = &net->nexthop.rb_root;
|
||||
bool group_filter = false;
|
||||
struct rb_node *node;
|
||||
int idx = 0, s_idx;
|
||||
int err;
|
||||
|
||||
err = nh_valid_dump_req(cb->nlh, &dev_filter_idx, &master_idx, cb);
|
||||
err = nh_valid_dump_req(cb->nlh, &dev_filter_idx, &master_idx,
|
||||
&group_filter, cb);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
|
|
@ -902,7 +1360,7 @@ static int rtm_dump_nexthop(struct sk_buff *skb, struct netlink_callback *cb)
|
|||
|
||||
nh = rb_entry(node, struct nexthop, rb_node);
|
||||
if (nh_dump_filtered(nh, dev_filter_idx, master_idx,
|
||||
nhm->nh_family))
|
||||
group_filter, nhm->nh_family))
|
||||
goto cont;
|
||||
|
||||
err = nh_fill_node(skb, nh, RTM_NEWNEXTHOP,
|
||||
|
|
|
|||
Loading…
Reference in New Issue