[mirror_ubuntu-focal-kernel.git] / net / bridge / br_switchdev.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>
#include <linux/skbuff.h>
#include <net/switchdev.h>

#include "br_private.h"

static int br_switchdev_mark_get(struct net_bridge *br, struct net_device *dev)
{
	struct net_bridge_port *p;

	/* dev is yet to be added to the port list. */
	list_for_each_entry(p, &br->port_list, list) {
		if (netdev_port_same_parent_id(dev, p->dev))
			return p->offload_fwd_mark;
	}

	return ++br->offload_fwd_mark;
}

int nbp_switchdev_mark_set(struct net_bridge_port *p)
{
	struct netdev_phys_item_id ppid = { };
	int err;

	ASSERT_RTNL();

	err = dev_get_port_parent_id(p->dev, &ppid, true);
	if (err) {
		if (err == -EOPNOTSUPP)
			return 0;
		return err;
	}

	p->offload_fwd_mark = br_switchdev_mark_get(p->br, p->dev);

	return 0;
}

void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
			      struct sk_buff *skb)
{
	if (skb->offload_fwd_mark && !WARN_ON_ONCE(!p->offload_fwd_mark))
		BR_INPUT_SKB_CB(skb)->offload_fwd_mark = p->offload_fwd_mark;
}

bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
				  const struct sk_buff *skb)
{
	return !skb->offload_fwd_mark ||
	       BR_INPUT_SKB_CB(skb)->offload_fwd_mark != p->offload_fwd_mark;
}

/* Flags that can be offloaded to hardware */
#define BR_PORT_FLAGS_HW_OFFLOAD (BR_LEARNING | BR_FLOOD | \
				  BR_MCAST_FLOOD | BR_BCAST_FLOOD)

int br_switchdev_set_port_flag(struct net_bridge_port *p,
			       unsigned long flags,
			       unsigned long mask)
{
	struct switchdev_attr attr = {
		.orig_dev = p->dev,
		.id = SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS,
		.u.brport_flags = mask,
	};
	struct switchdev_notifier_port_attr_info info = {
		.attr = &attr,
	};
	int err;

	if (mask & ~BR_PORT_FLAGS_HW_OFFLOAD)
		return 0;

	/* We run from atomic context here */
	err = call_switchdev_notifiers(SWITCHDEV_PORT_ATTR_SET, p->dev,
				       &info.info, NULL);
	err = notifier_to_errno(err);
	if (err == -EOPNOTSUPP)
		return 0;

	if (err) {
		br_warn(p->br, "bridge flag offload is not supported %u(%s)\n",
			(unsigned int)p->port_no, p->dev->name);
		return -EOPNOTSUPP;
	}

	attr.id = SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS;
	attr.flags = SWITCHDEV_F_DEFER;
	attr.u.brport_flags = flags;

	err = switchdev_port_attr_set(p->dev, &attr);
	if (err) {
		br_warn(p->br, "error setting offload flag on port %u(%s)\n",
			(unsigned int)p->port_no, p->dev->name);
		return err;
	}

	return 0;
}

static void
br_switchdev_fdb_call_notifiers(bool adding, const unsigned char *mac,
				u16 vid, struct net_device *dev,
				bool added_by_user, bool offloaded)
{
	struct switchdev_notifier_fdb_info info;
	unsigned long notifier_type;

	info.addr = mac;
	info.vid = vid;
	info.added_by_user = added_by_user;
	info.offloaded = offloaded;
	notifier_type = adding ? SWITCHDEV_FDB_ADD_TO_DEVICE : SWITCHDEV_FDB_DEL_TO_DEVICE;
	call_switchdev_notifiers(notifier_type, dev, &info.info, NULL);
}

void
br_switchdev_fdb_notify(const struct net_bridge_fdb_entry *fdb, int type)
{
	if (!fdb->dst)
		return;

	switch (type) {
	case RTM_DELNEIGH:
		br_switchdev_fdb_call_notifiers(false, fdb->key.addr.addr,
						fdb->key.vlan_id,
						fdb->dst->dev,
						fdb->added_by_user,
						fdb->offloaded);
		break;
	case RTM_NEWNEIGH:
		br_switchdev_fdb_call_notifiers(true, fdb->key.addr.addr,
						fdb->key.vlan_id,
						fdb->dst->dev,
						fdb->added_by_user,
						fdb->offloaded);
		break;
	}
}

int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid, u16 flags,
			       struct netlink_ext_ack *extack)
{
	struct switchdev_obj_port_vlan v = {
		.obj.orig_dev = dev,
		.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
		.flags = flags,
		.vid_begin = vid,
		.vid_end = vid,
	};

	return switchdev_port_obj_add(dev, &v.obj, extack);
}

int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid)
{
	struct switchdev_obj_port_vlan v = {
		.obj.orig_dev = dev,
		.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
		.vid_begin = vid,
		.vid_end = vid,
	};

	return switchdev_port_obj_del(dev, &v.obj);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
6bc506b4 IS	2	#include <linux/kernel.h>
	3	#include <linux/list.h>
	4	#include <linux/netdevice.h>
	5	#include <linux/rtnetlink.h>
	6	#include <linux/skbuff.h>
	7	#include <net/switchdev.h>
	8
	9	#include "br_private.h"
	10
	11	static int br_switchdev_mark_get(struct net_bridge br, struct net_device dev)
	12	{
	13	struct net_bridge_port *p;
	14
	15	/* dev is yet to be added to the port list. */
	16	list_for_each_entry(p, &br->port_list, list) {
bccb3025	17	if (netdev_port_same_parent_id(dev, p->dev))
6bc506b4 IS	18	return p->offload_fwd_mark;
	19	}
	20
	21	return ++br->offload_fwd_mark;
	22	}
	23
	24	int nbp_switchdev_mark_set(struct net_bridge_port *p)
	25	{
bccb3025	26	struct netdev_phys_item_id ppid = { };
6bc506b4 IS	27	int err;
	28
	29	ASSERT_RTNL();
	30
bccb3025	31	err = dev_get_port_parent_id(p->dev, &ppid, true);
6bc506b4 IS	32	if (err) {
	33	if (err == -EOPNOTSUPP)
	34	return 0;
	35	return err;
	36	}
	37
	38	p->offload_fwd_mark = br_switchdev_mark_get(p->br, p->dev);
	39
	40	return 0;
	41	}
	42
	43	void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
	44	struct sk_buff *skb)
	45	{
	46	if (skb->offload_fwd_mark && !WARN_ON_ONCE(!p->offload_fwd_mark))
	47	BR_INPUT_SKB_CB(skb)->offload_fwd_mark = p->offload_fwd_mark;
	48	}
	49
	50	bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
	51	const struct sk_buff *skb)
	52	{
	53	return !skb->offload_fwd_mark \|\|
	54	BR_INPUT_SKB_CB(skb)->offload_fwd_mark != p->offload_fwd_mark;
	55	}
3922285d AS	56
	57	/* Flags that can be offloaded to hardware */
	58	#define BR_PORT_FLAGS_HW_OFFLOAD (BR_LEARNING \| BR_FLOOD \| \
	59	BR_MCAST_FLOOD \| BR_BCAST_FLOOD)
	60
	61	int br_switchdev_set_port_flag(struct net_bridge_port *p,
	62	unsigned long flags,
	63	unsigned long mask)
	64	{
	65	struct switchdev_attr attr = {
	66	.orig_dev = p->dev,
1ef07644 FF	67	.id = SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS,
1ef07644 FF	68	.u.brport_flags = mask,
3922285d	69	};
d45224d6 FF	70	struct switchdev_notifier_port_attr_info info = {
	71	.attr = &attr,
	72	};
3922285d AS	73	int err;
	74
	75	if (mask & ~BR_PORT_FLAGS_HW_OFFLOAD)
	76	return 0;
	77
d45224d6 FF	78	/* We run from atomic context here */
	79	err = call_switchdev_notifiers(SWITCHDEV_PORT_ATTR_SET, p->dev,
	80	&info.info, NULL);
	81	err = notifier_to_errno(err);
3922285d AS	82	if (err == -EOPNOTSUPP)
3922285d AS	83	return 0;
3922285d	84
1ef07644	85	if (err) {
3922285d AS	86	br_warn(p->br, "bridge flag offload is not supported %u(%s)\n",
	87	(unsigned int)p->port_no, p->dev->name);
	88	return -EOPNOTSUPP;
	89	}
	90
	91	attr.id = SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS;
	92	attr.flags = SWITCHDEV_F_DEFER;
	93	attr.u.brport_flags = flags;
1ef07644	94
3922285d AS	95	err = switchdev_port_attr_set(p->dev, &attr);
	96	if (err) {
	97	br_warn(p->br, "error setting offload flag on port %u(%s)\n",
	98	(unsigned int)p->port_no, p->dev->name);
	99	return err;
	100	}
	101
	102	return 0;
	103	}
6b26b51b AS	104
	105	static void
	106	br_switchdev_fdb_call_notifiers(bool adding, const unsigned char *mac,
816a3bed	107	u16 vid, struct net_device *dev,
e9ba0fbc	108	bool added_by_user, bool offloaded)
6b26b51b AS	109	{
	110	struct switchdev_notifier_fdb_info info;
	111	unsigned long notifier_type;
	112
	113	info.addr = mac;
	114	info.vid = vid;
816a3bed	115	info.added_by_user = added_by_user;
e9ba0fbc	116	info.offloaded = offloaded;
6b26b51b	117	notifier_type = adding ? SWITCHDEV_FDB_ADD_TO_DEVICE : SWITCHDEV_FDB_DEL_TO_DEVICE;
6685987c	118	call_switchdev_notifiers(notifier_type, dev, &info.info, NULL);
6b26b51b AS	119	}
	120
	121	void
	122	br_switchdev_fdb_notify(const struct net_bridge_fdb_entry *fdb, int type)
	123	{
161d82de	124	if (!fdb->dst)
6b26b51b AS	125	return;
	126
	127	switch (type) {
	128	case RTM_DELNEIGH:
eb793583 NA	129	br_switchdev_fdb_call_notifiers(false, fdb->key.addr.addr,
eb793583 NA	130	fdb->key.vlan_id,
816a3bed	131	fdb->dst->dev,
e9ba0fbc IS	132	fdb->added_by_user,
e9ba0fbc IS	133	fdb->offloaded);
6b26b51b AS	134	break;
6b26b51b AS	135	case RTM_NEWNEIGH:
eb793583 NA	136	br_switchdev_fdb_call_notifiers(true, fdb->key.addr.addr,
eb793583 NA	137	fdb->key.vlan_id,
816a3bed	138	fdb->dst->dev,
e9ba0fbc IS	139	fdb->added_by_user,
e9ba0fbc IS	140	fdb->offloaded);
6b26b51b AS	141	break;
	142	}
	143	}
d66e4348	144
169327d5 PM	145	int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid, u16 flags,
169327d5 PM	146	struct netlink_ext_ack *extack)
d66e4348 PM	147	{
	148	struct switchdev_obj_port_vlan v = {
	149	.obj.orig_dev = dev,
	150	.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
	151	.flags = flags,
	152	.vid_begin = vid,
	153	.vid_end = vid,
	154	};
	155
69b7320e	156	return switchdev_port_obj_add(dev, &v.obj, extack);
d66e4348 PM	157	}
	158
	159	int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid)
	160	{
	161	struct switchdev_obj_port_vlan v = {
	162	.obj.orig_dev = dev,
	163	.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
	164	.vid_begin = vid,
	165	.vid_end = vid,
	166	};
	167
	168	return switchdev_port_obj_del(dev, &v.obj);
	169	}