leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

bridge: mrp: Rework the MRP netlink interface

Browse Source 
This patch reworks the MRP netlink interface. Before, each attribute
represented a binary structure which made it hard to be extended.
Therefore update the MRP netlink interface such that each existing
attribute to be a nested attribute which contains the fields of the
binary structures.
In this way the MRP netlink interface can be extended without breaking
the backwards compatibility. It is also using strict checking for
attributes under the MRP top attribute.

Signed-off-by: Horatiu Vultur <horatiu.vultur@microchip.com>
Acked-by: Nikolay Aleksandrov <nikolay@cumulusnetworks.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Horatiu Vultur 2020-05-27 12:34:30 +00:00 committed by David S. Miller
parent 9f01a71c5c
commit 20f6a05ef6
4 changed files with 290 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
include/uapi/linux/if_bridge.h
View File

@ -169,17 +169,69 @@ enum {
__IFLA_BRIDGE_MRP_MAX, __IFLA_BRIDGE_MRP_MAX,
}; };
#define IFLA_BRIDGE_MRP_MAX (__IFLA_BRIDGE_MRP_MAX - 1)
enum {
IFLA_BRIDGE_MRP_INSTANCE_UNSPEC,
IFLA_BRIDGE_MRP_INSTANCE_RING_ID,
IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX,
IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX,
__IFLA_BRIDGE_MRP_INSTANCE_MAX,
};
#define IFLA_BRIDGE_MRP_INSTANCE_MAX (__IFLA_BRIDGE_MRP_INSTANCE_MAX - 1)
enum {
IFLA_BRIDGE_MRP_PORT_STATE_UNSPEC,
IFLA_BRIDGE_MRP_PORT_STATE_STATE,
__IFLA_BRIDGE_MRP_PORT_STATE_MAX,
};
#define IFLA_BRIDGE_MRP_PORT_STATE_MAX (__IFLA_BRIDGE_MRP_PORT_STATE_MAX - 1)
enum {
IFLA_BRIDGE_MRP_PORT_ROLE_UNSPEC,
IFLA_BRIDGE_MRP_PORT_ROLE_ROLE,
__IFLA_BRIDGE_MRP_PORT_ROLE_MAX,
};
#define IFLA_BRIDGE_MRP_PORT_ROLE_MAX (__IFLA_BRIDGE_MRP_PORT_ROLE_MAX - 1)
enum {
IFLA_BRIDGE_MRP_RING_STATE_UNSPEC,
IFLA_BRIDGE_MRP_RING_STATE_RING_ID,
IFLA_BRIDGE_MRP_RING_STATE_STATE,
__IFLA_BRIDGE_MRP_RING_STATE_MAX,
};
#define IFLA_BRIDGE_MRP_RING_STATE_MAX (__IFLA_BRIDGE_MRP_RING_STATE_MAX - 1)
enum {
IFLA_BRIDGE_MRP_RING_ROLE_UNSPEC,
IFLA_BRIDGE_MRP_RING_ROLE_RING_ID,
IFLA_BRIDGE_MRP_RING_ROLE_ROLE,
__IFLA_BRIDGE_MRP_RING_ROLE_MAX,
};
#define IFLA_BRIDGE_MRP_RING_ROLE_MAX (__IFLA_BRIDGE_MRP_RING_ROLE_MAX - 1)
enum {
IFLA_BRIDGE_MRP_START_TEST_UNSPEC,
IFLA_BRIDGE_MRP_START_TEST_RING_ID,
IFLA_BRIDGE_MRP_START_TEST_INTERVAL,
IFLA_BRIDGE_MRP_START_TEST_MAX_MISS,
IFLA_BRIDGE_MRP_START_TEST_PERIOD,
__IFLA_BRIDGE_MRP_START_TEST_MAX,
};
#define IFLA_BRIDGE_MRP_START_TEST_MAX (__IFLA_BRIDGE_MRP_START_TEST_MAX - 1)
struct br_mrp_instance { struct br_mrp_instance {
__u32 ring_id; __u32 ring_id;
__u32 p_ifindex; __u32 p_ifindex;
__u32 s_ifindex; __u32 s_ifindex;
}; };
struct br_mrp_port_role {
__u32 ring_id;
__u32 role;
};
struct br_mrp_ring_state { struct br_mrp_ring_state {
__u32 ring_id; __u32 ring_id;
__u32 ring_state; __u32 ring_state;
@ -197,8 +249,6 @@ struct br_mrp_start_test {
__u32 period; __u32 period;
}; };
#define IFLA_BRIDGE_MRP_MAX (__IFLA_BRIDGE_MRP_MAX - 1)
struct bridge_stp_xstats { struct bridge_stp_xstats {
__u64 transition_blk; __u64 transition_blk;
__u64 transition_fwd; __u64 transition_fwd;

8
net/bridge/br_mrp.c
View File

@ -376,24 +376,24 @@ int br_mrp_set_port_state(struct net_bridge_port *p,
* note: already called with rtnl_lock * note: already called with rtnl_lock
*/ */
int br_mrp_set_port_role(struct net_bridge_port *p, int br_mrp_set_port_role(struct net_bridge_port *p,
struct br_mrp_port_role *role) enum br_mrp_port_role_type role)
{ {
struct br_mrp *mrp; struct br_mrp *mrp;
if (!p || !(p->flags & BR_MRP_AWARE)) if (!p || !(p->flags & BR_MRP_AWARE))
return -EINVAL; return -EINVAL;
mrp = br_mrp_find_id(p->br, role->ring_id); mrp = br_mrp_find_port(p->br, p);
if (!mrp) if (!mrp)
return -EINVAL; return -EINVAL;
if (role->role == BR_MRP_PORT_ROLE_PRIMARY) if (role == BR_MRP_PORT_ROLE_PRIMARY)
rcu_assign_pointer(mrp->p_port, p); rcu_assign_pointer(mrp->p_port, p);
else else
rcu_assign_pointer(mrp->s_port, p); rcu_assign_pointer(mrp->s_port, p);
br_mrp_port_switchdev_set_role(p, role->role); br_mrp_port_switchdev_set_role(p, role);
return 0; return 0;
} }

266
net/bridge/br_mrp_netlink.c
View File

@ -8,19 +8,222 @@
static const struct nla_policy br_mrp_policy[IFLA_BRIDGE_MRP_MAX + 1] = { static const struct nla_policy br_mrp_policy[IFLA_BRIDGE_MRP_MAX + 1] = {
[IFLA_BRIDGE_MRP_UNSPEC] = { .type = NLA_REJECT }, [IFLA_BRIDGE_MRP_UNSPEC] = { .type = NLA_REJECT },
[IFLA_BRIDGE_MRP_INSTANCE] = { .type = NLA_EXACT_LEN, [IFLA_BRIDGE_MRP_INSTANCE] = { .type = NLA_NESTED },
.len = sizeof(struct br_mrp_instance)}, [IFLA_BRIDGE_MRP_PORT_STATE] = { .type = NLA_NESTED },
[IFLA_BRIDGE_MRP_PORT_STATE] = { .type = NLA_U32 }, [IFLA_BRIDGE_MRP_PORT_ROLE] = { .type = NLA_NESTED },
[IFLA_BRIDGE_MRP_PORT_ROLE] = { .type = NLA_EXACT_LEN, [IFLA_BRIDGE_MRP_RING_STATE] = { .type = NLA_NESTED },
.len = sizeof(struct br_mrp_port_role)}, [IFLA_BRIDGE_MRP_RING_ROLE] = { .type = NLA_NESTED },
[IFLA_BRIDGE_MRP_RING_STATE] = { .type = NLA_EXACT_LEN, [IFLA_BRIDGE_MRP_START_TEST] = { .type = NLA_NESTED },
.len = sizeof(struct br_mrp_ring_state)},
[IFLA_BRIDGE_MRP_RING_ROLE] = { .type = NLA_EXACT_LEN,
.len = sizeof(struct br_mrp_ring_role)},
[IFLA_BRIDGE_MRP_START_TEST] = { .type = NLA_EXACT_LEN,
.len = sizeof(struct br_mrp_start_test)},
}; };
static const struct nla_policy
br_mrp_instance_policy[IFLA_BRIDGE_MRP_INSTANCE_MAX + 1] = {
[IFLA_BRIDGE_MRP_INSTANCE_UNSPEC] = { .type = NLA_REJECT },
[IFLA_BRIDGE_MRP_INSTANCE_RING_ID] = { .type = NLA_U32 },
[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX] = { .type = NLA_U32 },
[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX] = { .type = NLA_U32 },
};
static int br_mrp_instance_parse(struct net_bridge *br, struct nlattr *attr,
int cmd, struct netlink_ext_ack *extack)
{
struct nlattr *tb[IFLA_BRIDGE_MRP_INSTANCE_MAX + 1];
struct br_mrp_instance inst;
int err;
err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_INSTANCE_MAX, attr,
br_mrp_instance_policy, extack);
if (err)
return err;
if (!tb[IFLA_BRIDGE_MRP_INSTANCE_RING_ID] ||
!tb[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX] ||
!tb[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]) {
NL_SET_ERR_MSG_MOD(extack,
"Missing attribute: RING_ID or P_IFINDEX or S_IFINDEX");
return -EINVAL;
}
memset(&inst, 0, sizeof(inst));
inst.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_RING_ID]);
inst.p_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX]);
inst.s_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]);
if (cmd == RTM_SETLINK)
return br_mrp_add(br, &inst);
else
return br_mrp_del(br, &inst);
return 0;
}
static const struct nla_policy
br_mrp_port_state_policy[IFLA_BRIDGE_MRP_PORT_STATE_MAX + 1] = {
[IFLA_BRIDGE_MRP_PORT_STATE_UNSPEC] = { .type = NLA_REJECT },
[IFLA_BRIDGE_MRP_PORT_STATE_STATE] = { .type = NLA_U32 },
};
static int br_mrp_port_state_parse(struct net_bridge_port *p,
struct nlattr *attr,
struct netlink_ext_ack *extack)
{
struct nlattr *tb[IFLA_BRIDGE_MRP_PORT_STATE_MAX + 1];
enum br_mrp_port_state_type state;
int err;
err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_PORT_STATE_MAX, attr,
br_mrp_port_state_policy, extack);
if (err)
return err;
if (!tb[IFLA_BRIDGE_MRP_PORT_STATE_STATE]) {
NL_SET_ERR_MSG_MOD(extack, "Missing attribute: STATE");
return -EINVAL;
}
state = nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_STATE_STATE]);
return br_mrp_set_port_state(p, state);
}
static const struct nla_policy
br_mrp_port_role_policy[IFLA_BRIDGE_MRP_PORT_ROLE_MAX + 1] = {
[IFLA_BRIDGE_MRP_PORT_ROLE_UNSPEC] = { .type = NLA_REJECT },
[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE] = { .type = NLA_U32 },
};
static int br_mrp_port_role_parse(struct net_bridge_port *p,
struct nlattr *attr,
struct netlink_ext_ack *extack)
{
struct nlattr *tb[IFLA_BRIDGE_MRP_PORT_ROLE_MAX + 1];
enum br_mrp_port_role_type role;
int err;
err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_PORT_ROLE_MAX, attr,
br_mrp_port_role_policy, extack);
if (err)
return err;
if (!tb[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]) {
NL_SET_ERR_MSG_MOD(extack, "Missing attribute: ROLE");
return -EINVAL;
}
role = nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]);
return br_mrp_set_port_role(p, role);
}
static const struct nla_policy
br_mrp_ring_state_policy[IFLA_BRIDGE_MRP_RING_STATE_MAX + 1] = {
[IFLA_BRIDGE_MRP_RING_STATE_UNSPEC] = { .type = NLA_REJECT },
[IFLA_BRIDGE_MRP_RING_STATE_RING_ID] = { .type = NLA_U32 },
[IFLA_BRIDGE_MRP_RING_STATE_STATE] = { .type = NLA_U32 },
};
static int br_mrp_ring_state_parse(struct net_bridge *br, struct nlattr *attr,
struct netlink_ext_ack *extack)
{
struct nlattr *tb[IFLA_BRIDGE_MRP_RING_STATE_MAX + 1];
struct br_mrp_ring_state state;
int err;
err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_RING_STATE_MAX, attr,
br_mrp_ring_state_policy, extack);
if (err)
return err;
if (!tb[IFLA_BRIDGE_MRP_RING_STATE_RING_ID] ||
!tb[IFLA_BRIDGE_MRP_RING_STATE_STATE]) {
NL_SET_ERR_MSG_MOD(extack,
"Missing attribute: RING_ID or STATE");
return -EINVAL;
}
memset(&state, 0x0, sizeof(state));
state.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_STATE_RING_ID]);
state.ring_state = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_STATE_STATE]);
return br_mrp_set_ring_state(br, &state);
}
static const struct nla_policy
br_mrp_ring_role_policy[IFLA_BRIDGE_MRP_RING_ROLE_MAX + 1] = {
[IFLA_BRIDGE_MRP_RING_ROLE_UNSPEC] = { .type = NLA_REJECT },
[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID] = { .type = NLA_U32 },
[IFLA_BRIDGE_MRP_RING_ROLE_ROLE] = { .type = NLA_U32 },
};
static int br_mrp_ring_role_parse(struct net_bridge *br, struct nlattr *attr,
struct netlink_ext_ack *extack)
{
struct nlattr *tb[IFLA_BRIDGE_MRP_RING_ROLE_MAX + 1];
struct br_mrp_ring_role role;
int err;
err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_RING_ROLE_MAX, attr,
br_mrp_ring_role_policy, extack);
if (err)
return err;
if (!tb[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID] ||
!tb[IFLA_BRIDGE_MRP_RING_ROLE_ROLE]) {
NL_SET_ERR_MSG_MOD(extack,
"Missing attribute: RING_ID or ROLE");
return -EINVAL;
}
memset(&role, 0x0, sizeof(role));
role.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID]);
role.ring_role = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_ROLE_ROLE]);
return br_mrp_set_ring_role(br, &role);
}
static const struct nla_policy
br_mrp_start_test_policy[IFLA_BRIDGE_MRP_START_TEST_MAX + 1] = {
[IFLA_BRIDGE_MRP_START_TEST_UNSPEC] = { .type = NLA_REJECT },
[IFLA_BRIDGE_MRP_START_TEST_RING_ID] = { .type = NLA_U32 },
[IFLA_BRIDGE_MRP_START_TEST_INTERVAL] = { .type = NLA_U32 },
[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS] = { .type = NLA_U32 },
[IFLA_BRIDGE_MRP_START_TEST_PERIOD] = { .type = NLA_U32 },
};
static int br_mrp_start_test_parse(struct net_bridge *br, struct nlattr *attr,
struct netlink_ext_ack *extack)
{
struct nlattr *tb[IFLA_BRIDGE_MRP_START_TEST_MAX + 1];
struct br_mrp_start_test test;
int err;
err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_START_TEST_MAX, attr,
br_mrp_start_test_policy, extack);
if (err)
return err;
if (!tb[IFLA_BRIDGE_MRP_START_TEST_RING_ID] ||
!tb[IFLA_BRIDGE_MRP_START_TEST_INTERVAL] ||
!tb[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS] ||
!tb[IFLA_BRIDGE_MRP_START_TEST_PERIOD]) {
NL_SET_ERR_MSG_MOD(extack,
"Missing attribute: RING_ID or INTERVAL or MAX_MISS or PERIOD");
return -EINVAL;
}
memset(&test, 0x0, sizeof(test));
test.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_RING_ID]);
test.interval = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_INTERVAL]);
test.max_miss = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS]);
test.period = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_PERIOD]);
return br_mrp_start_test(br, &test);
}
int br_mrp_parse(struct net_bridge *br, struct net_bridge_port *p, int br_mrp_parse(struct net_bridge *br, struct net_bridge_port *p,
struct nlattr *attr, int cmd, struct netlink_ext_ack *extack) struct nlattr *attr, int cmd, struct netlink_ext_ack *extack)
{ {
@ -44,58 +247,45 @@ int br_mrp_parse(struct net_bridge *br, struct net_bridge_port *p,
return err; return err;
if (tb[IFLA_BRIDGE_MRP_INSTANCE]) { if (tb[IFLA_BRIDGE_MRP_INSTANCE]) {
struct br_mrp_instance *instance = err = br_mrp_instance_parse(br, tb[IFLA_BRIDGE_MRP_INSTANCE],
nla_data(tb[IFLA_BRIDGE_MRP_INSTANCE]); cmd, extack);
if (cmd == RTM_SETLINK)
err = br_mrp_add(br, instance);
else
err = br_mrp_del(br, instance);
if (err) if (err)
return err; return err;
} }
if (tb[IFLA_BRIDGE_MRP_PORT_STATE]) { if (tb[IFLA_BRIDGE_MRP_PORT_STATE]) {
enum br_mrp_port_state_type state = err = br_mrp_port_state_parse(p, tb[IFLA_BRIDGE_MRP_PORT_STATE],
nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_STATE]); extack);
err = br_mrp_set_port_state(p, state);
if (err) if (err)
return err; return err;
} }
if (tb[IFLA_BRIDGE_MRP_PORT_ROLE]) { if (tb[IFLA_BRIDGE_MRP_PORT_ROLE]) {
struct br_mrp_port_role *role = err = br_mrp_port_role_parse(p, tb[IFLA_BRIDGE_MRP_PORT_ROLE],
nla_data(tb[IFLA_BRIDGE_MRP_PORT_ROLE]); extack);
err = br_mrp_set_port_role(p, role);
if (err) if (err)
return err; return err;
} }
if (tb[IFLA_BRIDGE_MRP_RING_STATE]) { if (tb[IFLA_BRIDGE_MRP_RING_STATE]) {
struct br_mrp_ring_state *state = err = br_mrp_ring_state_parse(br,
nla_data(tb[IFLA_BRIDGE_MRP_RING_STATE]); tb[IFLA_BRIDGE_MRP_RING_STATE],
extack);
err = br_mrp_set_ring_state(br, state);
if (err) if (err)
return err; return err;
} }
if (tb[IFLA_BRIDGE_MRP_RING_ROLE]) { if (tb[IFLA_BRIDGE_MRP_RING_ROLE]) {
struct br_mrp_ring_role *role = err = br_mrp_ring_role_parse(br, tb[IFLA_BRIDGE_MRP_RING_ROLE],
nla_data(tb[IFLA_BRIDGE_MRP_RING_ROLE]); extack);
err = br_mrp_set_ring_role(br, role);
if (err) if (err)
return err; return err;
} }
if (tb[IFLA_BRIDGE_MRP_START_TEST]) { if (tb[IFLA_BRIDGE_MRP_START_TEST]) {
struct br_mrp_start_test *test = err = br_mrp_start_test_parse(br,
nla_data(tb[IFLA_BRIDGE_MRP_START_TEST]); tb[IFLA_BRIDGE_MRP_START_TEST],
extack);
err = br_mrp_start_test(br, test);
if (err) if (err)
return err; return err;
} }

2
net/bridge/br_private_mrp.h
View File

@ -37,7 +37,7 @@ int br_mrp_del(struct net_bridge *br, struct br_mrp_instance *instance);
int br_mrp_set_port_state(struct net_bridge_port *p, int br_mrp_set_port_state(struct net_bridge_port *p,
enum br_mrp_port_state_type state); enum br_mrp_port_state_type state);
int br_mrp_set_port_role(struct net_bridge_port *p, int br_mrp_set_port_role(struct net_bridge_port *p,
struct br_mrp_port_role *role); enum br_mrp_port_role_type role);
int br_mrp_set_ring_state(struct net_bridge *br, int br_mrp_set_ring_state(struct net_bridge *br,
struct br_mrp_ring_state *state); struct br_mrp_ring_state *state);
int br_mrp_set_ring_role(struct net_bridge *br, struct br_mrp_ring_role *role); int br_mrp_set_ring_role(struct net_bridge *br, struct br_mrp_ring_role *role);