[linux-block.git] / net / bridge / br_mrp_netlink.c

// SPDX-License-Identifier: GPL-2.0-or-later

#include <net/genetlink.h>

#include <uapi/linux/mrp_bridge.h>
#include "br_private.h"
#include "br_private_mrp.h"

static const struct nla_policy br_mrp_policy[IFLA_BRIDGE_MRP_MAX + 1] = {
	[IFLA_BRIDGE_MRP_UNSPEC]	= { .type = NLA_REJECT },
	[IFLA_BRIDGE_MRP_INSTANCE]	= { .type = NLA_NESTED },
	[IFLA_BRIDGE_MRP_PORT_STATE]	= { .type = NLA_NESTED },
	[IFLA_BRIDGE_MRP_PORT_ROLE]	= { .type = NLA_NESTED },
	[IFLA_BRIDGE_MRP_RING_STATE]	= { .type = NLA_NESTED },
	[IFLA_BRIDGE_MRP_RING_ROLE]	= { .type = NLA_NESTED },
	[IFLA_BRIDGE_MRP_START_TEST]	= { .type = NLA_NESTED },
	[IFLA_BRIDGE_MRP_IN_ROLE]	= { .type = NLA_NESTED },
	[IFLA_BRIDGE_MRP_IN_STATE]	= { .type = NLA_NESTED },
	[IFLA_BRIDGE_MRP_START_IN_TEST]	= { .type = NLA_NESTED },
};

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 },
	[IFLA_BRIDGE_MRP_INSTANCE_PRIO]		= { .type = NLA_U16 },
};

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]);
	inst.prio = MRP_DEFAULT_PRIO;

	if (tb[IFLA_BRIDGE_MRP_INSTANCE_PRIO])
		inst.prio = nla_get_u16(tb[IFLA_BRIDGE_MRP_INSTANCE_PRIO]);

	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 },
	[IFLA_BRIDGE_MRP_START_TEST_MONITOR]	= { .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]);
	test.monitor = false;

	if (tb[IFLA_BRIDGE_MRP_START_TEST_MONITOR])
		test.monitor =
			nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_MONITOR]);

	return br_mrp_start_test(br, &test);
}

static const struct nla_policy
br_mrp_in_state_policy[IFLA_BRIDGE_MRP_IN_STATE_MAX + 1] = {
	[IFLA_BRIDGE_MRP_IN_STATE_UNSPEC]	= { .type = NLA_REJECT },
	[IFLA_BRIDGE_MRP_IN_STATE_IN_ID]	= { .type = NLA_U32 },
	[IFLA_BRIDGE_MRP_IN_STATE_STATE]	= { .type = NLA_U32 },
};

static int br_mrp_in_state_parse(struct net_bridge *br, struct nlattr *attr,
				 struct netlink_ext_ack *extack)
{
	struct nlattr *tb[IFLA_BRIDGE_MRP_IN_STATE_MAX + 1];
	struct br_mrp_in_state state;
	int err;

	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_IN_STATE_MAX, attr,
			       br_mrp_in_state_policy, extack);
	if (err)
		return err;

	if (!tb[IFLA_BRIDGE_MRP_IN_STATE_IN_ID] ||
	    !tb[IFLA_BRIDGE_MRP_IN_STATE_STATE]) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Missing attribute: IN_ID or STATE");
		return -EINVAL;
	}

	memset(&state, 0x0, sizeof(state));

	state.in_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_STATE_IN_ID]);
	state.in_state = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_STATE_STATE]);

	return br_mrp_set_in_state(br, &state);
}

static const struct nla_policy
br_mrp_in_role_policy[IFLA_BRIDGE_MRP_IN_ROLE_MAX + 1] = {
	[IFLA_BRIDGE_MRP_IN_ROLE_UNSPEC]	= { .type = NLA_REJECT },
	[IFLA_BRIDGE_MRP_IN_ROLE_RING_ID]	= { .type = NLA_U32 },
	[IFLA_BRIDGE_MRP_IN_ROLE_IN_ID]		= { .type = NLA_U16 },
	[IFLA_BRIDGE_MRP_IN_ROLE_ROLE]		= { .type = NLA_U32 },
	[IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX]	= { .type = NLA_U32 },
};

static int br_mrp_in_role_parse(struct net_bridge *br, struct nlattr *attr,
				struct netlink_ext_ack *extack)
{
	struct nlattr *tb[IFLA_BRIDGE_MRP_IN_ROLE_MAX + 1];
	struct br_mrp_in_role role;
	int err;

	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_IN_ROLE_MAX, attr,
			       br_mrp_in_role_policy, extack);
	if (err)
		return err;

	if (!tb[IFLA_BRIDGE_MRP_IN_ROLE_RING_ID] ||
	    !tb[IFLA_BRIDGE_MRP_IN_ROLE_IN_ID] ||
	    !tb[IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX] ||
	    !tb[IFLA_BRIDGE_MRP_IN_ROLE_ROLE]) {
		NL_SET_ERR_MSG_MOD(extack,
				   "Missing attribute: RING_ID or ROLE or IN_ID or I_IFINDEX");
		return -EINVAL;
	}

	memset(&role, 0x0, sizeof(role));

	role.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_RING_ID]);
	role.in_id = nla_get_u16(tb[IFLA_BRIDGE_MRP_IN_ROLE_IN_ID]);
	role.i_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX]);
	role.in_role = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_ROLE]);

	return br_mrp_set_in_role(br, &role);
}

static const struct nla_policy
br_mrp_start_in_test_policy[IFLA_BRIDGE_MRP_START_IN_TEST_MAX + 1] = {
	[IFLA_BRIDGE_MRP_START_IN_TEST_UNSPEC]	= { .type = NLA_REJECT },
	[IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID]	= { .type = NLA_U32 },
	[IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL]	= { .type = NLA_U32 },
	[IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS]	= { .type = NLA_U32 },
	[IFLA_BRIDGE_MRP_START_IN_TEST_PERIOD]	= { .type = NLA_U32 },
};

static int br_mrp_start_in_test_parse(struct net_bridge *br,
				      struct nlattr *attr,
				      struct netlink_ext_ack *extack)
{
	struct nlattr *tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX + 1];
	struct br_mrp_start_in_test test;
	int err;

	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_START_IN_TEST_MAX, attr,
			       br_mrp_start_in_test_policy, extack);
	if (err)
		return err;

	if (!tb[IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID] ||
	    !tb[IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL] ||
	    !tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS] ||
	    !tb[IFLA_BRIDGE_MRP_START_IN_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.in_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID]);
	test.interval = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL]);
	test.max_miss = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS]);
	test.period = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_PERIOD]);

	return br_mrp_start_in_test(br, &test);
}

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 *tb[IFLA_BRIDGE_MRP_MAX + 1];
	int err;

	/* When this function is called for a port then the br pointer is
	 * invalid, therefor set the br to point correctly
	 */
	if (p)
		br = p->br;

	if (br->stp_enabled != BR_NO_STP) {
		NL_SET_ERR_MSG_MOD(extack, "MRP can't be enabled if STP is already enabled");
		return -EINVAL;
	}

	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_MAX, attr,
			       br_mrp_policy, extack);
	if (err)
		return err;

	if (tb[IFLA_BRIDGE_MRP_INSTANCE]) {
		err = br_mrp_instance_parse(br, tb[IFLA_BRIDGE_MRP_INSTANCE],
					    cmd, extack);
		if (err)
			return err;
	}

	if (tb[IFLA_BRIDGE_MRP_PORT_STATE]) {
		err = br_mrp_port_state_parse(p, tb[IFLA_BRIDGE_MRP_PORT_STATE],
					      extack);
		if (err)
			return err;
	}

	if (tb[IFLA_BRIDGE_MRP_PORT_ROLE]) {
		err = br_mrp_port_role_parse(p, tb[IFLA_BRIDGE_MRP_PORT_ROLE],
					     extack);
		if (err)
			return err;
	}

	if (tb[IFLA_BRIDGE_MRP_RING_STATE]) {
		err = br_mrp_ring_state_parse(br,
					      tb[IFLA_BRIDGE_MRP_RING_STATE],
					      extack);
		if (err)
			return err;
	}

	if (tb[IFLA_BRIDGE_MRP_RING_ROLE]) {
		err = br_mrp_ring_role_parse(br, tb[IFLA_BRIDGE_MRP_RING_ROLE],
					     extack);
		if (err)
			return err;
	}

	if (tb[IFLA_BRIDGE_MRP_START_TEST]) {
		err = br_mrp_start_test_parse(br,
					      tb[IFLA_BRIDGE_MRP_START_TEST],
					      extack);
		if (err)
			return err;
	}

	if (tb[IFLA_BRIDGE_MRP_IN_STATE]) {
		err = br_mrp_in_state_parse(br, tb[IFLA_BRIDGE_MRP_IN_STATE],
					    extack);
		if (err)
			return err;
	}

	if (tb[IFLA_BRIDGE_MRP_IN_ROLE]) {
		err = br_mrp_in_role_parse(br, tb[IFLA_BRIDGE_MRP_IN_ROLE],
					   extack);
		if (err)
			return err;
	}

	if (tb[IFLA_BRIDGE_MRP_START_IN_TEST]) {
		err = br_mrp_start_in_test_parse(br,
						 tb[IFLA_BRIDGE_MRP_START_IN_TEST],
						 extack);
		if (err)
			return err;
	}

	return 0;
}

int br_mrp_fill_info(struct sk_buff *skb, struct net_bridge *br)
{
	struct nlattr *tb, *mrp_tb;
	struct br_mrp *mrp;

	mrp_tb = nla_nest_start_noflag(skb, IFLA_BRIDGE_MRP);
	if (!mrp_tb)
		return -EMSGSIZE;

	hlist_for_each_entry_rcu(mrp, &br->mrp_list, list) {
		struct net_bridge_port *p;

		tb = nla_nest_start_noflag(skb, IFLA_BRIDGE_MRP_INFO);
		if (!tb)
			goto nla_info_failure;

		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_ID,
				mrp->ring_id))
			goto nla_put_failure;

		p = rcu_dereference(mrp->p_port);
		if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_P_IFINDEX,
				     p->dev->ifindex))
			goto nla_put_failure;

		p = rcu_dereference(mrp->s_port);
		if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_S_IFINDEX,
				     p->dev->ifindex))
			goto nla_put_failure;

		p = rcu_dereference(mrp->i_port);
		if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_I_IFINDEX,
				     p->dev->ifindex))
			goto nla_put_failure;

		if (nla_put_u16(skb, IFLA_BRIDGE_MRP_INFO_PRIO,
				mrp->prio))
			goto nla_put_failure;
		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_STATE,
				mrp->ring_state))
			goto nla_put_failure;
		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_ROLE,
				mrp->ring_role))
			goto nla_put_failure;
		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_INTERVAL,
				mrp->test_interval))
			goto nla_put_failure;
		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_MAX_MISS,
				mrp->test_max_miss))
			goto nla_put_failure;
		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_MONITOR,
				mrp->test_monitor))
			goto nla_put_failure;

		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_STATE,
				mrp->in_state))
			goto nla_put_failure;
		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_ROLE,
				mrp->in_role))
			goto nla_put_failure;
		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_TEST_INTERVAL,
				mrp->in_test_interval))
			goto nla_put_failure;
		if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_TEST_MAX_MISS,
				mrp->in_test_max_miss))
			goto nla_put_failure;

		nla_nest_end(skb, tb);
	}
	nla_nest_end(skb, mrp_tb);

	return 0;

nla_put_failure:
	nla_nest_cancel(skb, tb);

nla_info_failure:
	nla_nest_cancel(skb, mrp_tb);

	return -EMSGSIZE;
}

int br_mrp_ring_port_open(struct net_device *dev, u8 loc)
{
	struct net_bridge_port *p;
	int err = 0;

	p = br_port_get_rcu(dev);
	if (!p) {
		err = -EINVAL;
		goto out;
	}

	if (loc)
		p->flags |= BR_MRP_LOST_CONT;
	else
		p->flags &= ~BR_MRP_LOST_CONT;

	br_ifinfo_notify(RTM_NEWLINK, NULL, p);

out:
	return err;
}

int br_mrp_in_port_open(struct net_device *dev, u8 loc)
{
	struct net_bridge_port *p;
	int err = 0;

	p = br_port_get_rcu(dev);
	if (!p) {
		err = -EINVAL;
		goto out;
	}

	if (loc)
		p->flags |= BR_MRP_LOST_IN_CONT;
	else
		p->flags &= ~BR_MRP_LOST_IN_CONT;

	br_ifinfo_notify(RTM_NEWLINK, NULL, p);

out:
	return err;
}
Commit	Line	Data
9a9f26e8 HV	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2
	3	#include <net/genetlink.h>
	4
	5	#include <uapi/linux/mrp_bridge.h>
	6	#include "br_private.h"
	7	#include "br_private_mrp.h"
	8
4d02b8f0 HV	9	static const struct nla_policy br_mrp_policy[IFLA_BRIDGE_MRP_MAX + 1] = {
4d02b8f0 HV	10	[IFLA_BRIDGE_MRP_UNSPEC] = { .type = NLA_REJECT },
20f6a05e HV	11	[IFLA_BRIDGE_MRP_INSTANCE] = { .type = NLA_NESTED },
	12	[IFLA_BRIDGE_MRP_PORT_STATE] = { .type = NLA_NESTED },
	13	[IFLA_BRIDGE_MRP_PORT_ROLE] = { .type = NLA_NESTED },
	14	[IFLA_BRIDGE_MRP_RING_STATE] = { .type = NLA_NESTED },
	15	[IFLA_BRIDGE_MRP_RING_ROLE] = { .type = NLA_NESTED },
	16	[IFLA_BRIDGE_MRP_START_TEST] = { .type = NLA_NESTED },
7ab1748e HV	17	[IFLA_BRIDGE_MRP_IN_ROLE] = { .type = NLA_NESTED },
	18	[IFLA_BRIDGE_MRP_IN_STATE] = { .type = NLA_NESTED },
	19	[IFLA_BRIDGE_MRP_START_IN_TEST] = { .type = NLA_NESTED },
4d02b8f0 HV	20	};
4d02b8f0 HV	21
20f6a05e HV	22	static const struct nla_policy
	23	br_mrp_instance_policy[IFLA_BRIDGE_MRP_INSTANCE_MAX + 1] = {
	24	[IFLA_BRIDGE_MRP_INSTANCE_UNSPEC] = { .type = NLA_REJECT },
	25	[IFLA_BRIDGE_MRP_INSTANCE_RING_ID] = { .type = NLA_U32 },
	26	[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX] = { .type = NLA_U32 },
	27	[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX] = { .type = NLA_U32 },
4b3a61b0	28	[IFLA_BRIDGE_MRP_INSTANCE_PRIO] = { .type = NLA_U16 },
20f6a05e HV	29	};
	30
	31	static int br_mrp_instance_parse(struct net_bridge br, struct nlattr attr,
	32	int cmd, struct netlink_ext_ack *extack)
	33	{
	34	struct nlattr *tb[IFLA_BRIDGE_MRP_INSTANCE_MAX + 1];
	35	struct br_mrp_instance inst;
	36	int err;
	37
	38	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_INSTANCE_MAX, attr,
	39	br_mrp_instance_policy, extack);
	40	if (err)
	41	return err;
	42
	43	if (!tb[IFLA_BRIDGE_MRP_INSTANCE_RING_ID] \|\|
	44	!tb[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX] \|\|
	45	!tb[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]) {
	46	NL_SET_ERR_MSG_MOD(extack,
	47	"Missing attribute: RING_ID or P_IFINDEX or S_IFINDEX");
	48	return -EINVAL;
	49	}
	50
	51	memset(&inst, 0, sizeof(inst));
	52
	53	inst.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_RING_ID]);
	54	inst.p_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX]);
	55	inst.s_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]);
4b3a61b0 HV	56	inst.prio = MRP_DEFAULT_PRIO;
	57
	58	if (tb[IFLA_BRIDGE_MRP_INSTANCE_PRIO])
	59	inst.prio = nla_get_u16(tb[IFLA_BRIDGE_MRP_INSTANCE_PRIO]);
20f6a05e HV	60
	61	if (cmd == RTM_SETLINK)
	62	return br_mrp_add(br, &inst);
	63	else
	64	return br_mrp_del(br, &inst);
	65
	66	return 0;
	67	}
	68
	69	static const struct nla_policy
	70	br_mrp_port_state_policy[IFLA_BRIDGE_MRP_PORT_STATE_MAX + 1] = {
	71	[IFLA_BRIDGE_MRP_PORT_STATE_UNSPEC] = { .type = NLA_REJECT },
	72	[IFLA_BRIDGE_MRP_PORT_STATE_STATE] = { .type = NLA_U32 },
	73	};
	74
	75	static int br_mrp_port_state_parse(struct net_bridge_port *p,
	76	struct nlattr *attr,
	77	struct netlink_ext_ack *extack)
	78	{
	79	struct nlattr *tb[IFLA_BRIDGE_MRP_PORT_STATE_MAX + 1];
	80	enum br_mrp_port_state_type state;
	81	int err;
	82
	83	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_PORT_STATE_MAX, attr,
	84	br_mrp_port_state_policy, extack);
	85	if (err)
	86	return err;
	87
	88	if (!tb[IFLA_BRIDGE_MRP_PORT_STATE_STATE]) {
	89	NL_SET_ERR_MSG_MOD(extack, "Missing attribute: STATE");
	90	return -EINVAL;
	91	}
	92
	93	state = nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_STATE_STATE]);
	94
	95	return br_mrp_set_port_state(p, state);
	96	}
	97
	98	static const struct nla_policy
	99	br_mrp_port_role_policy[IFLA_BRIDGE_MRP_PORT_ROLE_MAX + 1] = {
	100	[IFLA_BRIDGE_MRP_PORT_ROLE_UNSPEC] = { .type = NLA_REJECT },
	101	[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE] = { .type = NLA_U32 },
	102	};
	103
	104	static int br_mrp_port_role_parse(struct net_bridge_port *p,
	105	struct nlattr *attr,
	106	struct netlink_ext_ack *extack)
	107	{
	108	struct nlattr *tb[IFLA_BRIDGE_MRP_PORT_ROLE_MAX + 1];
	109	enum br_mrp_port_role_type role;
	110	int err;
	111
	112	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_PORT_ROLE_MAX, attr,
	113	br_mrp_port_role_policy, extack);
	114	if (err)
	115	return err;
	116
	117	if (!tb[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]) {
	118	NL_SET_ERR_MSG_MOD(extack, "Missing attribute: ROLE");
	119	return -EINVAL;
	120	}
	121
	122	role = nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]);
	123
124	return br_mrp_set_port_role(p, role);
125	}
126
127	static const struct nla_policy
128	br_mrp_ring_state_policy[IFLA_BRIDGE_MRP_RING_STATE_MAX + 1] = {
129	[IFLA_BRIDGE_MRP_RING_STATE_UNSPEC] = { .type = NLA_REJECT },
130	[IFLA_BRIDGE_MRP_RING_STATE_RING_ID] = { .type = NLA_U32 },
131	[IFLA_BRIDGE_MRP_RING_STATE_STATE] = { .type = NLA_U32 },
132	};
133
134	static int br_mrp_ring_state_parse(struct net_bridge br, struct nlattr attr,
135	struct netlink_ext_ack *extack)
136	{
137	struct nlattr *tb[IFLA_BRIDGE_MRP_RING_STATE_MAX + 1];
138	struct br_mrp_ring_state state;
139	int err;
140
141	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_RING_STATE_MAX, attr,
142	br_mrp_ring_state_policy, extack);
143	if (err)
144	return err;
145
146	if (!tb[IFLA_BRIDGE_MRP_RING_STATE_RING_ID] \|\|
147	!tb[IFLA_BRIDGE_MRP_RING_STATE_STATE]) {
148	NL_SET_ERR_MSG_MOD(extack,
149	"Missing attribute: RING_ID or STATE");
150	return -EINVAL;
151	}
152
153	memset(&state, 0x0, sizeof(state));
154
155	state.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_STATE_RING_ID]);
156	state.ring_state = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_STATE_STATE]);
157
158	return br_mrp_set_ring_state(br, &state);
159	}
160
161	static const struct nla_policy
162	br_mrp_ring_role_policy[IFLA_BRIDGE_MRP_RING_ROLE_MAX + 1] = {
163	[IFLA_BRIDGE_MRP_RING_ROLE_UNSPEC] = { .type = NLA_REJECT },
164	[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID] = { .type = NLA_U32 },
165	[IFLA_BRIDGE_MRP_RING_ROLE_ROLE] = { .type = NLA_U32 },
166	};
167
168	static int br_mrp_ring_role_parse(struct net_bridge br, struct nlattr attr,
169	struct netlink_ext_ack *extack)
170	{
171	struct nlattr *tb[IFLA_BRIDGE_MRP_RING_ROLE_MAX + 1];
172	struct br_mrp_ring_role role;
173	int err;
174
175	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_RING_ROLE_MAX, attr,
176	br_mrp_ring_role_policy, extack);
177	if (err)
178	return err;
179
180	if (!tb[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID] \|\|
181	!tb[IFLA_BRIDGE_MRP_RING_ROLE_ROLE]) {
182	NL_SET_ERR_MSG_MOD(extack,
183	"Missing attribute: RING_ID or ROLE");
184	return -EINVAL;
185	}
186
187	memset(&role, 0x0, sizeof(role));
188
189	role.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID]);
190	role.ring_role = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_ROLE_ROLE]);
191
192	return br_mrp_set_ring_role(br, &role);
193	}
194
195	static const struct nla_policy
196	br_mrp_start_test_policy[IFLA_BRIDGE_MRP_START_TEST_MAX + 1] = {
197	[IFLA_BRIDGE_MRP_START_TEST_UNSPEC] = { .type = NLA_REJECT },
198	[IFLA_BRIDGE_MRP_START_TEST_RING_ID] = { .type = NLA_U32 },
199	[IFLA_BRIDGE_MRP_START_TEST_INTERVAL] = { .type = NLA_U32 },
200	[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS] = { .type = NLA_U32 },
201	[IFLA_BRIDGE_MRP_START_TEST_PERIOD] = { .type = NLA_U32 },
c6676e7d	202	[IFLA_BRIDGE_MRP_START_TEST_MONITOR] = { .type = NLA_U32 },
20f6a05e HV	203	};
	204
	205	static int br_mrp_start_test_parse(struct net_bridge br, struct nlattr attr,
	206	struct netlink_ext_ack *extack)
	207	{
	208	struct nlattr *tb[IFLA_BRIDGE_MRP_START_TEST_MAX + 1];
	209	struct br_mrp_start_test test;
	210	int err;
	211
	212	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_START_TEST_MAX, attr,
	213	br_mrp_start_test_policy, extack);
	214	if (err)
	215	return err;
	216
	217	if (!tb[IFLA_BRIDGE_MRP_START_TEST_RING_ID] \|\|
	218	!tb[IFLA_BRIDGE_MRP_START_TEST_INTERVAL] \|\|
	219	!tb[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS] \|\|
	220	!tb[IFLA_BRIDGE_MRP_START_TEST_PERIOD]) {
	221	NL_SET_ERR_MSG_MOD(extack,
	222	"Missing attribute: RING_ID or INTERVAL or MAX_MISS or PERIOD");
	223	return -EINVAL;
	224	}
	225
	226	memset(&test, 0x0, sizeof(test));
	227
	228	test.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_RING_ID]);
	229	test.interval = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_INTERVAL]);
	230	test.max_miss = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS]);
	231	test.period = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_PERIOD]);
c6676e7d HV	232	test.monitor = false;
	233
	234	if (tb[IFLA_BRIDGE_MRP_START_TEST_MONITOR])
	235	test.monitor =
	236	nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_MONITOR]);
20f6a05e HV	237
	238	return br_mrp_start_test(br, &test);
	239	}
	240
7ab1748e HV	241	static const struct nla_policy
	242	br_mrp_in_state_policy[IFLA_BRIDGE_MRP_IN_STATE_MAX + 1] = {
	243	[IFLA_BRIDGE_MRP_IN_STATE_UNSPEC] = { .type = NLA_REJECT },
	244	[IFLA_BRIDGE_MRP_IN_STATE_IN_ID] = { .type = NLA_U32 },
	245	[IFLA_BRIDGE_MRP_IN_STATE_STATE] = { .type = NLA_U32 },
	246	};
	247
	248	static int br_mrp_in_state_parse(struct net_bridge br, struct nlattr attr,
	249	struct netlink_ext_ack *extack)
	250	{
	251	struct nlattr *tb[IFLA_BRIDGE_MRP_IN_STATE_MAX + 1];
	252	struct br_mrp_in_state state;
	253	int err;
	254
	255	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_IN_STATE_MAX, attr,
	256	br_mrp_in_state_policy, extack);
	257	if (err)
	258	return err;
	259
	260	if (!tb[IFLA_BRIDGE_MRP_IN_STATE_IN_ID] \|\|
	261	!tb[IFLA_BRIDGE_MRP_IN_STATE_STATE]) {
	262	NL_SET_ERR_MSG_MOD(extack,
	263	"Missing attribute: IN_ID or STATE");
	264	return -EINVAL;
	265	}
	266
	267	memset(&state, 0x0, sizeof(state));
	268
	269	state.in_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_STATE_IN_ID]);
	270	state.in_state = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_STATE_STATE]);
	271
	272	return br_mrp_set_in_state(br, &state);
	273	}
	274
	275	static const struct nla_policy
	276	br_mrp_in_role_policy[IFLA_BRIDGE_MRP_IN_ROLE_MAX + 1] = {
	277	[IFLA_BRIDGE_MRP_IN_ROLE_UNSPEC] = { .type = NLA_REJECT },
	278	[IFLA_BRIDGE_MRP_IN_ROLE_RING_ID] = { .type = NLA_U32 },
	279	[IFLA_BRIDGE_MRP_IN_ROLE_IN_ID] = { .type = NLA_U16 },
	280	[IFLA_BRIDGE_MRP_IN_ROLE_ROLE] = { .type = NLA_U32 },
	281	[IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX] = { .type = NLA_U32 },
	282	};
	283
	284	static int br_mrp_in_role_parse(struct net_bridge br, struct nlattr attr,
	285	struct netlink_ext_ack *extack)
	286	{
	287	struct nlattr *tb[IFLA_BRIDGE_MRP_IN_ROLE_MAX + 1];
	288	struct br_mrp_in_role role;
	289	int err;
	290
	291	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_IN_ROLE_MAX, attr,
	292	br_mrp_in_role_policy, extack);
	293	if (err)
	294	return err;
	295
	296	if (!tb[IFLA_BRIDGE_MRP_IN_ROLE_RING_ID] \|\|
	297	!tb[IFLA_BRIDGE_MRP_IN_ROLE_IN_ID] \|\|
	298	!tb[IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX] \|\|
	299	!tb[IFLA_BRIDGE_MRP_IN_ROLE_ROLE]) {
	300	NL_SET_ERR_MSG_MOD(extack,
	301	"Missing attribute: RING_ID or ROLE or IN_ID or I_IFINDEX");
	302	return -EINVAL;
	303	}
	304
305	memset(&role, 0x0, sizeof(role));
306
307	role.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_RING_ID]);
308	role.in_id = nla_get_u16(tb[IFLA_BRIDGE_MRP_IN_ROLE_IN_ID]);
309	role.i_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX]);
310	role.in_role = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_ROLE]);
311
312	return br_mrp_set_in_role(br, &role);
313	}
314
315	static const struct nla_policy
316	br_mrp_start_in_test_policy[IFLA_BRIDGE_MRP_START_IN_TEST_MAX + 1] = {
317	[IFLA_BRIDGE_MRP_START_IN_TEST_UNSPEC] = { .type = NLA_REJECT },
318	[IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID] = { .type = NLA_U32 },
319	[IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL] = { .type = NLA_U32 },
320	[IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS] = { .type = NLA_U32 },
321	[IFLA_BRIDGE_MRP_START_IN_TEST_PERIOD] = { .type = NLA_U32 },
322	};
323
324	static int br_mrp_start_in_test_parse(struct net_bridge *br,
325	struct nlattr *attr,
326	struct netlink_ext_ack *extack)
327	{
328	struct nlattr *tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX + 1];
329	struct br_mrp_start_in_test test;
330	int err;
331
332	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_START_IN_TEST_MAX, attr,
333	br_mrp_start_in_test_policy, extack);
334	if (err)
335	return err;
336
337	if (!tb[IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID] \|\|
338	!tb[IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL] \|\|
339	!tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS] \|\|
340	!tb[IFLA_BRIDGE_MRP_START_IN_TEST_PERIOD]) {
341	NL_SET_ERR_MSG_MOD(extack,
342	"Missing attribute: RING_ID or INTERVAL or MAX_MISS or PERIOD");
343	return -EINVAL;
344	}
345
346	memset(&test, 0x0, sizeof(test));
347
348	test.in_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID]);
349	test.interval = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL]);
350	test.max_miss = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS]);
351	test.period = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_PERIOD]);
352
353	return br_mrp_start_in_test(br, &test);
354	}
355
4d02b8f0 HV	356	int br_mrp_parse(struct net_bridge br, struct net_bridge_port p,
	357	struct nlattr attr, int cmd, struct netlink_ext_ack extack)
	358	{
	359	struct nlattr *tb[IFLA_BRIDGE_MRP_MAX + 1];
	360	int err;
	361
617504c6 HV	362	/* When this function is called for a port then the br pointer is
	363	* invalid, therefor set the br to point correctly
	364	*/
	365	if (p)
	366	br = p->br;
	367
4d02b8f0	368	if (br->stp_enabled != BR_NO_STP) {
c75a33c8	369	NL_SET_ERR_MSG_MOD(extack, "MRP can't be enabled if STP is already enabled");
4d02b8f0 HV	370	return -EINVAL;
	371	}
	372
	373	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_MAX, attr,
	374	br_mrp_policy, extack);
	375	if (err)
	376	return err;
	377
	378	if (tb[IFLA_BRIDGE_MRP_INSTANCE]) {
20f6a05e HV	379	err = br_mrp_instance_parse(br, tb[IFLA_BRIDGE_MRP_INSTANCE],
20f6a05e HV	380	cmd, extack);
4d02b8f0 HV	381	if (err)
	382	return err;
	383	}
	384
	385	if (tb[IFLA_BRIDGE_MRP_PORT_STATE]) {
20f6a05e HV	386	err = br_mrp_port_state_parse(p, tb[IFLA_BRIDGE_MRP_PORT_STATE],
20f6a05e HV	387	extack);
4d02b8f0 HV	388	if (err)
	389	return err;
	390	}
	391
	392	if (tb[IFLA_BRIDGE_MRP_PORT_ROLE]) {
20f6a05e HV	393	err = br_mrp_port_role_parse(p, tb[IFLA_BRIDGE_MRP_PORT_ROLE],
20f6a05e HV	394	extack);
4d02b8f0 HV	395	if (err)
	396	return err;
	397	}
	398
	399	if (tb[IFLA_BRIDGE_MRP_RING_STATE]) {
20f6a05e HV	400	err = br_mrp_ring_state_parse(br,
	401	tb[IFLA_BRIDGE_MRP_RING_STATE],
	402	extack);
4d02b8f0 HV	403	if (err)
	404	return err;
	405	}
	406
	407	if (tb[IFLA_BRIDGE_MRP_RING_ROLE]) {
20f6a05e HV	408	err = br_mrp_ring_role_parse(br, tb[IFLA_BRIDGE_MRP_RING_ROLE],
20f6a05e HV	409	extack);
4d02b8f0 HV	410	if (err)
	411	return err;
	412	}
	413
	414	if (tb[IFLA_BRIDGE_MRP_START_TEST]) {
20f6a05e HV	415	err = br_mrp_start_test_parse(br,
	416	tb[IFLA_BRIDGE_MRP_START_TEST],
	417	extack);
4d02b8f0 HV	418	if (err)
	419	return err;
	420	}
	421
7ab1748e HV	422	if (tb[IFLA_BRIDGE_MRP_IN_STATE]) {
	423	err = br_mrp_in_state_parse(br, tb[IFLA_BRIDGE_MRP_IN_STATE],
	424	extack);
	425	if (err)
	426	return err;
	427	}
	428
	429	if (tb[IFLA_BRIDGE_MRP_IN_ROLE]) {
	430	err = br_mrp_in_role_parse(br, tb[IFLA_BRIDGE_MRP_IN_ROLE],
	431	extack);
	432	if (err)
	433	return err;
	434	}
	435
	436	if (tb[IFLA_BRIDGE_MRP_START_IN_TEST]) {
	437	err = br_mrp_start_in_test_parse(br,
	438	tb[IFLA_BRIDGE_MRP_START_IN_TEST],
	439	extack);
	440	if (err)
	441	return err;
	442	}
	443
4d02b8f0 HV	444	return 0;
	445	}
	446
df42ef22 HV	447	int br_mrp_fill_info(struct sk_buff skb, struct net_bridge br)
	448	{
	449	struct nlattr tb, mrp_tb;
	450	struct br_mrp *mrp;
	451
	452	mrp_tb = nla_nest_start_noflag(skb, IFLA_BRIDGE_MRP);
	453	if (!mrp_tb)
	454	return -EMSGSIZE;
	455
0169b820	456	hlist_for_each_entry_rcu(mrp, &br->mrp_list, list) {
df42ef22 HV	457	struct net_bridge_port *p;
	458
	459	tb = nla_nest_start_noflag(skb, IFLA_BRIDGE_MRP_INFO);
	460	if (!tb)
	461	goto nla_info_failure;
	462
	463	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_ID,
	464	mrp->ring_id))
	465	goto nla_put_failure;
	466
	467	p = rcu_dereference(mrp->p_port);
	468	if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_P_IFINDEX,
	469	p->dev->ifindex))
	470	goto nla_put_failure;
	471
	472	p = rcu_dereference(mrp->s_port);
	473	if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_S_IFINDEX,
	474	p->dev->ifindex))
	475	goto nla_put_failure;
	476
4fc4871f HV	477	p = rcu_dereference(mrp->i_port);
	478	if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_I_IFINDEX,
	479	p->dev->ifindex))
	480	goto nla_put_failure;
	481
df42ef22 HV	482	if (nla_put_u16(skb, IFLA_BRIDGE_MRP_INFO_PRIO,
	483	mrp->prio))
	484	goto nla_put_failure;
	485	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_STATE,
	486	mrp->ring_state))
	487	goto nla_put_failure;
	488	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_ROLE,
	489	mrp->ring_role))
	490	goto nla_put_failure;
	491	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_INTERVAL,
	492	mrp->test_interval))
	493	goto nla_put_failure;
	494	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_MAX_MISS,
	495	mrp->test_max_miss))
	496	goto nla_put_failure;
	497	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_MONITOR,
	498	mrp->test_monitor))
	499	goto nla_put_failure;
	500
4fc4871f HV	501	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_STATE,
	502	mrp->in_state))
	503	goto nla_put_failure;
	504	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_ROLE,
	505	mrp->in_role))
	506	goto nla_put_failure;
	507	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_TEST_INTERVAL,
	508	mrp->in_test_interval))
	509	goto nla_put_failure;
	510	if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_TEST_MAX_MISS,
	511	mrp->in_test_max_miss))
	512	goto nla_put_failure;
	513
df42ef22 HV	514	nla_nest_end(skb, tb);
	515	}
	516	nla_nest_end(skb, mrp_tb);
	517
	518	return 0;
	519
	520	nla_put_failure:
	521	nla_nest_cancel(skb, tb);
	522
	523	nla_info_failure:
	524	nla_nest_cancel(skb, mrp_tb);
	525
	526	return -EMSGSIZE;
	527	}
	528
4cc625c6	529	int br_mrp_ring_port_open(struct net_device *dev, u8 loc)
9a9f26e8 HV	530	{
	531	struct net_bridge_port *p;
	532	int err = 0;
	533
	534	p = br_port_get_rcu(dev);
	535	if (!p) {
	536	err = -EINVAL;
	537	goto out;
	538	}
	539
	540	if (loc)
	541	p->flags \|= BR_MRP_LOST_CONT;
	542	else
	543	p->flags &= ~BR_MRP_LOST_CONT;
	544
	545	br_ifinfo_notify(RTM_NEWLINK, NULL, p);
	546
	547	out:
	548	return err;
	549	}
4139d4b5 HV	550
	551	int br_mrp_in_port_open(struct net_device *dev, u8 loc)
	552	{
	553	struct net_bridge_port *p;
	554	int err = 0;
	555
	556	p = br_port_get_rcu(dev);
	557	if (!p) {
	558	err = -EINVAL;
	559	goto out;
	560	}
	561
	562	if (loc)
	563	p->flags \|= BR_MRP_LOST_IN_CONT;
	564	else
	565	p->flags &= ~BR_MRP_LOST_IN_CONT;
	566
	567	br_ifinfo_notify(RTM_NEWLINK, NULL, p);
	568
	569	out:
	570	return err;
	571	}