[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 },
};

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 },
};

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,
		 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;
	}

	return 0;
}

int br_mrp_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;
}
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 },
4d02b8f0 HV	17	};
4d02b8f0 HV	18
20f6a05e HV	19	static const struct nla_policy
	20	br_mrp_instance_policy[IFLA_BRIDGE_MRP_INSTANCE_MAX + 1] = {
	21	[IFLA_BRIDGE_MRP_INSTANCE_UNSPEC] = { .type = NLA_REJECT },
	22	[IFLA_BRIDGE_MRP_INSTANCE_RING_ID] = { .type = NLA_U32 },
	23	[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX] = { .type = NLA_U32 },
	24	[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX] = { .type = NLA_U32 },
4b3a61b0	25	[IFLA_BRIDGE_MRP_INSTANCE_PRIO] = { .type = NLA_U16 },
20f6a05e HV	26	};
	27
	28	static int br_mrp_instance_parse(struct net_bridge br, struct nlattr attr,
	29	int cmd, struct netlink_ext_ack *extack)
	30	{
	31	struct nlattr *tb[IFLA_BRIDGE_MRP_INSTANCE_MAX + 1];
	32	struct br_mrp_instance inst;
	33	int err;
	34
	35	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_INSTANCE_MAX, attr,
	36	br_mrp_instance_policy, extack);
	37	if (err)
	38	return err;
	39
	40	if (!tb[IFLA_BRIDGE_MRP_INSTANCE_RING_ID] \|\|
	41	!tb[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX] \|\|
	42	!tb[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]) {
	43	NL_SET_ERR_MSG_MOD(extack,
	44	"Missing attribute: RING_ID or P_IFINDEX or S_IFINDEX");
	45	return -EINVAL;
	46	}
	47
	48	memset(&inst, 0, sizeof(inst));
	49
	50	inst.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_RING_ID]);
	51	inst.p_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX]);
	52	inst.s_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]);
4b3a61b0 HV	53	inst.prio = MRP_DEFAULT_PRIO;
	54
	55	if (tb[IFLA_BRIDGE_MRP_INSTANCE_PRIO])
	56	inst.prio = nla_get_u16(tb[IFLA_BRIDGE_MRP_INSTANCE_PRIO]);
20f6a05e HV	57
	58	if (cmd == RTM_SETLINK)
	59	return br_mrp_add(br, &inst);
	60	else
	61	return br_mrp_del(br, &inst);
	62
	63	return 0;
	64	}
	65
	66	static const struct nla_policy
	67	br_mrp_port_state_policy[IFLA_BRIDGE_MRP_PORT_STATE_MAX + 1] = {
	68	[IFLA_BRIDGE_MRP_PORT_STATE_UNSPEC] = { .type = NLA_REJECT },
	69	[IFLA_BRIDGE_MRP_PORT_STATE_STATE] = { .type = NLA_U32 },
	70	};
	71
	72	static int br_mrp_port_state_parse(struct net_bridge_port *p,
	73	struct nlattr *attr,
	74	struct netlink_ext_ack *extack)
	75	{
	76	struct nlattr *tb[IFLA_BRIDGE_MRP_PORT_STATE_MAX + 1];
	77	enum br_mrp_port_state_type state;
	78	int err;
	79
	80	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_PORT_STATE_MAX, attr,
	81	br_mrp_port_state_policy, extack);
	82	if (err)
	83	return err;
	84
	85	if (!tb[IFLA_BRIDGE_MRP_PORT_STATE_STATE]) {
	86	NL_SET_ERR_MSG_MOD(extack, "Missing attribute: STATE");
	87	return -EINVAL;
	88	}
	89
	90	state = nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_STATE_STATE]);
	91
	92	return br_mrp_set_port_state(p, state);
	93	}
	94
	95	static const struct nla_policy
	96	br_mrp_port_role_policy[IFLA_BRIDGE_MRP_PORT_ROLE_MAX + 1] = {
	97	[IFLA_BRIDGE_MRP_PORT_ROLE_UNSPEC] = { .type = NLA_REJECT },
	98	[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE] = { .type = NLA_U32 },
	99	};
	100
	101	static int br_mrp_port_role_parse(struct net_bridge_port *p,
	102	struct nlattr *attr,
	103	struct netlink_ext_ack *extack)
	104	{
	105	struct nlattr *tb[IFLA_BRIDGE_MRP_PORT_ROLE_MAX + 1];
	106	enum br_mrp_port_role_type role;
	107	int err;
	108
	109	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_PORT_ROLE_MAX, attr,
	110	br_mrp_port_role_policy, extack);
	111	if (err)
	112	return err;
	113
	114	if (!tb[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]) {
	115	NL_SET_ERR_MSG_MOD(extack, "Missing attribute: ROLE");
	116	return -EINVAL;
	117	}
	118
	119	role = nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]);
	120
121	return br_mrp_set_port_role(p, role);
122	}
123
124	static const struct nla_policy
125	br_mrp_ring_state_policy[IFLA_BRIDGE_MRP_RING_STATE_MAX + 1] = {
126	[IFLA_BRIDGE_MRP_RING_STATE_UNSPEC] = { .type = NLA_REJECT },
127	[IFLA_BRIDGE_MRP_RING_STATE_RING_ID] = { .type = NLA_U32 },
128	[IFLA_BRIDGE_MRP_RING_STATE_STATE] = { .type = NLA_U32 },
129	};
130
131	static int br_mrp_ring_state_parse(struct net_bridge br, struct nlattr attr,
132	struct netlink_ext_ack *extack)
133	{
134	struct nlattr *tb[IFLA_BRIDGE_MRP_RING_STATE_MAX + 1];
135	struct br_mrp_ring_state state;
136	int err;
137
138	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_RING_STATE_MAX, attr,
139	br_mrp_ring_state_policy, extack);
140	if (err)
141	return err;
142
143	if (!tb[IFLA_BRIDGE_MRP_RING_STATE_RING_ID] \|\|
144	!tb[IFLA_BRIDGE_MRP_RING_STATE_STATE]) {
145	NL_SET_ERR_MSG_MOD(extack,
146	"Missing attribute: RING_ID or STATE");
147	return -EINVAL;
148	}
149
150	memset(&state, 0x0, sizeof(state));
151
152	state.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_STATE_RING_ID]);
153	state.ring_state = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_STATE_STATE]);
154
155	return br_mrp_set_ring_state(br, &state);
156	}
157
158	static const struct nla_policy
159	br_mrp_ring_role_policy[IFLA_BRIDGE_MRP_RING_ROLE_MAX + 1] = {
160	[IFLA_BRIDGE_MRP_RING_ROLE_UNSPEC] = { .type = NLA_REJECT },
161	[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID] = { .type = NLA_U32 },
162	[IFLA_BRIDGE_MRP_RING_ROLE_ROLE] = { .type = NLA_U32 },
163	};
164
165	static int br_mrp_ring_role_parse(struct net_bridge br, struct nlattr attr,
166	struct netlink_ext_ack *extack)
167	{
168	struct nlattr *tb[IFLA_BRIDGE_MRP_RING_ROLE_MAX + 1];
169	struct br_mrp_ring_role role;
170	int err;
171
172	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_RING_ROLE_MAX, attr,
173	br_mrp_ring_role_policy, extack);
174	if (err)
175	return err;
176
177	if (!tb[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID] \|\|
178	!tb[IFLA_BRIDGE_MRP_RING_ROLE_ROLE]) {
179	NL_SET_ERR_MSG_MOD(extack,
180	"Missing attribute: RING_ID or ROLE");
181	return -EINVAL;
182	}
183
184	memset(&role, 0x0, sizeof(role));
185
186	role.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID]);
187	role.ring_role = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_ROLE_ROLE]);
188
189	return br_mrp_set_ring_role(br, &role);
190	}
191
192	static const struct nla_policy
193	br_mrp_start_test_policy[IFLA_BRIDGE_MRP_START_TEST_MAX + 1] = {
194	[IFLA_BRIDGE_MRP_START_TEST_UNSPEC] = { .type = NLA_REJECT },
195	[IFLA_BRIDGE_MRP_START_TEST_RING_ID] = { .type = NLA_U32 },
196	[IFLA_BRIDGE_MRP_START_TEST_INTERVAL] = { .type = NLA_U32 },
197	[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS] = { .type = NLA_U32 },
198	[IFLA_BRIDGE_MRP_START_TEST_PERIOD] = { .type = NLA_U32 },
199	};
200
201	static int br_mrp_start_test_parse(struct net_bridge br, struct nlattr attr,
202	struct netlink_ext_ack *extack)
203	{
204	struct nlattr *tb[IFLA_BRIDGE_MRP_START_TEST_MAX + 1];
205	struct br_mrp_start_test test;
206	int err;
207
208	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_START_TEST_MAX, attr,
209	br_mrp_start_test_policy, extack);
210	if (err)
211	return err;
212
213	if (!tb[IFLA_BRIDGE_MRP_START_TEST_RING_ID] \|\|
214	!tb[IFLA_BRIDGE_MRP_START_TEST_INTERVAL] \|\|
215	!tb[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS] \|\|
216	!tb[IFLA_BRIDGE_MRP_START_TEST_PERIOD]) {
217	NL_SET_ERR_MSG_MOD(extack,
218	"Missing attribute: RING_ID or INTERVAL or MAX_MISS or PERIOD");
219	return -EINVAL;
220	}
221
222	memset(&test, 0x0, sizeof(test));
223
224	test.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_RING_ID]);
225	test.interval = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_INTERVAL]);
226	test.max_miss = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS]);
227	test.period = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_PERIOD]);
228
229	return br_mrp_start_test(br, &test);
230	}
231
4d02b8f0 HV	232	int br_mrp_parse(struct net_bridge br, struct net_bridge_port p,
	233	struct nlattr attr, int cmd, struct netlink_ext_ack extack)
	234	{
	235	struct nlattr *tb[IFLA_BRIDGE_MRP_MAX + 1];
	236	int err;
	237
617504c6 HV	238	/* When this function is called for a port then the br pointer is
	239	* invalid, therefor set the br to point correctly
	240	*/
	241	if (p)
	242	br = p->br;
	243
4d02b8f0	244	if (br->stp_enabled != BR_NO_STP) {
c75a33c8	245	NL_SET_ERR_MSG_MOD(extack, "MRP can't be enabled if STP is already enabled");
4d02b8f0 HV	246	return -EINVAL;
	247	}
	248
	249	err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_MAX, attr,
	250	br_mrp_policy, extack);
	251	if (err)
	252	return err;
	253
	254	if (tb[IFLA_BRIDGE_MRP_INSTANCE]) {
20f6a05e HV	255	err = br_mrp_instance_parse(br, tb[IFLA_BRIDGE_MRP_INSTANCE],
20f6a05e HV	256	cmd, extack);
4d02b8f0 HV	257	if (err)
	258	return err;
	259	}
	260
	261	if (tb[IFLA_BRIDGE_MRP_PORT_STATE]) {
20f6a05e HV	262	err = br_mrp_port_state_parse(p, tb[IFLA_BRIDGE_MRP_PORT_STATE],
20f6a05e HV	263	extack);
4d02b8f0 HV	264	if (err)
	265	return err;
	266	}
	267
	268	if (tb[IFLA_BRIDGE_MRP_PORT_ROLE]) {
20f6a05e HV	269	err = br_mrp_port_role_parse(p, tb[IFLA_BRIDGE_MRP_PORT_ROLE],
20f6a05e HV	270	extack);
4d02b8f0 HV	271	if (err)
	272	return err;
	273	}
	274
	275	if (tb[IFLA_BRIDGE_MRP_RING_STATE]) {
20f6a05e HV	276	err = br_mrp_ring_state_parse(br,
	277	tb[IFLA_BRIDGE_MRP_RING_STATE],
	278	extack);
4d02b8f0 HV	279	if (err)
	280	return err;
	281	}
	282
	283	if (tb[IFLA_BRIDGE_MRP_RING_ROLE]) {
20f6a05e HV	284	err = br_mrp_ring_role_parse(br, tb[IFLA_BRIDGE_MRP_RING_ROLE],
20f6a05e HV	285	extack);
4d02b8f0 HV	286	if (err)
	287	return err;
	288	}
	289
	290	if (tb[IFLA_BRIDGE_MRP_START_TEST]) {
20f6a05e HV	291	err = br_mrp_start_test_parse(br,
	292	tb[IFLA_BRIDGE_MRP_START_TEST],
	293	extack);
4d02b8f0 HV	294	if (err)
	295	return err;
	296	}
	297
	298	return 0;
	299	}
	300
9a9f26e8 HV	301	int br_mrp_port_open(struct net_device *dev, u8 loc)
	302	{
	303	struct net_bridge_port *p;
	304	int err = 0;
	305
	306	p = br_port_get_rcu(dev);
	307	if (!p) {
	308	err = -EINVAL;
	309	goto out;
	310	}
	311
	312	if (loc)
	313	p->flags \|= BR_MRP_LOST_CONT;
	314	else
	315	p->flags &= ~BR_MRP_LOST_CONT;
	316
	317	br_ifinfo_notify(RTM_NEWLINK, NULL, p);
	318
	319	out:
	320	return err;
	321	}