2019-05-27 06:55:01 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Linux ethernet bridge
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Lennert Buytenhek <buytenh@gnu.org>
|
|
|
|
*/
|
|
|
|
#ifndef _LINUX_IF_BRIDGE_H
|
|
|
|
#define _LINUX_IF_BRIDGE_H
|
|
|
|
|
|
|
|
|
|
|
|
#include <linux/netdevice.h>
|
2012-10-13 09:46:48 +00:00
|
|
|
#include <uapi/linux/if_bridge.h>
|
2014-11-28 13:34:22 +00:00
|
|
|
#include <linux/bitops.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-07 16:26:28 +00:00
|
|
|
struct br_ip {
|
|
|
|
union {
|
|
|
|
__be32 ip4;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
struct in6_addr ip6;
|
2020-09-22 07:30:15 +00:00
|
|
|
#endif
|
|
|
|
} src;
|
|
|
|
union {
|
|
|
|
__be32 ip4;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
struct in6_addr ip6;
|
2014-06-07 16:26:28 +00:00
|
|
|
#endif
|
2020-10-28 23:38:31 +00:00
|
|
|
unsigned char mac_addr[ETH_ALEN];
|
2020-09-22 07:30:17 +00:00
|
|
|
} dst;
|
2014-06-07 16:26:28 +00:00
|
|
|
__be16 proto;
|
|
|
|
__u16 vid;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct br_ip_list {
|
|
|
|
struct list_head list;
|
|
|
|
struct br_ip addr;
|
|
|
|
};
|
|
|
|
|
2014-11-28 13:34:22 +00:00
|
|
|
#define BR_HAIRPIN_MODE BIT(0)
|
|
|
|
#define BR_BPDU_GUARD BIT(1)
|
|
|
|
#define BR_ROOT_BLOCK BIT(2)
|
|
|
|
#define BR_MULTICAST_FAST_LEAVE BIT(3)
|
|
|
|
#define BR_ADMIN_COST BIT(4)
|
|
|
|
#define BR_LEARNING BIT(5)
|
|
|
|
#define BR_FLOOD BIT(6)
|
|
|
|
#define BR_AUTO_MASK (BR_FLOOD | BR_LEARNING)
|
|
|
|
#define BR_PROMISC BIT(7)
|
|
|
|
#define BR_PROXYARP BIT(8)
|
2014-11-28 13:34:23 +00:00
|
|
|
#define BR_LEARNING_SYNC BIT(9)
|
2015-03-04 10:54:21 +00:00
|
|
|
#define BR_PROXYARP_WIFI BIT(10)
|
2016-08-31 13:36:52 +00:00
|
|
|
#define BR_MCAST_FLOOD BIT(11)
|
2017-01-21 20:01:32 +00:00
|
|
|
#define BR_MULTICAST_TO_UNICAST BIT(12)
|
2017-02-01 06:59:53 +00:00
|
|
|
#define BR_VLAN_TUNNEL BIT(13)
|
2017-04-26 13:48:09 +00:00
|
|
|
#define BR_BCAST_FLOOD BIT(14)
|
2017-10-07 05:12:37 +00:00
|
|
|
#define BR_NEIGH_SUPPRESS BIT(15)
|
2018-05-24 08:56:48 +00:00
|
|
|
#define BR_ISOLATED BIT(16)
|
2020-04-26 13:22:00 +00:00
|
|
|
#define BR_MRP_AWARE BIT(17)
|
|
|
|
#define BR_MRP_LOST_CONT BIT(18)
|
2020-07-14 07:34:49 +00:00
|
|
|
#define BR_MRP_LOST_IN_CONT BIT(19)
|
2021-07-22 15:55:38 +00:00
|
|
|
#define BR_TX_FWD_OFFLOAD BIT(20)
|
2022-02-23 10:16:46 +00:00
|
|
|
#define BR_PORT_LOCKED BIT(21)
|
bridge: Add MAC Authentication Bypass (MAB) support
Hosts that support 802.1X authentication are able to authenticate
themselves by exchanging EAPOL frames with an authenticator (Ethernet
bridge, in this case) and an authentication server. Access to the
network is only granted by the authenticator to successfully
authenticated hosts.
The above is implemented in the bridge using the "locked" bridge port
option. When enabled, link-local frames (e.g., EAPOL) can be locally
received by the bridge, but all other frames are dropped unless the host
is authenticated. That is, unless the user space control plane installed
an FDB entry according to which the source address of the frame is
located behind the locked ingress port. The entry can be dynamic, in
which case learning needs to be enabled so that the entry will be
refreshed by incoming traffic.
There are deployments in which not all the devices connected to the
authenticator (the bridge) support 802.1X. Such devices can include
printers and cameras. One option to support such deployments is to
unlock the bridge ports connecting these devices, but a slightly more
secure option is to use MAB. When MAB is enabled, the MAC address of the
connected device is used as the user name and password for the
authentication.
For MAB to work, the user space control plane needs to be notified about
MAC addresses that are trying to gain access so that they will be
compared against an allow list. This can be implemented via the regular
learning process with the sole difference that learned FDB entries are
installed with a new "locked" flag indicating that the entry cannot be
used to authenticate the device. The flag cannot be set by user space,
but user space can clear the flag by replacing the entry, thereby
authenticating the device.
Locked FDB entries implement the following semantics with regards to
roaming, aging and forwarding:
1. Roaming: Locked FDB entries can roam to unlocked (authorized) ports,
in which case the "locked" flag is cleared. FDB entries cannot roam
to locked ports regardless of MAB being enabled or not. Therefore,
locked FDB entries are only created if an FDB entry with the given {MAC,
VID} does not already exist. This behavior prevents unauthenticated
devices from disrupting traffic destined to already authenticated
devices.
2. Aging: Locked FDB entries age and refresh by incoming traffic like
regular entries.
3. Forwarding: Locked FDB entries forward traffic like regular entries.
If user space detects an unauthorized MAC behind a locked port and
wishes to prevent traffic with this MAC DA from reaching the host, it
can do so using tc or a different mechanism.
Enable the above behavior using a new bridge port option called "mab".
It can only be enabled on a bridge port that is both locked and has
learning enabled. Locked FDB entries are flushed from the port once MAB
is disabled. A new option is added because there are pure 802.1X
deployments that are not interested in notifications about locked FDB
entries.
Signed-off-by: Hans J. Schultz <netdev@kapio-technology.com>
Signed-off-by: Ido Schimmel <idosch@nvidia.com>
Acked-by: Nikolay Aleksandrov <razor@blackwall.org>
Reviewed-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-11-01 19:39:21 +00:00
|
|
|
#define BR_PORT_MAB BIT(22)
|
2023-04-19 15:34:54 +00:00
|
|
|
#define BR_NEIGH_VLAN_SUPPRESS BIT(23)
|
2014-11-28 13:34:22 +00:00
|
|
|
|
2015-09-23 15:39:16 +00:00
|
|
|
#define BR_DEFAULT_AGEING_TIME (300 * HZ)
|
|
|
|
|
2021-07-27 13:45:16 +00:00
|
|
|
struct net_bridge;
|
|
|
|
void brioctl_set(int (*hook)(struct net *net, struct net_bridge *br,
|
|
|
|
unsigned int cmd, struct ifreq *ifr,
|
|
|
|
void __user *uarg));
|
|
|
|
int br_ioctl_call(struct net *net, struct net_bridge *br, unsigned int cmd,
|
|
|
|
struct ifreq *ifr, void __user *uarg);
|
2010-11-15 06:38:11 +00:00
|
|
|
|
2014-07-07 03:41:16 +00:00
|
|
|
#if IS_ENABLED(CONFIG_BRIDGE) && IS_ENABLED(CONFIG_BRIDGE_IGMP_SNOOPING)
|
2014-06-07 16:26:28 +00:00
|
|
|
int br_multicast_list_adjacent(struct net_device *dev,
|
|
|
|
struct list_head *br_ip_list);
|
2014-07-07 03:41:17 +00:00
|
|
|
bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto);
|
2014-06-07 16:26:29 +00:00
|
|
|
bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto);
|
2021-05-13 13:20:53 +00:00
|
|
|
bool br_multicast_has_router_adjacent(struct net_device *dev, int proto);
|
2017-05-26 06:37:24 +00:00
|
|
|
bool br_multicast_enabled(const struct net_device *dev);
|
2017-10-09 09:15:32 +00:00
|
|
|
bool br_multicast_router(const struct net_device *dev);
|
2014-07-07 03:41:16 +00:00
|
|
|
#else
|
|
|
|
static inline int br_multicast_list_adjacent(struct net_device *dev,
|
|
|
|
struct list_head *br_ip_list)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2014-07-07 03:41:17 +00:00
|
|
|
static inline bool br_multicast_has_querier_anywhere(struct net_device *dev,
|
|
|
|
int proto)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2014-07-07 03:41:16 +00:00
|
|
|
static inline bool br_multicast_has_querier_adjacent(struct net_device *dev,
|
|
|
|
int proto)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2021-05-13 13:20:53 +00:00
|
|
|
|
|
|
|
static inline bool br_multicast_has_router_adjacent(struct net_device *dev,
|
|
|
|
int proto)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-05-26 06:37:24 +00:00
|
|
|
static inline bool br_multicast_enabled(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2017-10-09 09:15:32 +00:00
|
|
|
static inline bool br_multicast_router(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2014-07-07 03:41:16 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-05-26 06:37:23 +00:00
|
|
|
#if IS_ENABLED(CONFIG_BRIDGE) && IS_ENABLED(CONFIG_BRIDGE_VLAN_FILTERING)
|
|
|
|
bool br_vlan_enabled(const struct net_device *dev);
|
2018-04-29 07:56:08 +00:00
|
|
|
int br_vlan_get_pvid(const struct net_device *dev, u16 *p_pvid);
|
2019-07-05 13:16:34 +00:00
|
|
|
int br_vlan_get_pvid_rcu(const struct net_device *dev, u16 *p_pvid);
|
2019-07-05 13:16:36 +00:00
|
|
|
int br_vlan_get_proto(const struct net_device *dev, u16 *p_proto);
|
2018-04-29 07:56:08 +00:00
|
|
|
int br_vlan_get_info(const struct net_device *dev, u16 vid,
|
|
|
|
struct bridge_vlan_info *p_vinfo);
|
net: bridge: add a helper for retrieving port VLANs from the data path
Introduce a brother of br_vlan_get_info() which is protected by the RCU
mechanism, as opposed to br_vlan_get_info() which relies on taking the
write-side rtnl_mutex.
This is needed for drivers which need to find out whether a bridge port
has a VLAN configured or not. For example, certain DSA switches might
not offer complete source port identification to the CPU on RX, just the
VLAN in which the packet was received. Based on this VLAN, we cannot set
an accurate skb->dev ingress port, but at least we can configure one
that behaves the same as the correct one would (this is possible because
DSA sets skb->offload_fwd_mark = 1).
When we look at the bridge RX handler (br_handle_frame), we see that
what matters regarding skb->dev is the VLAN ID and the port STP state.
So we need to select an skb->dev that has the same bridge VLAN as the
packet we're receiving, and is in the LEARNING or FORWARDING STP state.
The latter is easy, but for the former, we should somehow keep a shadow
list of the bridge VLANs on each port, and a lookup table between VLAN
ID and the 'designated port for imprecise RX'. That is rather
complicated to keep in sync properly (the designated port per VLAN needs
to be updated on the addition and removal of a VLAN, as well as on the
join/leave events of the bridge on that port).
So, to avoid all that complexity, let's just iterate through our finite
number of ports and ask the bridge, for each packet: "do you have this
VLAN configured on this port?".
Cc: Roopa Prabhu <roopa@nvidia.com>
Cc: Nikolay Aleksandrov <nikolay@nvidia.com>
Cc: Ido Schimmel <idosch@nvidia.com>
Cc: Jiri Pirko <jiri@nvidia.com>
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-07-26 16:55:29 +00:00
|
|
|
int br_vlan_get_info_rcu(const struct net_device *dev, u16 vid,
|
|
|
|
struct bridge_vlan_info *p_vinfo);
|
2022-03-16 15:08:50 +00:00
|
|
|
bool br_mst_enabled(const struct net_device *dev);
|
2022-03-16 15:08:49 +00:00
|
|
|
int br_mst_get_info(const struct net_device *dev, u16 msti, unsigned long *vids);
|
2022-03-16 15:08:51 +00:00
|
|
|
int br_mst_get_state(const struct net_device *dev, u16 msti, u8 *state);
|
2017-05-26 06:37:23 +00:00
|
|
|
#else
|
|
|
|
static inline bool br_vlan_enabled(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2018-04-29 07:56:08 +00:00
|
|
|
|
|
|
|
static inline int br_vlan_get_pvid(const struct net_device *dev, u16 *p_pvid)
|
|
|
|
{
|
2018-07-06 12:44:02 +00:00
|
|
|
return -EINVAL;
|
2018-04-29 07:56:08 +00:00
|
|
|
}
|
|
|
|
|
2019-07-05 13:16:36 +00:00
|
|
|
static inline int br_vlan_get_proto(const struct net_device *dev, u16 *p_proto)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2019-07-05 13:16:34 +00:00
|
|
|
static inline int br_vlan_get_pvid_rcu(const struct net_device *dev, u16 *p_pvid)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2018-04-29 07:56:08 +00:00
|
|
|
static inline int br_vlan_get_info(const struct net_device *dev, u16 vid,
|
|
|
|
struct bridge_vlan_info *p_vinfo)
|
net: bridge: add a helper for retrieving port VLANs from the data path
Introduce a brother of br_vlan_get_info() which is protected by the RCU
mechanism, as opposed to br_vlan_get_info() which relies on taking the
write-side rtnl_mutex.
This is needed for drivers which need to find out whether a bridge port
has a VLAN configured or not. For example, certain DSA switches might
not offer complete source port identification to the CPU on RX, just the
VLAN in which the packet was received. Based on this VLAN, we cannot set
an accurate skb->dev ingress port, but at least we can configure one
that behaves the same as the correct one would (this is possible because
DSA sets skb->offload_fwd_mark = 1).
When we look at the bridge RX handler (br_handle_frame), we see that
what matters regarding skb->dev is the VLAN ID and the port STP state.
So we need to select an skb->dev that has the same bridge VLAN as the
packet we're receiving, and is in the LEARNING or FORWARDING STP state.
The latter is easy, but for the former, we should somehow keep a shadow
list of the bridge VLANs on each port, and a lookup table between VLAN
ID and the 'designated port for imprecise RX'. That is rather
complicated to keep in sync properly (the designated port per VLAN needs
to be updated on the addition and removal of a VLAN, as well as on the
join/leave events of the bridge on that port).
So, to avoid all that complexity, let's just iterate through our finite
number of ports and ask the bridge, for each packet: "do you have this
VLAN configured on this port?".
Cc: Roopa Prabhu <roopa@nvidia.com>
Cc: Nikolay Aleksandrov <nikolay@nvidia.com>
Cc: Ido Schimmel <idosch@nvidia.com>
Cc: Jiri Pirko <jiri@nvidia.com>
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-07-26 16:55:29 +00:00
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int br_vlan_get_info_rcu(const struct net_device *dev, u16 vid,
|
|
|
|
struct bridge_vlan_info *p_vinfo)
|
2018-04-29 07:56:08 +00:00
|
|
|
{
|
2018-07-06 12:44:02 +00:00
|
|
|
return -EINVAL;
|
2018-04-29 07:56:08 +00:00
|
|
|
}
|
2022-03-16 15:08:49 +00:00
|
|
|
|
2022-03-16 15:08:50 +00:00
|
|
|
static inline bool br_mst_enabled(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2022-03-16 15:08:49 +00:00
|
|
|
static inline int br_mst_get_info(const struct net_device *dev, u16 msti,
|
|
|
|
unsigned long *vids)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2022-03-16 15:08:51 +00:00
|
|
|
static inline int br_mst_get_state(const struct net_device *dev, u16 msti,
|
|
|
|
u8 *state)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2018-04-29 07:56:08 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_BRIDGE)
|
|
|
|
struct net_device *br_fdb_find_port(const struct net_device *br_dev,
|
|
|
|
const unsigned char *addr,
|
|
|
|
__u16 vid);
|
2018-12-07 19:55:07 +00:00
|
|
|
void br_fdb_clear_offload(const struct net_device *dev, u16 vid);
|
2018-11-21 08:02:41 +00:00
|
|
|
bool br_port_flag_is_set(const struct net_device *dev, unsigned long flag);
|
2021-03-22 23:51:42 +00:00
|
|
|
u8 br_port_get_stp_state(const struct net_device *dev);
|
2021-06-27 11:54:26 +00:00
|
|
|
clock_t br_get_ageing_time(const struct net_device *br_dev);
|
2018-04-29 07:56:08 +00:00
|
|
|
#else
|
|
|
|
static inline struct net_device *
|
|
|
|
br_fdb_find_port(const struct net_device *br_dev,
|
|
|
|
const unsigned char *addr,
|
|
|
|
__u16 vid)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2018-12-07 19:55:07 +00:00
|
|
|
|
|
|
|
static inline void br_fdb_clear_offload(const struct net_device *dev, u16 vid)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2018-11-21 08:02:41 +00:00
|
|
|
static inline bool
|
|
|
|
br_port_flag_is_set(const struct net_device *dev, unsigned long flag)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
2021-03-22 23:51:42 +00:00
|
|
|
|
|
|
|
static inline u8 br_port_get_stp_state(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return BR_STATE_DISABLED;
|
|
|
|
}
|
2021-03-22 23:51:43 +00:00
|
|
|
|
2021-06-27 11:54:26 +00:00
|
|
|
static inline clock_t br_get_ageing_time(const struct net_device *br_dev)
|
2021-03-22 23:51:43 +00:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2017-05-26 06:37:23 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|