2019-05-27 14:55:01 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2010-02-28 03:41:45 +08:00
|
|
|
/*
|
|
|
|
* Bridge multicast support.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/err.h>
|
2014-06-08 00:26:28 +08:00
|
|
|
#include <linux/export.h>
|
2010-02-28 03:41:45 +08:00
|
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <linux/igmp.h>
|
2019-01-21 14:26:28 +08:00
|
|
|
#include <linux/in.h>
|
2010-02-28 03:41:45 +08:00
|
|
|
#include <linux/jhash.h>
|
|
|
|
#include <linux/kernel.h>
|
2010-02-28 03:41:51 +08:00
|
|
|
#include <linux/log2.h>
|
2010-02-28 03:41:45 +08:00
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/netfilter_bridge.h>
|
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/rculist.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/timer.h>
|
2013-05-22 05:52:54 +08:00
|
|
|
#include <linux/inetdevice.h>
|
2016-10-31 20:21:05 +08:00
|
|
|
#include <linux/mroute.h>
|
2010-02-28 03:41:45 +08:00
|
|
|
#include <net/ip.h>
|
2017-02-09 21:54:40 +08:00
|
|
|
#include <net/switchdev.h>
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2019-01-21 14:26:28 +08:00
|
|
|
#include <linux/icmpv6.h>
|
2010-04-23 00:54:22 +08:00
|
|
|
#include <net/ipv6.h>
|
|
|
|
#include <net/mld.h>
|
2010-04-28 01:16:54 +08:00
|
|
|
#include <net/ip6_checksum.h>
|
2013-09-04 08:13:39 +08:00
|
|
|
#include <net/addrconf.h>
|
2010-04-23 00:54:22 +08:00
|
|
|
#endif
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
#include "br_private.h"
|
2021-01-20 22:51:54 +08:00
|
|
|
#include "br_private_mcast_eht.h"
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
static const struct rhashtable_params br_mdb_rht_params = {
|
|
|
|
.head_offset = offsetof(struct net_bridge_mdb_entry, rhnode),
|
|
|
|
.key_offset = offsetof(struct net_bridge_mdb_entry, addr),
|
|
|
|
.key_len = sizeof(struct br_ip),
|
|
|
|
.automatic_shrinking = true,
|
|
|
|
};
|
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
static const struct rhashtable_params br_sg_port_rht_params = {
|
|
|
|
.head_offset = offsetof(struct net_bridge_port_group, rhnode),
|
|
|
|
.key_offset = offsetof(struct net_bridge_port_group, key),
|
|
|
|
.key_len = sizeof(struct net_bridge_port_group_sg_key),
|
|
|
|
.automatic_shrinking = true,
|
|
|
|
};
|
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
static void br_multicast_start_querier(struct net_bridge *br,
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_own_query *query);
|
2015-06-19 16:22:57 +08:00
|
|
|
static void br_multicast_add_router(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port);
|
2015-07-13 20:28:37 +08:00
|
|
|
static void br_ip4_multicast_leave_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
__be32 group,
|
2017-01-22 04:01:32 +08:00
|
|
|
__u16 vid,
|
|
|
|
const unsigned char *src);
|
2020-09-07 17:56:10 +08:00
|
|
|
static void br_multicast_port_group_rexmit(struct timer_list *t);
|
2017-01-22 04:01:32 +08:00
|
|
|
|
2017-02-09 21:54:41 +08:00
|
|
|
static void __del_port_router(struct net_bridge_port *p);
|
2015-07-13 20:28:37 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
static void br_ip6_multicast_leave_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
const struct in6_addr *group,
|
2017-01-22 04:01:32 +08:00
|
|
|
__u16 vid, const unsigned char *src);
|
2015-07-13 20:28:37 +08:00
|
|
|
#endif
|
2020-09-22 15:30:23 +08:00
|
|
|
static struct net_bridge_port_group *
|
|
|
|
__br_multicast_add_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
struct br_ip *group,
|
|
|
|
const unsigned char *src,
|
|
|
|
u8 filter_mode,
|
2020-09-22 15:30:25 +08:00
|
|
|
bool igmpv2_mldv1,
|
|
|
|
bool blocked);
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
static void br_multicast_find_del_pg(struct net_bridge *br,
|
|
|
|
struct net_bridge_port_group *pg);
|
2012-04-13 10:37:42 +08:00
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
static struct net_bridge_port_group *
|
|
|
|
br_sg_port_find(struct net_bridge *br,
|
|
|
|
struct net_bridge_port_group_sg_key *sg_p)
|
|
|
|
{
|
|
|
|
lockdep_assert_held_once(&br->multicast_lock);
|
|
|
|
|
|
|
|
return rhashtable_lookup_fast(&br->sg_port_tbl, sg_p,
|
|
|
|
br_sg_port_rht_params);
|
|
|
|
}
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
static struct net_bridge_mdb_entry *br_mdb_ip_get_rcu(struct net_bridge *br,
|
|
|
|
struct br_ip *dst)
|
2010-04-23 00:54:22 +08:00
|
|
|
{
|
2018-12-05 21:14:24 +08:00
|
|
|
return rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
struct net_bridge_mdb_entry *br_mdb_ip_get(struct net_bridge *br,
|
|
|
|
struct br_ip *dst)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2018-12-05 21:14:24 +08:00
|
|
|
struct net_bridge_mdb_entry *ent;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
lockdep_assert_held_once(&br->multicast_lock);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
ent = rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
|
|
|
|
rcu_read_unlock();
|
2010-07-05 22:50:08 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
return ent;
|
2010-07-05 22:50:08 +08:00
|
|
|
}
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
static struct net_bridge_mdb_entry *br_mdb_ip4_get(struct net_bridge *br,
|
|
|
|
__be32 dst, __u16 vid)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2010-04-18 11:42:07 +08:00
|
|
|
struct br_ip br_dst;
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
memset(&br_dst, 0, sizeof(br_dst));
|
2020-09-22 15:30:17 +08:00
|
|
|
br_dst.dst.ip4 = dst;
|
2010-04-18 11:42:07 +08:00
|
|
|
br_dst.proto = htons(ETH_P_IP);
|
2013-02-13 20:00:17 +08:00
|
|
|
br_dst.vid = vid;
|
2010-03-16 11:38:25 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
return br_mdb_ip_get(br, &br_dst);
|
2010-04-18 11:42:07 +08:00
|
|
|
}
|
|
|
|
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2018-12-05 21:14:24 +08:00
|
|
|
static struct net_bridge_mdb_entry *br_mdb_ip6_get(struct net_bridge *br,
|
|
|
|
const struct in6_addr *dst,
|
|
|
|
__u16 vid)
|
2010-04-23 00:54:22 +08:00
|
|
|
{
|
|
|
|
struct br_ip br_dst;
|
2010-03-16 11:38:25 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
memset(&br_dst, 0, sizeof(br_dst));
|
2020-09-22 15:30:17 +08:00
|
|
|
br_dst.dst.ip6 = *dst;
|
2010-04-23 00:54:22 +08:00
|
|
|
br_dst.proto = htons(ETH_P_IPV6);
|
2013-02-13 20:00:17 +08:00
|
|
|
br_dst.vid = vid;
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
return br_mdb_ip_get(br, &br_dst);
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
|
2013-03-07 11:05:33 +08:00
|
|
|
struct sk_buff *skb, u16 vid)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2010-04-18 11:42:07 +08:00
|
|
|
struct br_ip ip;
|
|
|
|
|
2018-09-26 22:01:03 +08:00
|
|
|
if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
|
2010-02-28 03:41:45 +08:00
|
|
|
return NULL;
|
|
|
|
|
2010-04-18 11:42:07 +08:00
|
|
|
if (BR_INPUT_SKB_CB(skb)->igmp)
|
2010-02-28 03:41:45 +08:00
|
|
|
return NULL;
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
memset(&ip, 0, sizeof(ip));
|
2010-04-18 11:42:07 +08:00
|
|
|
ip.proto = skb->protocol;
|
2013-03-07 11:05:33 +08:00
|
|
|
ip.vid = vid;
|
2010-04-18 11:42:07 +08:00
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
switch (skb->protocol) {
|
|
|
|
case htons(ETH_P_IP):
|
2020-09-22 15:30:17 +08:00
|
|
|
ip.dst.ip4 = ip_hdr(skb)->daddr;
|
2020-09-22 15:30:20 +08:00
|
|
|
if (br->multicast_igmp_version == 3) {
|
|
|
|
struct net_bridge_mdb_entry *mdb;
|
|
|
|
|
|
|
|
ip.src.ip4 = ip_hdr(skb)->saddr;
|
|
|
|
mdb = br_mdb_ip_get_rcu(br, &ip);
|
|
|
|
if (mdb)
|
|
|
|
return mdb;
|
|
|
|
ip.src.ip4 = 0;
|
|
|
|
}
|
2010-04-18 11:42:07 +08:00
|
|
|
break;
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2010-04-23 00:54:22 +08:00
|
|
|
case htons(ETH_P_IPV6):
|
2020-09-22 15:30:17 +08:00
|
|
|
ip.dst.ip6 = ipv6_hdr(skb)->daddr;
|
2020-09-22 15:30:20 +08:00
|
|
|
if (br->multicast_mld_version == 2) {
|
|
|
|
struct net_bridge_mdb_entry *mdb;
|
|
|
|
|
|
|
|
ip.src.ip6 = ipv6_hdr(skb)->saddr;
|
|
|
|
mdb = br_mdb_ip_get_rcu(br, &ip);
|
|
|
|
if (mdb)
|
|
|
|
return mdb;
|
|
|
|
memset(&ip.src.ip6, 0, sizeof(ip.src.ip6));
|
|
|
|
}
|
2010-04-23 00:54:22 +08:00
|
|
|
break;
|
|
|
|
#endif
|
2010-04-18 11:42:07 +08:00
|
|
|
default:
|
2020-10-29 07:38:31 +08:00
|
|
|
ip.proto = 0;
|
|
|
|
ether_addr_copy(ip.dst.mac_addr, eth_hdr(skb)->h_dest);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
return br_mdb_ip_get_rcu(br, &ip);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2020-09-22 15:30:23 +08:00
|
|
|
static bool br_port_group_equal(struct net_bridge_port_group *p,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
const unsigned char *src)
|
|
|
|
{
|
|
|
|
if (p->key.port != port)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!(port->flags & BR_MULTICAST_TO_UNICAST))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return ether_addr_equal(src, p->eth_addr);
|
|
|
|
}
|
|
|
|
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
static void __fwd_add_star_excl(struct net_bridge_port_group *pg,
|
|
|
|
struct br_ip *sg_ip)
|
|
|
|
{
|
|
|
|
struct net_bridge_port_group_sg_key sg_key;
|
|
|
|
struct net_bridge *br = pg->key.port->br;
|
|
|
|
struct net_bridge_port_group *src_pg;
|
|
|
|
|
|
|
|
memset(&sg_key, 0, sizeof(sg_key));
|
|
|
|
sg_key.port = pg->key.port;
|
|
|
|
sg_key.addr = *sg_ip;
|
|
|
|
if (br_sg_port_find(br, &sg_key))
|
|
|
|
return;
|
|
|
|
|
|
|
|
src_pg = __br_multicast_add_group(br, pg->key.port, sg_ip, pg->eth_addr,
|
2020-09-22 15:30:25 +08:00
|
|
|
MCAST_INCLUDE, false, false);
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
if (IS_ERR_OR_NULL(src_pg) ||
|
|
|
|
src_pg->rt_protocol != RTPROT_KERNEL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __fwd_del_star_excl(struct net_bridge_port_group *pg,
|
|
|
|
struct br_ip *sg_ip)
|
|
|
|
{
|
|
|
|
struct net_bridge_port_group_sg_key sg_key;
|
|
|
|
struct net_bridge *br = pg->key.port->br;
|
|
|
|
struct net_bridge_port_group *src_pg;
|
|
|
|
|
|
|
|
memset(&sg_key, 0, sizeof(sg_key));
|
|
|
|
sg_key.port = pg->key.port;
|
|
|
|
sg_key.addr = *sg_ip;
|
|
|
|
src_pg = br_sg_port_find(br, &sg_key);
|
|
|
|
if (!src_pg || !(src_pg->flags & MDB_PG_FLAGS_STAR_EXCL) ||
|
|
|
|
src_pg->rt_protocol != RTPROT_KERNEL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
br_multicast_find_del_pg(br, src_pg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* When a port group transitions to (or is added as) EXCLUDE we need to add it
|
|
|
|
* to all other ports' S,G entries which are not blocked by the current group
|
|
|
|
* for proper replication, the assumption is that any S,G blocked entries
|
|
|
|
* are already added so the S,G,port lookup should skip them.
|
|
|
|
* When a port group transitions from EXCLUDE -> INCLUDE mode or is being
|
|
|
|
* deleted we need to remove it from all ports' S,G entries where it was
|
|
|
|
* automatically installed before (i.e. where it's MDB_PG_FLAGS_STAR_EXCL).
|
|
|
|
*/
|
|
|
|
void br_multicast_star_g_handle_mode(struct net_bridge_port_group *pg,
|
|
|
|
u8 filter_mode)
|
|
|
|
{
|
|
|
|
struct net_bridge *br = pg->key.port->br;
|
|
|
|
struct net_bridge_port_group *pg_lst;
|
|
|
|
struct net_bridge_mdb_entry *mp;
|
|
|
|
struct br_ip sg_ip;
|
|
|
|
|
|
|
|
if (WARN_ON(!br_multicast_is_star_g(&pg->key.addr)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mp = br_mdb_ip_get(br, &pg->key.addr);
|
|
|
|
if (!mp)
|
|
|
|
return;
|
|
|
|
|
|
|
|
memset(&sg_ip, 0, sizeof(sg_ip));
|
|
|
|
sg_ip = pg->key.addr;
|
|
|
|
for (pg_lst = mlock_dereference(mp->ports, br);
|
|
|
|
pg_lst;
|
|
|
|
pg_lst = mlock_dereference(pg_lst->next, br)) {
|
|
|
|
struct net_bridge_group_src *src_ent;
|
|
|
|
|
|
|
|
if (pg_lst == pg)
|
|
|
|
continue;
|
|
|
|
hlist_for_each_entry(src_ent, &pg_lst->src_list, node) {
|
|
|
|
if (!(src_ent->flags & BR_SGRP_F_INSTALLED))
|
|
|
|
continue;
|
|
|
|
sg_ip.src = src_ent->addr.src;
|
|
|
|
switch (filter_mode) {
|
|
|
|
case MCAST_INCLUDE:
|
|
|
|
__fwd_del_star_excl(pg, &sg_ip);
|
|
|
|
break;
|
|
|
|
case MCAST_EXCLUDE:
|
|
|
|
__fwd_add_star_excl(pg, &sg_ip);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-22 15:30:26 +08:00
|
|
|
/* called when adding a new S,G with host_joined == false by default */
|
|
|
|
static void br_multicast_sg_host_state(struct net_bridge_mdb_entry *star_mp,
|
|
|
|
struct net_bridge_port_group *sg)
|
|
|
|
{
|
|
|
|
struct net_bridge_mdb_entry *sg_mp;
|
|
|
|
|
|
|
|
if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr)))
|
|
|
|
return;
|
|
|
|
if (!star_mp->host_joined)
|
|
|
|
return;
|
|
|
|
|
|
|
|
sg_mp = br_mdb_ip_get(star_mp->br, &sg->key.addr);
|
|
|
|
if (!sg_mp)
|
|
|
|
return;
|
|
|
|
sg_mp->host_joined = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* set the host_joined state of all of *,G's S,G entries */
|
|
|
|
static void br_multicast_star_g_host_state(struct net_bridge_mdb_entry *star_mp)
|
|
|
|
{
|
|
|
|
struct net_bridge *br = star_mp->br;
|
|
|
|
struct net_bridge_mdb_entry *sg_mp;
|
|
|
|
struct net_bridge_port_group *pg;
|
|
|
|
struct br_ip sg_ip;
|
|
|
|
|
|
|
|
if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
memset(&sg_ip, 0, sizeof(sg_ip));
|
|
|
|
sg_ip = star_mp->addr;
|
|
|
|
for (pg = mlock_dereference(star_mp->ports, br);
|
|
|
|
pg;
|
|
|
|
pg = mlock_dereference(pg->next, br)) {
|
|
|
|
struct net_bridge_group_src *src_ent;
|
|
|
|
|
|
|
|
hlist_for_each_entry(src_ent, &pg->src_list, node) {
|
|
|
|
if (!(src_ent->flags & BR_SGRP_F_INSTALLED))
|
|
|
|
continue;
|
|
|
|
sg_ip.src = src_ent->addr.src;
|
|
|
|
sg_mp = br_mdb_ip_get(br, &sg_ip);
|
|
|
|
if (!sg_mp)
|
|
|
|
continue;
|
|
|
|
sg_mp->host_joined = star_mp->host_joined;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
static void br_multicast_sg_del_exclude_ports(struct net_bridge_mdb_entry *sgmp)
|
|
|
|
{
|
|
|
|
struct net_bridge_port_group __rcu **pp;
|
|
|
|
struct net_bridge_port_group *p;
|
|
|
|
|
|
|
|
/* *,G exclude ports are only added to S,G entries */
|
|
|
|
if (WARN_ON(br_multicast_is_star_g(&sgmp->addr)))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* we need the STAR_EXCLUDE ports if there are non-STAR_EXCLUDE ports
|
|
|
|
* we should ignore perm entries since they're managed by user-space
|
|
|
|
*/
|
|
|
|
for (pp = &sgmp->ports;
|
|
|
|
(p = mlock_dereference(*pp, sgmp->br)) != NULL;
|
|
|
|
pp = &p->next)
|
|
|
|
if (!(p->flags & (MDB_PG_FLAGS_STAR_EXCL |
|
|
|
|
MDB_PG_FLAGS_PERMANENT)))
|
|
|
|
return;
|
|
|
|
|
2020-09-22 15:30:26 +08:00
|
|
|
/* currently the host can only have joined the *,G which means
|
|
|
|
* we treat it as EXCLUDE {}, so for an S,G it's considered a
|
|
|
|
* STAR_EXCLUDE entry and we can safely leave it
|
|
|
|
*/
|
|
|
|
sgmp->host_joined = false;
|
|
|
|
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
for (pp = &sgmp->ports;
|
|
|
|
(p = mlock_dereference(*pp, sgmp->br)) != NULL;) {
|
|
|
|
if (!(p->flags & MDB_PG_FLAGS_PERMANENT))
|
|
|
|
br_multicast_del_pg(sgmp, p, pp);
|
|
|
|
else
|
|
|
|
pp = &p->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_sg_add_exclude_ports(struct net_bridge_mdb_entry *star_mp,
|
|
|
|
struct net_bridge_port_group *sg)
|
|
|
|
{
|
|
|
|
struct net_bridge_port_group_sg_key sg_key;
|
|
|
|
struct net_bridge *br = star_mp->br;
|
|
|
|
struct net_bridge_port_group *pg;
|
|
|
|
|
|
|
|
if (WARN_ON(br_multicast_is_star_g(&sg->key.addr)))
|
|
|
|
return;
|
|
|
|
if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr)))
|
|
|
|
return;
|
|
|
|
|
2020-09-22 15:30:26 +08:00
|
|
|
br_multicast_sg_host_state(star_mp, sg);
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
memset(&sg_key, 0, sizeof(sg_key));
|
|
|
|
sg_key.addr = sg->key.addr;
|
|
|
|
/* we need to add all exclude ports to the S,G */
|
|
|
|
for (pg = mlock_dereference(star_mp->ports, br);
|
|
|
|
pg;
|
|
|
|
pg = mlock_dereference(pg->next, br)) {
|
|
|
|
struct net_bridge_port_group *src_pg;
|
|
|
|
|
|
|
|
if (pg == sg || pg->filter_mode == MCAST_INCLUDE)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
sg_key.port = pg->key.port;
|
|
|
|
if (br_sg_port_find(br, &sg_key))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
src_pg = __br_multicast_add_group(br, pg->key.port,
|
|
|
|
&sg->key.addr,
|
|
|
|
sg->eth_addr,
|
2020-09-22 15:30:25 +08:00
|
|
|
MCAST_INCLUDE, false, false);
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
if (IS_ERR_OR_NULL(src_pg) ||
|
|
|
|
src_pg->rt_protocol != RTPROT_KERNEL)
|
|
|
|
continue;
|
|
|
|
src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-22 15:30:23 +08:00
|
|
|
static void br_multicast_fwd_src_add(struct net_bridge_group_src *src)
|
|
|
|
{
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
struct net_bridge_mdb_entry *star_mp;
|
2020-09-22 15:30:23 +08:00
|
|
|
struct net_bridge_port_group *sg;
|
|
|
|
struct br_ip sg_ip;
|
|
|
|
|
|
|
|
if (src->flags & BR_SGRP_F_INSTALLED)
|
|
|
|
return;
|
|
|
|
|
|
|
|
memset(&sg_ip, 0, sizeof(sg_ip));
|
|
|
|
sg_ip = src->pg->key.addr;
|
|
|
|
sg_ip.src = src->addr.src;
|
|
|
|
sg = __br_multicast_add_group(src->br, src->pg->key.port, &sg_ip,
|
2020-09-22 15:30:25 +08:00
|
|
|
src->pg->eth_addr, MCAST_INCLUDE, false,
|
|
|
|
!timer_pending(&src->timer));
|
2020-09-22 15:30:23 +08:00
|
|
|
if (IS_ERR_OR_NULL(sg))
|
|
|
|
return;
|
|
|
|
src->flags |= BR_SGRP_F_INSTALLED;
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
sg->flags &= ~MDB_PG_FLAGS_STAR_EXCL;
|
2020-09-22 15:30:23 +08:00
|
|
|
|
|
|
|
/* if it was added by user-space as perm we can skip next steps */
|
|
|
|
if (sg->rt_protocol != RTPROT_KERNEL &&
|
|
|
|
(sg->flags & MDB_PG_FLAGS_PERMANENT))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* the kernel is now responsible for removing this S,G */
|
|
|
|
del_timer(&sg->timer);
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
star_mp = br_mdb_ip_get(src->br, &src->pg->key.addr);
|
|
|
|
if (!star_mp)
|
|
|
|
return;
|
|
|
|
|
|
|
|
br_multicast_sg_add_exclude_ports(star_mp, sg);
|
2020-09-22 15:30:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void br_multicast_fwd_src_remove(struct net_bridge_group_src *src)
|
|
|
|
{
|
|
|
|
struct net_bridge_port_group *p, *pg = src->pg;
|
|
|
|
struct net_bridge_port_group __rcu **pp;
|
|
|
|
struct net_bridge_mdb_entry *mp;
|
|
|
|
struct br_ip sg_ip;
|
|
|
|
|
|
|
|
memset(&sg_ip, 0, sizeof(sg_ip));
|
|
|
|
sg_ip = pg->key.addr;
|
|
|
|
sg_ip.src = src->addr.src;
|
|
|
|
|
|
|
|
mp = br_mdb_ip_get(src->br, &sg_ip);
|
|
|
|
if (!mp)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (pp = &mp->ports;
|
|
|
|
(p = mlock_dereference(*pp, src->br)) != NULL;
|
|
|
|
pp = &p->next) {
|
|
|
|
if (!br_port_group_equal(p, pg->key.port, pg->eth_addr))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (p->rt_protocol != RTPROT_KERNEL &&
|
|
|
|
(p->flags & MDB_PG_FLAGS_PERMANENT))
|
|
|
|
break;
|
|
|
|
|
|
|
|
br_multicast_del_pg(mp, p, pp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
src->flags &= ~BR_SGRP_F_INSTALLED;
|
|
|
|
}
|
|
|
|
|
2020-09-22 15:30:25 +08:00
|
|
|
/* install S,G and based on src's timer enable or disable forwarding */
|
2020-09-22 15:30:23 +08:00
|
|
|
static void br_multicast_fwd_src_handle(struct net_bridge_group_src *src)
|
|
|
|
{
|
2020-09-22 15:30:25 +08:00
|
|
|
struct net_bridge_port_group_sg_key sg_key;
|
|
|
|
struct net_bridge_port_group *sg;
|
|
|
|
u8 old_flags;
|
|
|
|
|
2020-09-22 15:30:23 +08:00
|
|
|
br_multicast_fwd_src_add(src);
|
2020-09-22 15:30:25 +08:00
|
|
|
|
|
|
|
memset(&sg_key, 0, sizeof(sg_key));
|
|
|
|
sg_key.addr = src->pg->key.addr;
|
|
|
|
sg_key.addr.src = src->addr.src;
|
|
|
|
sg_key.port = src->pg->key.port;
|
|
|
|
|
|
|
|
sg = br_sg_port_find(src->br, &sg_key);
|
|
|
|
if (!sg || (sg->flags & MDB_PG_FLAGS_PERMANENT))
|
|
|
|
return;
|
|
|
|
|
|
|
|
old_flags = sg->flags;
|
|
|
|
if (timer_pending(&src->timer))
|
|
|
|
sg->flags &= ~MDB_PG_FLAGS_BLOCKED;
|
|
|
|
else
|
|
|
|
sg->flags |= MDB_PG_FLAGS_BLOCKED;
|
|
|
|
|
|
|
|
if (old_flags != sg->flags) {
|
|
|
|
struct net_bridge_mdb_entry *sg_mp;
|
|
|
|
|
|
|
|
sg_mp = br_mdb_ip_get(src->br, &sg_key.addr);
|
|
|
|
if (!sg_mp)
|
|
|
|
return;
|
|
|
|
br_mdb_notify(src->br->dev, sg_mp, sg, RTM_NEWMDB);
|
|
|
|
}
|
2020-09-22 15:30:23 +08:00
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:19 +08:00
|
|
|
static void br_multicast_destroy_mdb_entry(struct net_bridge_mcast_gc *gc)
|
|
|
|
{
|
|
|
|
struct net_bridge_mdb_entry *mp;
|
|
|
|
|
|
|
|
mp = container_of(gc, struct net_bridge_mdb_entry, mcast_gc);
|
|
|
|
WARN_ON(!hlist_unhashed(&mp->mdb_node));
|
|
|
|
WARN_ON(mp->ports);
|
|
|
|
|
|
|
|
del_timer_sync(&mp->timer);
|
|
|
|
kfree_rcu(mp, rcu);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void br_multicast_del_mdb_entry(struct net_bridge_mdb_entry *mp)
|
|
|
|
{
|
|
|
|
struct net_bridge *br = mp->br;
|
|
|
|
|
|
|
|
rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode,
|
|
|
|
br_mdb_rht_params);
|
|
|
|
hlist_del_init_rcu(&mp->mdb_node);
|
|
|
|
hlist_add_head(&mp->mcast_gc.gc_node, &br->mcast_gc_list);
|
|
|
|
queue_work(system_long_wq, &br->mcast_gc_work);
|
|
|
|
}
|
|
|
|
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_multicast_group_expired(struct timer_list *t)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge_mdb_entry *mp = from_timer(mp, t, timer);
|
2010-02-28 03:41:45 +08:00
|
|
|
struct net_bridge *br = mp->br;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
2020-09-22 15:30:23 +08:00
|
|
|
if (hlist_unhashed(&mp->mdb_node) || !netif_running(br->dev) ||
|
|
|
|
timer_pending(&mp->timer))
|
2010-02-28 03:41:45 +08:00
|
|
|
goto out;
|
|
|
|
|
2019-08-17 19:22:13 +08:00
|
|
|
br_multicast_host_leave(mp, true);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
if (mp->ports)
|
|
|
|
goto out;
|
2020-09-07 17:56:19 +08:00
|
|
|
br_multicast_del_mdb_entry(mp);
|
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2020-09-07 17:56:19 +08:00
|
|
|
static void br_multicast_destroy_group_src(struct net_bridge_mcast_gc *gc)
|
|
|
|
{
|
|
|
|
struct net_bridge_group_src *src;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2020-09-07 17:56:19 +08:00
|
|
|
src = container_of(gc, struct net_bridge_group_src, mcast_gc);
|
|
|
|
WARN_ON(!hlist_unhashed(&src->node));
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2020-09-07 17:56:19 +08:00
|
|
|
del_timer_sync(&src->timer);
|
|
|
|
kfree_rcu(src, rcu);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:58 +08:00
|
|
|
void br_multicast_del_group_src(struct net_bridge_group_src *src)
|
2020-09-07 17:56:07 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = src->pg->key.port->br;
|
2020-09-07 17:56:07 +08:00
|
|
|
|
2020-09-22 15:30:23 +08:00
|
|
|
br_multicast_fwd_src_remove(src);
|
2020-09-07 17:56:07 +08:00
|
|
|
hlist_del_init_rcu(&src->node);
|
|
|
|
src->pg->src_ents--;
|
2020-09-07 17:56:19 +08:00
|
|
|
hlist_add_head(&src->mcast_gc.gc_node, &br->mcast_gc_list);
|
|
|
|
queue_work(system_long_wq, &br->mcast_gc_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void br_multicast_destroy_port_group(struct net_bridge_mcast_gc *gc)
|
|
|
|
{
|
|
|
|
struct net_bridge_port_group *pg;
|
|
|
|
|
|
|
|
pg = container_of(gc, struct net_bridge_port_group, mcast_gc);
|
|
|
|
WARN_ON(!hlist_unhashed(&pg->mglist));
|
|
|
|
WARN_ON(!hlist_empty(&pg->src_list));
|
|
|
|
|
|
|
|
del_timer_sync(&pg->rexmit_timer);
|
|
|
|
del_timer_sync(&pg->timer);
|
|
|
|
kfree_rcu(pg, rcu);
|
2020-09-07 17:56:07 +08:00
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:06 +08:00
|
|
|
void br_multicast_del_pg(struct net_bridge_mdb_entry *mp,
|
|
|
|
struct net_bridge_port_group *pg,
|
|
|
|
struct net_bridge_port_group __rcu **pp)
|
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:07 +08:00
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
struct hlist_node *tmp;
|
2020-09-07 17:56:06 +08:00
|
|
|
|
|
|
|
rcu_assign_pointer(*pp, pg->next);
|
|
|
|
hlist_del_init(&pg->mglist);
|
2021-01-20 22:51:56 +08:00
|
|
|
br_multicast_eht_clean_sets(pg);
|
2020-09-07 17:56:07 +08:00
|
|
|
hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
|
|
|
|
br_multicast_del_group_src(ent);
|
2020-09-07 17:56:12 +08:00
|
|
|
br_mdb_notify(br->dev, mp, pg, RTM_DELMDB);
|
2020-09-25 18:25:49 +08:00
|
|
|
if (!br_multicast_is_star_g(&mp->addr)) {
|
|
|
|
rhashtable_remove_fast(&br->sg_port_tbl, &pg->rhnode,
|
|
|
|
br_sg_port_rht_params);
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
br_multicast_sg_del_exclude_ports(mp);
|
2020-09-25 18:25:49 +08:00
|
|
|
} else {
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
br_multicast_star_g_handle_mode(pg, MCAST_INCLUDE);
|
2020-09-25 18:25:49 +08:00
|
|
|
}
|
2020-09-07 17:56:19 +08:00
|
|
|
hlist_add_head(&pg->mcast_gc.gc_node, &br->mcast_gc_list);
|
|
|
|
queue_work(system_long_wq, &br->mcast_gc_work);
|
2020-09-07 17:56:06 +08:00
|
|
|
|
|
|
|
if (!mp->ports && !mp->host_joined && netif_running(br->dev))
|
|
|
|
mod_timer(&mp->timer, jiffies);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void br_multicast_find_del_pg(struct net_bridge *br,
|
|
|
|
struct net_bridge_port_group *pg)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2020-09-07 17:56:07 +08:00
|
|
|
struct net_bridge_port_group __rcu **pp;
|
2010-02-28 03:41:45 +08:00
|
|
|
struct net_bridge_mdb_entry *mp;
|
|
|
|
struct net_bridge_port_group *p;
|
2010-11-15 14:38:10 +08:00
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
mp = br_mdb_ip_get(br, &pg->key.addr);
|
2010-02-28 03:41:45 +08:00
|
|
|
if (WARN_ON(!mp))
|
|
|
|
return;
|
|
|
|
|
2010-11-15 14:38:10 +08:00
|
|
|
for (pp = &mp->ports;
|
|
|
|
(p = mlock_dereference(*pp, br)) != NULL;
|
|
|
|
pp = &p->next) {
|
2010-02-28 03:41:45 +08:00
|
|
|
if (p != pg)
|
|
|
|
continue;
|
|
|
|
|
2020-09-07 17:56:06 +08:00
|
|
|
br_multicast_del_pg(mp, pg, pp);
|
2010-02-28 03:41:45 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON(1);
|
|
|
|
}
|
|
|
|
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_multicast_port_group_expired(struct timer_list *t)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge_port_group *pg = from_timer(pg, t, timer);
|
2020-09-07 17:56:13 +08:00
|
|
|
struct net_bridge_group_src *src_ent;
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:13 +08:00
|
|
|
struct hlist_node *tmp;
|
|
|
|
bool changed;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
if (!netif_running(br->dev) || timer_pending(&pg->timer) ||
|
2016-02-03 16:57:05 +08:00
|
|
|
hlist_unhashed(&pg->mglist) || pg->flags & MDB_PG_FLAGS_PERMANENT)
|
2010-02-28 03:41:45 +08:00
|
|
|
goto out;
|
|
|
|
|
2020-09-07 17:56:13 +08:00
|
|
|
changed = !!(pg->filter_mode == MCAST_EXCLUDE);
|
|
|
|
pg->filter_mode = MCAST_INCLUDE;
|
|
|
|
hlist_for_each_entry_safe(src_ent, tmp, &pg->src_list, node) {
|
|
|
|
if (!timer_pending(&src_ent->timer)) {
|
|
|
|
br_multicast_del_group_src(src_ent);
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hlist_empty(&pg->src_list)) {
|
|
|
|
br_multicast_find_del_pg(br, pg);
|
|
|
|
} else if (changed) {
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge_mdb_entry *mp = br_mdb_ip_get(br, &pg->key.addr);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
if (changed && br_multicast_is_star_g(&pg->key.addr))
|
|
|
|
br_multicast_star_g_handle_mode(pg, MCAST_INCLUDE);
|
|
|
|
|
2020-09-07 17:56:13 +08:00
|
|
|
if (WARN_ON(!mp))
|
|
|
|
goto out;
|
|
|
|
br_mdb_notify(br->dev, mp, pg, RTM_NEWMDB);
|
|
|
|
}
|
2010-02-28 03:41:45 +08:00
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:19 +08:00
|
|
|
static void br_multicast_gc(struct hlist_head *head)
|
|
|
|
{
|
|
|
|
struct net_bridge_mcast_gc *gcent;
|
|
|
|
struct hlist_node *tmp;
|
|
|
|
|
|
|
|
hlist_for_each_entry_safe(gcent, tmp, head, gc_node) {
|
|
|
|
hlist_del_init(&gcent->gc_node);
|
|
|
|
gcent->destroy(gcent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-18 11:42:07 +08:00
|
|
|
static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br,
|
2020-09-07 17:56:09 +08:00
|
|
|
struct net_bridge_port_group *pg,
|
|
|
|
__be32 ip_dst, __be32 group,
|
|
|
|
bool with_srcs, bool over_lmqt,
|
2020-09-07 17:56:10 +08:00
|
|
|
u8 sflag, u8 *igmp_type,
|
|
|
|
bool *need_rexmit)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge_port *p = pg ? pg->key.port : NULL;
|
2020-09-07 17:56:09 +08:00
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
size_t pkt_size, igmp_hdr_size;
|
|
|
|
unsigned long now = jiffies;
|
2016-11-21 20:03:24 +08:00
|
|
|
struct igmpv3_query *ihv3;
|
2020-09-07 17:56:09 +08:00
|
|
|
void *csum_start = NULL;
|
|
|
|
__sum16 *csum = NULL;
|
2010-02-28 03:41:45 +08:00
|
|
|
struct sk_buff *skb;
|
|
|
|
struct igmphdr *ih;
|
|
|
|
struct ethhdr *eth;
|
2020-09-07 17:56:09 +08:00
|
|
|
unsigned long lmqt;
|
2010-02-28 03:41:45 +08:00
|
|
|
struct iphdr *iph;
|
2020-09-07 17:56:09 +08:00
|
|
|
u16 lmqt_srcs = 0;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2016-11-21 20:03:24 +08:00
|
|
|
igmp_hdr_size = sizeof(*ih);
|
2020-09-07 17:56:09 +08:00
|
|
|
if (br->multicast_igmp_version == 3) {
|
2016-11-21 20:03:24 +08:00
|
|
|
igmp_hdr_size = sizeof(*ihv3);
|
2020-09-07 17:56:09 +08:00
|
|
|
if (pg && with_srcs) {
|
|
|
|
lmqt = now + (br->multicast_last_member_interval *
|
|
|
|
br->multicast_last_member_count);
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node) {
|
|
|
|
if (over_lmqt == time_after(ent->timer.expires,
|
|
|
|
lmqt) &&
|
|
|
|
ent->src_query_rexmit_cnt > 0)
|
|
|
|
lmqt_srcs++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!lmqt_srcs)
|
|
|
|
return NULL;
|
|
|
|
igmp_hdr_size += lmqt_srcs * sizeof(__be32);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pkt_size = sizeof(*eth) + sizeof(*iph) + 4 + igmp_hdr_size;
|
|
|
|
if ((p && pkt_size > p->dev->mtu) ||
|
|
|
|
pkt_size > br->dev->mtu)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
skb = netdev_alloc_skb_ip_align(br->dev, pkt_size);
|
2010-02-28 03:41:45 +08:00
|
|
|
if (!skb)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
skb->protocol = htons(ETH_P_IP);
|
|
|
|
|
|
|
|
skb_reset_mac_header(skb);
|
|
|
|
eth = eth_hdr(skb);
|
|
|
|
|
2014-02-23 16:05:25 +08:00
|
|
|
ether_addr_copy(eth->h_source, br->dev->dev_addr);
|
2020-09-07 17:56:09 +08:00
|
|
|
ip_eth_mc_map(ip_dst, eth->h_dest);
|
2010-02-28 03:41:45 +08:00
|
|
|
eth->h_proto = htons(ETH_P_IP);
|
|
|
|
skb_put(skb, sizeof(*eth));
|
|
|
|
|
|
|
|
skb_set_network_header(skb, skb->len);
|
|
|
|
iph = ip_hdr(skb);
|
2020-09-07 17:56:09 +08:00
|
|
|
iph->tot_len = htons(pkt_size - sizeof(*eth));
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
iph->version = 4;
|
|
|
|
iph->ihl = 6;
|
|
|
|
iph->tos = 0xc0;
|
|
|
|
iph->id = 0;
|
|
|
|
iph->frag_off = htons(IP_DF);
|
|
|
|
iph->ttl = 1;
|
|
|
|
iph->protocol = IPPROTO_IGMP;
|
2018-09-26 22:01:04 +08:00
|
|
|
iph->saddr = br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR) ?
|
2013-05-22 05:52:54 +08:00
|
|
|
inet_select_addr(br->dev, 0, RT_SCOPE_LINK) : 0;
|
2020-09-07 17:56:09 +08:00
|
|
|
iph->daddr = ip_dst;
|
2010-02-28 03:41:45 +08:00
|
|
|
((u8 *)&iph[1])[0] = IPOPT_RA;
|
|
|
|
((u8 *)&iph[1])[1] = 4;
|
|
|
|
((u8 *)&iph[1])[2] = 0;
|
|
|
|
((u8 *)&iph[1])[3] = 0;
|
|
|
|
ip_send_check(iph);
|
|
|
|
skb_put(skb, 24);
|
|
|
|
|
|
|
|
skb_set_transport_header(skb, skb->len);
|
2016-06-28 22:57:06 +08:00
|
|
|
*igmp_type = IGMP_HOST_MEMBERSHIP_QUERY;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2016-11-21 20:03:24 +08:00
|
|
|
switch (br->multicast_igmp_version) {
|
|
|
|
case 2:
|
|
|
|
ih = igmp_hdr(skb);
|
|
|
|
ih->type = IGMP_HOST_MEMBERSHIP_QUERY;
|
|
|
|
ih->code = (group ? br->multicast_last_member_interval :
|
|
|
|
br->multicast_query_response_interval) /
|
|
|
|
(HZ / IGMP_TIMER_SCALE);
|
|
|
|
ih->group = group;
|
|
|
|
ih->csum = 0;
|
2020-09-07 17:56:09 +08:00
|
|
|
csum = &ih->csum;
|
|
|
|
csum_start = (void *)ih;
|
2016-11-21 20:03:24 +08:00
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
ihv3 = igmpv3_query_hdr(skb);
|
|
|
|
ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY;
|
|
|
|
ihv3->code = (group ? br->multicast_last_member_interval :
|
|
|
|
br->multicast_query_response_interval) /
|
|
|
|
(HZ / IGMP_TIMER_SCALE);
|
|
|
|
ihv3->group = group;
|
|
|
|
ihv3->qqic = br->multicast_query_interval / HZ;
|
2020-09-07 17:56:09 +08:00
|
|
|
ihv3->nsrcs = htons(lmqt_srcs);
|
2016-11-21 20:03:24 +08:00
|
|
|
ihv3->resv = 0;
|
2020-09-07 17:56:09 +08:00
|
|
|
ihv3->suppress = sflag;
|
2016-11-21 20:03:24 +08:00
|
|
|
ihv3->qrv = 2;
|
|
|
|
ihv3->csum = 0;
|
2020-09-07 17:56:09 +08:00
|
|
|
csum = &ihv3->csum;
|
|
|
|
csum_start = (void *)ihv3;
|
|
|
|
if (!pg || !with_srcs)
|
|
|
|
break;
|
|
|
|
|
|
|
|
lmqt_srcs = 0;
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node) {
|
|
|
|
if (over_lmqt == time_after(ent->timer.expires,
|
|
|
|
lmqt) &&
|
|
|
|
ent->src_query_rexmit_cnt > 0) {
|
2020-09-22 15:30:16 +08:00
|
|
|
ihv3->srcs[lmqt_srcs++] = ent->addr.src.ip4;
|
2020-09-07 17:56:09 +08:00
|
|
|
ent->src_query_rexmit_cnt--;
|
2020-09-07 17:56:10 +08:00
|
|
|
if (need_rexmit && ent->src_query_rexmit_cnt)
|
|
|
|
*need_rexmit = true;
|
2020-09-07 17:56:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (WARN_ON(lmqt_srcs != ntohs(ihv3->nsrcs))) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-11-21 20:03:24 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:09 +08:00
|
|
|
if (WARN_ON(!csum || !csum_start)) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*csum = ip_compute_csum(csum_start, igmp_hdr_size);
|
2016-11-21 20:03:24 +08:00
|
|
|
skb_put(skb, igmp_hdr_size);
|
2010-02-28 03:41:45 +08:00
|
|
|
__skb_pull(skb, sizeof(*eth));
|
|
|
|
|
|
|
|
out:
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2010-04-23 00:54:22 +08:00
|
|
|
static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br,
|
2020-09-07 17:56:09 +08:00
|
|
|
struct net_bridge_port_group *pg,
|
|
|
|
const struct in6_addr *ip6_dst,
|
|
|
|
const struct in6_addr *group,
|
|
|
|
bool with_srcs, bool over_llqt,
|
2020-09-07 17:56:10 +08:00
|
|
|
u8 sflag, u8 *igmp_type,
|
|
|
|
bool *need_rexmit)
|
2010-04-23 00:54:22 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge_port *p = pg ? pg->key.port : NULL;
|
2020-09-07 17:56:09 +08:00
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
size_t pkt_size, mld_hdr_size;
|
|
|
|
unsigned long now = jiffies;
|
2016-11-21 20:03:25 +08:00
|
|
|
struct mld2_query *mld2q;
|
2020-09-07 17:56:09 +08:00
|
|
|
void *csum_start = NULL;
|
2016-11-21 20:03:25 +08:00
|
|
|
unsigned long interval;
|
2020-09-07 17:56:09 +08:00
|
|
|
__sum16 *csum = NULL;
|
2010-04-23 00:54:22 +08:00
|
|
|
struct ipv6hdr *ip6h;
|
|
|
|
struct mld_msg *mldq;
|
2016-11-21 20:03:25 +08:00
|
|
|
struct sk_buff *skb;
|
2020-09-07 17:56:09 +08:00
|
|
|
unsigned long llqt;
|
2010-04-23 00:54:22 +08:00
|
|
|
struct ethhdr *eth;
|
2020-09-07 17:56:09 +08:00
|
|
|
u16 llqt_srcs = 0;
|
2010-04-23 00:54:22 +08:00
|
|
|
u8 *hopopt;
|
|
|
|
|
2016-11-21 20:03:25 +08:00
|
|
|
mld_hdr_size = sizeof(*mldq);
|
2020-09-07 17:56:09 +08:00
|
|
|
if (br->multicast_mld_version == 2) {
|
2016-11-21 20:03:25 +08:00
|
|
|
mld_hdr_size = sizeof(*mld2q);
|
2020-09-07 17:56:09 +08:00
|
|
|
if (pg && with_srcs) {
|
|
|
|
llqt = now + (br->multicast_last_member_interval *
|
|
|
|
br->multicast_last_member_count);
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node) {
|
|
|
|
if (over_llqt == time_after(ent->timer.expires,
|
|
|
|
llqt) &&
|
|
|
|
ent->src_query_rexmit_cnt > 0)
|
|
|
|
llqt_srcs++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!llqt_srcs)
|
|
|
|
return NULL;
|
|
|
|
mld_hdr_size += llqt_srcs * sizeof(struct in6_addr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pkt_size = sizeof(*eth) + sizeof(*ip6h) + 8 + mld_hdr_size;
|
|
|
|
if ((p && pkt_size > p->dev->mtu) ||
|
|
|
|
pkt_size > br->dev->mtu)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
skb = netdev_alloc_skb_ip_align(br->dev, pkt_size);
|
2010-04-23 00:54:22 +08:00
|
|
|
if (!skb)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
skb->protocol = htons(ETH_P_IPV6);
|
|
|
|
|
|
|
|
/* Ethernet header */
|
|
|
|
skb_reset_mac_header(skb);
|
|
|
|
eth = eth_hdr(skb);
|
|
|
|
|
2014-02-23 16:05:25 +08:00
|
|
|
ether_addr_copy(eth->h_source, br->dev->dev_addr);
|
2010-04-23 00:54:22 +08:00
|
|
|
eth->h_proto = htons(ETH_P_IPV6);
|
|
|
|
skb_put(skb, sizeof(*eth));
|
|
|
|
|
|
|
|
/* IPv6 header + HbH option */
|
|
|
|
skb_set_network_header(skb, skb->len);
|
|
|
|
ip6h = ipv6_hdr(skb);
|
|
|
|
|
|
|
|
*(__force __be32 *)ip6h = htonl(0x60000000);
|
2016-11-21 20:03:25 +08:00
|
|
|
ip6h->payload_len = htons(8 + mld_hdr_size);
|
2010-04-23 00:54:22 +08:00
|
|
|
ip6h->nexthdr = IPPROTO_HOPOPTS;
|
|
|
|
ip6h->hop_limit = 1;
|
2020-09-07 17:56:09 +08:00
|
|
|
ip6h->daddr = *ip6_dst;
|
2012-03-05 12:52:44 +08:00
|
|
|
if (ipv6_dev_get_saddr(dev_net(br->dev), br->dev, &ip6h->daddr, 0,
|
|
|
|
&ip6h->saddr)) {
|
|
|
|
kfree_skb(skb);
|
2018-09-26 22:01:04 +08:00
|
|
|
br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, false);
|
2012-03-05 12:52:44 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
2016-06-24 18:35:18 +08:00
|
|
|
|
2018-09-26 22:01:04 +08:00
|
|
|
br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
|
2011-02-17 16:17:51 +08:00
|
|
|
ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
|
2010-04-23 00:54:22 +08:00
|
|
|
|
|
|
|
hopopt = (u8 *)(ip6h + 1);
|
|
|
|
hopopt[0] = IPPROTO_ICMPV6; /* next hdr */
|
|
|
|
hopopt[1] = 0; /* length of HbH */
|
|
|
|
hopopt[2] = IPV6_TLV_ROUTERALERT; /* Router Alert */
|
|
|
|
hopopt[3] = 2; /* Length of RA Option */
|
|
|
|
hopopt[4] = 0; /* Type = 0x0000 (MLD) */
|
|
|
|
hopopt[5] = 0;
|
2012-05-17 14:00:25 +08:00
|
|
|
hopopt[6] = IPV6_TLV_PAD1; /* Pad1 */
|
|
|
|
hopopt[7] = IPV6_TLV_PAD1; /* Pad1 */
|
2010-04-23 00:54:22 +08:00
|
|
|
|
|
|
|
skb_put(skb, sizeof(*ip6h) + 8);
|
|
|
|
|
|
|
|
/* ICMPv6 */
|
|
|
|
skb_set_transport_header(skb, skb->len);
|
2020-09-07 17:56:09 +08:00
|
|
|
interval = ipv6_addr_any(group) ?
|
2013-06-17 05:20:34 +08:00
|
|
|
br->multicast_query_response_interval :
|
|
|
|
br->multicast_last_member_interval;
|
2016-06-28 22:57:06 +08:00
|
|
|
*igmp_type = ICMPV6_MGM_QUERY;
|
2016-11-21 20:03:25 +08:00
|
|
|
switch (br->multicast_mld_version) {
|
|
|
|
case 1:
|
|
|
|
mldq = (struct mld_msg *)icmp6_hdr(skb);
|
|
|
|
mldq->mld_type = ICMPV6_MGM_QUERY;
|
|
|
|
mldq->mld_code = 0;
|
|
|
|
mldq->mld_cksum = 0;
|
|
|
|
mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval));
|
|
|
|
mldq->mld_reserved = 0;
|
2020-09-07 17:56:09 +08:00
|
|
|
mldq->mld_mca = *group;
|
|
|
|
csum = &mldq->mld_cksum;
|
|
|
|
csum_start = (void *)mldq;
|
2016-11-21 20:03:25 +08:00
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
mld2q = (struct mld2_query *)icmp6_hdr(skb);
|
2017-01-17 07:11:35 +08:00
|
|
|
mld2q->mld2q_mrc = htons((u16)jiffies_to_msecs(interval));
|
2016-11-21 20:03:25 +08:00
|
|
|
mld2q->mld2q_type = ICMPV6_MGM_QUERY;
|
|
|
|
mld2q->mld2q_code = 0;
|
|
|
|
mld2q->mld2q_cksum = 0;
|
|
|
|
mld2q->mld2q_resv1 = 0;
|
|
|
|
mld2q->mld2q_resv2 = 0;
|
2020-09-07 17:56:09 +08:00
|
|
|
mld2q->mld2q_suppress = sflag;
|
2016-11-21 20:03:25 +08:00
|
|
|
mld2q->mld2q_qrv = 2;
|
2020-09-07 17:56:09 +08:00
|
|
|
mld2q->mld2q_nsrcs = htons(llqt_srcs);
|
2016-11-21 20:03:25 +08:00
|
|
|
mld2q->mld2q_qqic = br->multicast_query_interval / HZ;
|
2020-09-07 17:56:09 +08:00
|
|
|
mld2q->mld2q_mca = *group;
|
|
|
|
csum = &mld2q->mld2q_cksum;
|
|
|
|
csum_start = (void *)mld2q;
|
|
|
|
if (!pg || !with_srcs)
|
|
|
|
break;
|
|
|
|
|
|
|
|
llqt_srcs = 0;
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node) {
|
|
|
|
if (over_llqt == time_after(ent->timer.expires,
|
|
|
|
llqt) &&
|
|
|
|
ent->src_query_rexmit_cnt > 0) {
|
2020-09-22 15:30:16 +08:00
|
|
|
mld2q->mld2q_srcs[llqt_srcs++] = ent->addr.src.ip6;
|
2020-09-07 17:56:09 +08:00
|
|
|
ent->src_query_rexmit_cnt--;
|
2020-09-07 17:56:10 +08:00
|
|
|
if (need_rexmit && ent->src_query_rexmit_cnt)
|
|
|
|
*need_rexmit = true;
|
2020-09-07 17:56:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (WARN_ON(llqt_srcs != ntohs(mld2q->mld2q_nsrcs))) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-11-21 20:03:25 +08:00
|
|
|
break;
|
|
|
|
}
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2020-09-07 17:56:09 +08:00
|
|
|
if (WARN_ON(!csum || !csum_start)) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*csum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr, mld_hdr_size,
|
|
|
|
IPPROTO_ICMPV6,
|
|
|
|
csum_partial(csum_start, mld_hdr_size, 0));
|
|
|
|
skb_put(skb, mld_hdr_size);
|
2010-04-23 00:54:22 +08:00
|
|
|
__skb_pull(skb, sizeof(*eth));
|
|
|
|
|
|
|
|
out:
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-04-18 11:42:07 +08:00
|
|
|
static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
|
2020-09-07 17:56:09 +08:00
|
|
|
struct net_bridge_port_group *pg,
|
|
|
|
struct br_ip *ip_dst,
|
|
|
|
struct br_ip *group,
|
|
|
|
bool with_srcs, bool over_lmqt,
|
2020-09-07 17:56:10 +08:00
|
|
|
u8 sflag, u8 *igmp_type,
|
|
|
|
bool *need_rexmit)
|
2010-04-18 11:42:07 +08:00
|
|
|
{
|
2020-09-07 17:56:09 +08:00
|
|
|
__be32 ip4_dst;
|
|
|
|
|
|
|
|
switch (group->proto) {
|
2010-04-18 11:42:07 +08:00
|
|
|
case htons(ETH_P_IP):
|
2020-09-22 15:30:17 +08:00
|
|
|
ip4_dst = ip_dst ? ip_dst->dst.ip4 : htonl(INADDR_ALLHOSTS_GROUP);
|
2020-09-07 17:56:09 +08:00
|
|
|
return br_ip4_multicast_alloc_query(br, pg,
|
2020-09-22 15:30:17 +08:00
|
|
|
ip4_dst, group->dst.ip4,
|
2020-09-07 17:56:09 +08:00
|
|
|
with_srcs, over_lmqt,
|
2020-09-07 17:56:10 +08:00
|
|
|
sflag, igmp_type,
|
|
|
|
need_rexmit);
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2020-09-07 17:56:09 +08:00
|
|
|
case htons(ETH_P_IPV6): {
|
|
|
|
struct in6_addr ip6_dst;
|
|
|
|
|
|
|
|
if (ip_dst)
|
2020-09-22 15:30:17 +08:00
|
|
|
ip6_dst = ip_dst->dst.ip6;
|
2020-09-07 17:56:09 +08:00
|
|
|
else
|
|
|
|
ipv6_addr_set(&ip6_dst, htonl(0xff020000), 0, 0,
|
|
|
|
htonl(1));
|
|
|
|
|
|
|
|
return br_ip6_multicast_alloc_query(br, pg,
|
2020-09-22 15:30:17 +08:00
|
|
|
&ip6_dst, &group->dst.ip6,
|
2020-09-07 17:56:09 +08:00
|
|
|
with_srcs, over_lmqt,
|
2020-09-07 17:56:10 +08:00
|
|
|
sflag, igmp_type,
|
|
|
|
need_rexmit);
|
2020-09-07 17:56:09 +08:00
|
|
|
}
|
2010-04-23 00:54:22 +08:00
|
|
|
#endif
|
2010-04-18 11:42:07 +08:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-12-12 06:23:08 +08:00
|
|
|
struct net_bridge_mdb_entry *br_multicast_new_group(struct net_bridge *br,
|
2016-11-21 20:03:24 +08:00
|
|
|
struct br_ip *group)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_mdb_entry *mp;
|
2010-12-10 11:18:04 +08:00
|
|
|
int err;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
mp = br_mdb_ip_get(br, group);
|
|
|
|
if (mp)
|
|
|
|
return mp;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
if (atomic_read(&br->mdb_hash_tbl.nelems) >= br->hash_max) {
|
|
|
|
br_opt_toggle(br, BROPT_MULTICAST_ENABLED, false);
|
|
|
|
return ERR_PTR(-E2BIG);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
mp = kzalloc(sizeof(*mp), GFP_ATOMIC);
|
|
|
|
if (unlikely(!mp))
|
2010-12-10 11:18:04 +08:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
mp->br = br;
|
2010-04-18 11:42:07 +08:00
|
|
|
mp->addr = *group;
|
2020-09-07 17:56:19 +08:00
|
|
|
mp->mcast_gc.destroy = br_multicast_destroy_mdb_entry;
|
2017-11-03 14:21:10 +08:00
|
|
|
timer_setup(&mp->timer, br_multicast_group_expired, 0);
|
2018-12-05 21:14:24 +08:00
|
|
|
err = rhashtable_lookup_insert_fast(&br->mdb_hash_tbl, &mp->rhnode,
|
|
|
|
br_mdb_rht_params);
|
|
|
|
if (err) {
|
|
|
|
kfree(mp);
|
|
|
|
mp = ERR_PTR(err);
|
|
|
|
} else {
|
|
|
|
hlist_add_head_rcu(&mp->mdb_node, &br->mdb_list);
|
|
|
|
}
|
2013-07-20 11:07:16 +08:00
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
return mp;
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:07 +08:00
|
|
|
static void br_multicast_group_src_expired(struct timer_list *t)
|
|
|
|
{
|
|
|
|
struct net_bridge_group_src *src = from_timer(src, t, timer);
|
|
|
|
struct net_bridge_port_group *pg;
|
|
|
|
struct net_bridge *br = src->br;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
if (hlist_unhashed(&src->node) || !netif_running(br->dev) ||
|
|
|
|
timer_pending(&src->timer))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
pg = src->pg;
|
|
|
|
if (pg->filter_mode == MCAST_INCLUDE) {
|
|
|
|
br_multicast_del_group_src(src);
|
|
|
|
if (!hlist_empty(&pg->src_list))
|
|
|
|
goto out;
|
|
|
|
br_multicast_find_del_pg(br, pg);
|
2020-09-22 15:30:25 +08:00
|
|
|
} else {
|
|
|
|
br_multicast_fwd_src_handle(src);
|
2020-09-07 17:56:07 +08:00
|
|
|
}
|
2020-09-22 15:30:25 +08:00
|
|
|
|
2020-09-07 17:56:07 +08:00
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:58 +08:00
|
|
|
struct net_bridge_group_src *
|
2020-09-07 17:56:07 +08:00
|
|
|
br_multicast_find_group_src(struct net_bridge_port_group *pg, struct br_ip *ip)
|
|
|
|
{
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
|
|
|
|
switch (ip->proto) {
|
|
|
|
case htons(ETH_P_IP):
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
2020-09-22 15:30:16 +08:00
|
|
|
if (ip->src.ip4 == ent->addr.src.ip4)
|
2020-09-07 17:56:07 +08:00
|
|
|
return ent;
|
|
|
|
break;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
case htons(ETH_P_IPV6):
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
2020-09-22 15:30:16 +08:00
|
|
|
if (!ipv6_addr_cmp(&ent->addr.src.ip6, &ip->src.ip6))
|
2020-09-07 17:56:07 +08:00
|
|
|
return ent;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct net_bridge_group_src *
|
|
|
|
br_multicast_new_group_src(struct net_bridge_port_group *pg, struct br_ip *src_ip)
|
|
|
|
{
|
|
|
|
struct net_bridge_group_src *grp_src;
|
|
|
|
|
|
|
|
if (unlikely(pg->src_ents >= PG_SRC_ENT_LIMIT))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
switch (src_ip->proto) {
|
|
|
|
case htons(ETH_P_IP):
|
2020-09-22 15:30:16 +08:00
|
|
|
if (ipv4_is_zeronet(src_ip->src.ip4) ||
|
|
|
|
ipv4_is_multicast(src_ip->src.ip4))
|
2020-09-07 17:56:07 +08:00
|
|
|
return NULL;
|
|
|
|
break;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
case htons(ETH_P_IPV6):
|
2020-09-22 15:30:16 +08:00
|
|
|
if (ipv6_addr_any(&src_ip->src.ip6) ||
|
|
|
|
ipv6_addr_is_multicast(&src_ip->src.ip6))
|
2020-09-07 17:56:07 +08:00
|
|
|
return NULL;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
grp_src = kzalloc(sizeof(*grp_src), GFP_ATOMIC);
|
|
|
|
if (unlikely(!grp_src))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
grp_src->pg = pg;
|
2020-09-22 15:30:22 +08:00
|
|
|
grp_src->br = pg->key.port->br;
|
2020-09-07 17:56:07 +08:00
|
|
|
grp_src->addr = *src_ip;
|
2020-09-07 17:56:19 +08:00
|
|
|
grp_src->mcast_gc.destroy = br_multicast_destroy_group_src;
|
2020-09-07 17:56:07 +08:00
|
|
|
timer_setup(&grp_src->timer, br_multicast_group_src_expired, 0);
|
|
|
|
|
|
|
|
hlist_add_head_rcu(&grp_src->node, &pg->src_list);
|
|
|
|
pg->src_ents++;
|
|
|
|
|
|
|
|
return grp_src;
|
|
|
|
}
|
|
|
|
|
2012-12-12 06:23:08 +08:00
|
|
|
struct net_bridge_port_group *br_multicast_new_port_group(
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
struct br_ip *group,
|
2012-12-15 06:09:51 +08:00
|
|
|
struct net_bridge_port_group __rcu *next,
|
2017-01-22 04:01:32 +08:00
|
|
|
unsigned char flags,
|
2020-09-07 17:56:07 +08:00
|
|
|
const unsigned char *src,
|
2020-09-22 15:30:21 +08:00
|
|
|
u8 filter_mode,
|
|
|
|
u8 rt_protocol)
|
2012-12-12 06:23:08 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_port_group *p;
|
|
|
|
|
|
|
|
p = kzalloc(sizeof(*p), GFP_ATOMIC);
|
|
|
|
if (unlikely(!p))
|
|
|
|
return NULL;
|
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
p->key.addr = *group;
|
|
|
|
p->key.port = port;
|
2016-02-03 16:57:05 +08:00
|
|
|
p->flags = flags;
|
2020-09-07 17:56:07 +08:00
|
|
|
p->filter_mode = filter_mode;
|
2020-09-22 15:30:21 +08:00
|
|
|
p->rt_protocol = rt_protocol;
|
2021-01-20 22:51:55 +08:00
|
|
|
p->eht_host_tree = RB_ROOT;
|
2021-01-20 22:51:56 +08:00
|
|
|
p->eht_set_tree = RB_ROOT;
|
2020-09-07 17:56:19 +08:00
|
|
|
p->mcast_gc.destroy = br_multicast_destroy_port_group;
|
2020-09-07 17:56:07 +08:00
|
|
|
INIT_HLIST_HEAD(&p->src_list);
|
2020-09-22 15:30:22 +08:00
|
|
|
|
|
|
|
if (!br_multicast_is_star_g(group) &&
|
|
|
|
rhashtable_lookup_insert_fast(&port->br->sg_port_tbl, &p->rhnode,
|
|
|
|
br_sg_port_rht_params)) {
|
|
|
|
kfree(p);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-12-13 14:51:28 +08:00
|
|
|
rcu_assign_pointer(p->next, next);
|
2017-11-03 14:21:10 +08:00
|
|
|
timer_setup(&p->timer, br_multicast_port_group_expired, 0);
|
2020-09-07 17:56:10 +08:00
|
|
|
timer_setup(&p->rexmit_timer, br_multicast_port_group_rexmit, 0);
|
|
|
|
hlist_add_head(&p->mglist, &port->mglist);
|
2017-01-22 04:01:32 +08:00
|
|
|
|
|
|
|
if (src)
|
|
|
|
memcpy(p->eth_addr, src, ETH_ALEN);
|
|
|
|
else
|
2019-03-20 10:06:57 +08:00
|
|
|
eth_broadcast_addr(p->eth_addr);
|
2017-01-22 04:01:32 +08:00
|
|
|
|
2012-12-12 06:23:08 +08:00
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
2019-08-17 19:22:13 +08:00
|
|
|
void br_multicast_host_join(struct net_bridge_mdb_entry *mp, bool notify)
|
|
|
|
{
|
|
|
|
if (!mp->host_joined) {
|
|
|
|
mp->host_joined = true;
|
2020-09-22 15:30:26 +08:00
|
|
|
if (br_multicast_is_star_g(&mp->addr))
|
|
|
|
br_multicast_star_g_host_state(mp);
|
2019-08-17 19:22:13 +08:00
|
|
|
if (notify)
|
2020-09-07 17:56:12 +08:00
|
|
|
br_mdb_notify(mp->br->dev, mp, NULL, RTM_NEWMDB);
|
2019-08-17 19:22:13 +08:00
|
|
|
}
|
2020-10-29 07:38:31 +08:00
|
|
|
|
|
|
|
if (br_group_is_l2(&mp->addr))
|
|
|
|
return;
|
|
|
|
|
2019-08-17 19:22:13 +08:00
|
|
|
mod_timer(&mp->timer, jiffies + mp->br->multicast_membership_interval);
|
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify)
|
|
|
|
{
|
|
|
|
if (!mp->host_joined)
|
|
|
|
return;
|
|
|
|
|
|
|
|
mp->host_joined = false;
|
2020-09-22 15:30:26 +08:00
|
|
|
if (br_multicast_is_star_g(&mp->addr))
|
|
|
|
br_multicast_star_g_host_state(mp);
|
2019-08-17 19:22:13 +08:00
|
|
|
if (notify)
|
2020-09-07 17:56:12 +08:00
|
|
|
br_mdb_notify(mp->br->dev, mp, NULL, RTM_DELMDB);
|
2019-08-17 19:22:13 +08:00
|
|
|
}
|
|
|
|
|
2020-09-22 15:30:23 +08:00
|
|
|
static struct net_bridge_port_group *
|
|
|
|
__br_multicast_add_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
struct br_ip *group,
|
|
|
|
const unsigned char *src,
|
|
|
|
u8 filter_mode,
|
2020-09-22 15:30:25 +08:00
|
|
|
bool igmpv2_mldv1,
|
|
|
|
bool blocked)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2010-11-15 14:38:10 +08:00
|
|
|
struct net_bridge_port_group __rcu **pp;
|
2020-09-22 15:30:23 +08:00
|
|
|
struct net_bridge_port_group *p = NULL;
|
2016-11-21 20:03:24 +08:00
|
|
|
struct net_bridge_mdb_entry *mp;
|
2013-10-20 06:58:57 +08:00
|
|
|
unsigned long now = jiffies;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
if (!netif_running(br->dev) ||
|
|
|
|
(port && port->state == BR_STATE_DISABLED))
|
|
|
|
goto out;
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
mp = br_multicast_new_group(br, group);
|
2010-12-10 11:18:04 +08:00
|
|
|
if (IS_ERR(mp))
|
2020-09-22 15:30:23 +08:00
|
|
|
return ERR_PTR(PTR_ERR(mp));
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
if (!port) {
|
2019-08-17 19:22:13 +08:00
|
|
|
br_multicast_host_join(mp, true);
|
2010-02-28 03:41:45 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-11-15 14:38:10 +08:00
|
|
|
for (pp = &mp->ports;
|
|
|
|
(p = mlock_dereference(*pp, br)) != NULL;
|
|
|
|
pp = &p->next) {
|
2017-01-22 04:01:32 +08:00
|
|
|
if (br_port_group_equal(p, port, src))
|
2013-10-20 06:58:57 +08:00
|
|
|
goto found;
|
2020-09-22 15:30:22 +08:00
|
|
|
if ((unsigned long)p->key.port < (unsigned long)port)
|
2010-02-28 03:41:45 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2020-10-29 07:38:31 +08:00
|
|
|
p = br_multicast_new_port_group(port, group, *pp, 0, src,
|
|
|
|
filter_mode, RTPROT_KERNEL);
|
2020-09-22 15:30:23 +08:00
|
|
|
if (unlikely(!p)) {
|
|
|
|
p = ERR_PTR(-ENOMEM);
|
|
|
|
goto out;
|
|
|
|
}
|
2010-02-28 03:41:45 +08:00
|
|
|
rcu_assign_pointer(*pp, p);
|
2020-09-22 15:30:25 +08:00
|
|
|
if (blocked)
|
|
|
|
p->flags |= MDB_PG_FLAGS_BLOCKED;
|
2020-09-07 17:56:12 +08:00
|
|
|
br_mdb_notify(br->dev, mp, p, RTM_NEWMDB);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2013-10-20 06:58:57 +08:00
|
|
|
found:
|
2020-09-07 17:56:14 +08:00
|
|
|
if (igmpv2_mldv1)
|
|
|
|
mod_timer(&p->timer, now + br->multicast_membership_interval);
|
2020-09-07 17:56:12 +08:00
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
out:
|
2020-09-22 15:30:23 +08:00
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int br_multicast_add_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
struct br_ip *group,
|
|
|
|
const unsigned char *src,
|
|
|
|
u8 filter_mode,
|
|
|
|
bool igmpv2_mldv1)
|
|
|
|
{
|
|
|
|
struct net_bridge_port_group *pg;
|
|
|
|
int err;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2020-09-22 15:30:23 +08:00
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
pg = __br_multicast_add_group(br, port, group, src, filter_mode,
|
2020-09-22 15:30:25 +08:00
|
|
|
igmpv2_mldv1, false);
|
2020-09-22 15:30:23 +08:00
|
|
|
/* NULL is considered valid for host joined groups */
|
|
|
|
err = IS_ERR(pg) ? PTR_ERR(pg) : 0;
|
2010-02-28 03:41:45 +08:00
|
|
|
spin_unlock(&br->multicast_lock);
|
2020-09-22 15:30:23 +08:00
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-04-18 11:42:07 +08:00
|
|
|
static int br_ip4_multicast_add_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-02-13 20:00:17 +08:00
|
|
|
__be32 group,
|
2017-01-22 04:01:32 +08:00
|
|
|
__u16 vid,
|
2020-09-07 17:56:07 +08:00
|
|
|
const unsigned char *src,
|
|
|
|
bool igmpv2)
|
2010-04-18 11:42:07 +08:00
|
|
|
{
|
|
|
|
struct br_ip br_group;
|
2020-09-07 17:56:07 +08:00
|
|
|
u8 filter_mode;
|
2010-04-18 11:42:07 +08:00
|
|
|
|
|
|
|
if (ipv4_is_local_multicast(group))
|
|
|
|
return 0;
|
|
|
|
|
2019-04-04 04:27:24 +08:00
|
|
|
memset(&br_group, 0, sizeof(br_group));
|
2020-09-22 15:30:17 +08:00
|
|
|
br_group.dst.ip4 = group;
|
2010-04-18 11:42:07 +08:00
|
|
|
br_group.proto = htons(ETH_P_IP);
|
2013-02-13 20:00:17 +08:00
|
|
|
br_group.vid = vid;
|
2020-09-07 17:56:07 +08:00
|
|
|
filter_mode = igmpv2 ? MCAST_EXCLUDE : MCAST_INCLUDE;
|
2010-04-18 11:42:07 +08:00
|
|
|
|
2020-09-07 17:56:14 +08:00
|
|
|
return br_multicast_add_group(br, port, &br_group, src, filter_mode,
|
|
|
|
igmpv2);
|
2010-04-18 11:42:07 +08:00
|
|
|
}
|
|
|
|
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2010-04-23 00:54:22 +08:00
|
|
|
static int br_ip6_multicast_add_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-02-13 20:00:17 +08:00
|
|
|
const struct in6_addr *group,
|
2017-01-22 04:01:32 +08:00
|
|
|
__u16 vid,
|
2020-09-07 17:56:07 +08:00
|
|
|
const unsigned char *src,
|
|
|
|
bool mldv1)
|
2010-04-23 00:54:22 +08:00
|
|
|
{
|
|
|
|
struct br_ip br_group;
|
2020-09-07 17:56:07 +08:00
|
|
|
u8 filter_mode;
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2013-09-04 08:13:39 +08:00
|
|
|
if (ipv6_addr_is_ll_all_nodes(group))
|
2010-04-23 00:54:22 +08:00
|
|
|
return 0;
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
memset(&br_group, 0, sizeof(br_group));
|
2020-09-22 15:30:17 +08:00
|
|
|
br_group.dst.ip6 = *group;
|
2011-02-15 21:19:17 +08:00
|
|
|
br_group.proto = htons(ETH_P_IPV6);
|
2013-02-13 20:00:17 +08:00
|
|
|
br_group.vid = vid;
|
2020-09-07 17:56:07 +08:00
|
|
|
filter_mode = mldv1 ? MCAST_EXCLUDE : MCAST_INCLUDE;
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2020-09-07 17:56:14 +08:00
|
|
|
return br_multicast_add_group(br, port, &br_group, src, filter_mode,
|
|
|
|
mldv1);
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_multicast_router_expired(struct timer_list *t)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge_port *port =
|
|
|
|
from_timer(port, t, multicast_router_timer);
|
2010-02-28 03:41:45 +08:00
|
|
|
struct net_bridge *br = port->br;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
2016-02-27 04:20:03 +08:00
|
|
|
if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
|
|
|
|
port->multicast_router == MDB_RTR_TYPE_PERM ||
|
2017-02-09 21:54:41 +08:00
|
|
|
timer_pending(&port->multicast_router_timer))
|
2010-02-28 03:41:45 +08:00
|
|
|
goto out;
|
|
|
|
|
2017-02-09 21:54:41 +08:00
|
|
|
__del_port_router(port);
|
2010-02-28 03:41:45 +08:00
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2017-10-09 17:15:31 +08:00
|
|
|
static void br_mc_router_state_change(struct net_bridge *p,
|
|
|
|
bool is_mc_router)
|
|
|
|
{
|
|
|
|
struct switchdev_attr attr = {
|
|
|
|
.orig_dev = p->dev,
|
|
|
|
.id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER,
|
|
|
|
.flags = SWITCHDEV_F_DEFER,
|
|
|
|
.u.mrouter = is_mc_router,
|
|
|
|
};
|
|
|
|
|
|
|
|
switchdev_port_attr_set(p->dev, &attr);
|
|
|
|
}
|
|
|
|
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_multicast_local_router_expired(struct timer_list *t)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge *br = from_timer(br, t, multicast_router_timer);
|
2017-10-09 17:15:31 +08:00
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
if (br->multicast_router == MDB_RTR_TYPE_DISABLED ||
|
|
|
|
br->multicast_router == MDB_RTR_TYPE_PERM ||
|
|
|
|
timer_pending(&br->multicast_router_timer))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
br_mc_router_state_change(br, false);
|
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
static void br_multicast_querier_expired(struct net_bridge *br,
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_own_query *query)
|
2012-04-13 10:37:42 +08:00
|
|
|
{
|
|
|
|
spin_lock(&br->multicast_lock);
|
2018-09-26 22:01:03 +08:00
|
|
|
if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
|
2012-04-13 10:37:42 +08:00
|
|
|
goto out;
|
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
br_multicast_start_querier(br, query);
|
2012-04-13 10:37:42 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_ip4_multicast_querier_expired(struct timer_list *t)
|
2013-08-30 23:28:17 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge *br = from_timer(br, t, ip4_other_query.timer);
|
2013-08-30 23:28:17 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_querier_expired(br, &br->ip4_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_ip6_multicast_querier_expired(struct timer_list *t)
|
2013-08-30 23:28:17 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge *br = from_timer(br, t, ip6_other_query.timer);
|
2013-08-30 23:28:17 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_querier_expired(br, &br->ip6_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
static void br_multicast_select_own_querier(struct net_bridge *br,
|
|
|
|
struct br_ip *ip,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
if (ip->proto == htons(ETH_P_IP))
|
2020-09-22 15:30:16 +08:00
|
|
|
br->ip4_querier.addr.src.ip4 = ip_hdr(skb)->saddr;
|
2014-06-08 00:26:27 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
else
|
2020-09-22 15:30:16 +08:00
|
|
|
br->ip6_querier.addr.src.ip6 = ipv6_hdr(skb)->saddr;
|
2014-06-08 00:26:27 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-04-18 11:42:07 +08:00
|
|
|
static void __br_multicast_send_query(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2020-09-07 17:56:09 +08:00
|
|
|
struct net_bridge_port_group *pg,
|
|
|
|
struct br_ip *ip_dst,
|
|
|
|
struct br_ip *group,
|
|
|
|
bool with_srcs,
|
2020-09-07 17:56:10 +08:00
|
|
|
u8 sflag,
|
|
|
|
bool *need_rexmit)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2020-09-07 17:56:09 +08:00
|
|
|
bool over_lmqt = !!sflag;
|
2010-02-28 03:41:45 +08:00
|
|
|
struct sk_buff *skb;
|
2016-06-28 22:57:06 +08:00
|
|
|
u8 igmp_type;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2020-09-07 17:56:09 +08:00
|
|
|
again_under_lmqt:
|
|
|
|
skb = br_multicast_alloc_query(br, pg, ip_dst, group, with_srcs,
|
2020-09-07 17:56:10 +08:00
|
|
|
over_lmqt, sflag, &igmp_type,
|
|
|
|
need_rexmit);
|
2010-02-28 03:41:45 +08:00
|
|
|
if (!skb)
|
2010-04-18 11:42:07 +08:00
|
|
|
return;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
if (port) {
|
|
|
|
skb->dev = port->dev;
|
2016-07-07 03:12:21 +08:00
|
|
|
br_multicast_count(br, port, skb, igmp_type,
|
2016-06-28 22:57:06 +08:00
|
|
|
BR_MCAST_DIR_TX);
|
2015-09-16 09:04:16 +08:00
|
|
|
NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT,
|
|
|
|
dev_net(port->dev), NULL, skb, NULL, skb->dev,
|
2014-11-17 19:20:28 +08:00
|
|
|
br_dev_queue_push_xmit);
|
2020-09-07 17:56:09 +08:00
|
|
|
|
|
|
|
if (over_lmqt && with_srcs && sflag) {
|
|
|
|
over_lmqt = false;
|
|
|
|
goto again_under_lmqt;
|
|
|
|
}
|
2014-06-08 00:26:27 +08:00
|
|
|
} else {
|
2020-09-07 17:56:09 +08:00
|
|
|
br_multicast_select_own_querier(br, group, skb);
|
2016-07-07 03:12:21 +08:00
|
|
|
br_multicast_count(br, port, skb, igmp_type,
|
2016-06-28 22:57:06 +08:00
|
|
|
BR_MCAST_DIR_RX);
|
2010-02-28 03:41:45 +08:00
|
|
|
netif_rx(skb);
|
2014-06-08 00:26:27 +08:00
|
|
|
}
|
2010-04-18 11:42:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void br_multicast_send_query(struct net_bridge *br,
|
2013-08-30 23:28:17 +08:00
|
|
|
struct net_bridge_port *port,
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_own_query *own_query)
|
2010-04-18 11:42:07 +08:00
|
|
|
{
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_other_query *other_query = NULL;
|
2016-11-21 20:03:24 +08:00
|
|
|
struct br_ip br_group;
|
|
|
|
unsigned long time;
|
2010-04-18 11:42:07 +08:00
|
|
|
|
2018-09-26 22:01:03 +08:00
|
|
|
if (!netif_running(br->dev) ||
|
|
|
|
!br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
|
2018-09-26 22:01:04 +08:00
|
|
|
!br_opt_get(br, BROPT_MULTICAST_QUERIER))
|
2010-04-18 11:42:07 +08:00
|
|
|
return;
|
|
|
|
|
2020-09-22 15:30:17 +08:00
|
|
|
memset(&br_group.dst, 0, sizeof(br_group.dst));
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
if (port ? (own_query == &port->ip4_own_query) :
|
|
|
|
(own_query == &br->ip4_own_query)) {
|
|
|
|
other_query = &br->ip4_other_query;
|
2013-08-30 23:28:17 +08:00
|
|
|
br_group.proto = htons(ETH_P_IP);
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2013-08-30 23:28:17 +08:00
|
|
|
} else {
|
2014-06-08 00:26:26 +08:00
|
|
|
other_query = &br->ip6_other_query;
|
2013-08-30 23:28:17 +08:00
|
|
|
br_group.proto = htons(ETH_P_IPV6);
|
2010-04-23 00:54:22 +08:00
|
|
|
#endif
|
2013-08-30 23:28:17 +08:00
|
|
|
}
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
if (!other_query || timer_pending(&other_query->timer))
|
2013-08-30 23:28:17 +08:00
|
|
|
return;
|
|
|
|
|
2020-09-07 17:56:10 +08:00
|
|
|
__br_multicast_send_query(br, port, NULL, NULL, &br_group, false, 0,
|
|
|
|
NULL);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
time = jiffies;
|
2014-06-08 00:26:26 +08:00
|
|
|
time += own_query->startup_sent < br->multicast_startup_query_count ?
|
2010-02-28 03:41:45 +08:00
|
|
|
br->multicast_startup_query_interval :
|
|
|
|
br->multicast_query_interval;
|
2014-06-08 00:26:26 +08:00
|
|
|
mod_timer(&own_query->timer, time);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
static void
|
|
|
|
br_multicast_port_query_expired(struct net_bridge_port *port,
|
|
|
|
struct bridge_mcast_own_query *query)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
|
|
|
struct net_bridge *br = port->br;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
2010-03-06 09:14:09 +08:00
|
|
|
if (port->state == BR_STATE_DISABLED ||
|
|
|
|
port->state == BR_STATE_BLOCKING)
|
2010-02-28 03:41:45 +08:00
|
|
|
goto out;
|
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
if (query->startup_sent < br->multicast_startup_query_count)
|
|
|
|
query->startup_sent++;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
br_multicast_send_query(port->br, port, query);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_ip4_multicast_port_query_expired(struct timer_list *t)
|
2013-08-30 23:28:17 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge_port *port = from_timer(port, t, ip4_own_query.timer);
|
2013-08-30 23:28:17 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_port_query_expired(port, &port->ip4_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_ip6_multicast_port_query_expired(struct timer_list *t)
|
2013-08-30 23:28:17 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge_port *port = from_timer(port, t, ip6_own_query.timer);
|
2013-08-30 23:28:17 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_port_query_expired(port, &port->ip6_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-09-07 17:56:10 +08:00
|
|
|
static void br_multicast_port_group_rexmit(struct timer_list *t)
|
|
|
|
{
|
|
|
|
struct net_bridge_port_group *pg = from_timer(pg, t, rexmit_timer);
|
|
|
|
struct bridge_mcast_other_query *other_query = NULL;
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:10 +08:00
|
|
|
bool need_rexmit = false;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
if (!netif_running(br->dev) || hlist_unhashed(&pg->mglist) ||
|
|
|
|
!br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
|
|
|
|
!br_opt_get(br, BROPT_MULTICAST_QUERIER))
|
|
|
|
goto out;
|
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
if (pg->key.addr.proto == htons(ETH_P_IP))
|
2020-09-07 17:56:10 +08:00
|
|
|
other_query = &br->ip4_other_query;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
else
|
|
|
|
other_query = &br->ip6_other_query;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (!other_query || timer_pending(&other_query->timer))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (pg->grp_query_rexmit_cnt) {
|
|
|
|
pg->grp_query_rexmit_cnt--;
|
2020-09-22 15:30:22 +08:00
|
|
|
__br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
|
|
|
|
&pg->key.addr, false, 1, NULL);
|
2020-09-07 17:56:10 +08:00
|
|
|
}
|
2020-09-22 15:30:22 +08:00
|
|
|
__br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
|
|
|
|
&pg->key.addr, true, 0, &need_rexmit);
|
2020-09-07 17:56:10 +08:00
|
|
|
|
|
|
|
if (pg->grp_query_rexmit_cnt || need_rexmit)
|
|
|
|
mod_timer(&pg->rexmit_timer, jiffies +
|
|
|
|
br->multicast_last_member_interval);
|
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2017-02-09 21:54:40 +08:00
|
|
|
static void br_mc_disabled_update(struct net_device *dev, bool value)
|
|
|
|
{
|
|
|
|
struct switchdev_attr attr = {
|
|
|
|
.orig_dev = dev,
|
|
|
|
.id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED,
|
|
|
|
.flags = SWITCHDEV_F_DEFER,
|
2018-09-26 22:01:03 +08:00
|
|
|
.u.mc_disabled = !value,
|
2017-02-09 21:54:40 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
switchdev_port_attr_set(dev, &attr);
|
|
|
|
}
|
|
|
|
|
2016-06-28 22:57:06 +08:00
|
|
|
int br_multicast_add_port(struct net_bridge_port *port)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2016-02-27 04:20:01 +08:00
|
|
|
port->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2017-11-03 14:21:10 +08:00
|
|
|
timer_setup(&port->multicast_router_timer,
|
|
|
|
br_multicast_router_expired, 0);
|
|
|
|
timer_setup(&port->ip4_own_query.timer,
|
|
|
|
br_ip4_multicast_port_query_expired, 0);
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2017-11-03 14:21:10 +08:00
|
|
|
timer_setup(&port->ip6_own_query.timer,
|
|
|
|
br_ip6_multicast_port_query_expired, 0);
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2018-09-26 22:01:03 +08:00
|
|
|
br_mc_disabled_update(port->dev,
|
|
|
|
br_opt_get(port->br, BROPT_MULTICAST_ENABLED));
|
2017-02-09 21:54:40 +08:00
|
|
|
|
2016-06-28 22:57:06 +08:00
|
|
|
port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
|
|
|
|
if (!port->mcast_stats)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_del_port(struct net_bridge_port *port)
|
|
|
|
{
|
2015-07-15 22:16:51 +08:00
|
|
|
struct net_bridge *br = port->br;
|
|
|
|
struct net_bridge_port_group *pg;
|
2020-09-07 17:56:19 +08:00
|
|
|
HLIST_HEAD(deleted_head);
|
2015-07-15 22:16:51 +08:00
|
|
|
struct hlist_node *n;
|
|
|
|
|
|
|
|
/* Take care of the remaining groups, only perm ones should be left */
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
|
|
|
hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
|
2020-09-07 17:56:06 +08:00
|
|
|
br_multicast_find_del_pg(br, pg);
|
2020-09-07 17:56:19 +08:00
|
|
|
hlist_move_list(&br->mcast_gc_list, &deleted_head);
|
2015-07-15 22:16:51 +08:00
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
2020-09-07 17:56:19 +08:00
|
|
|
br_multicast_gc(&deleted_head);
|
2010-02-28 03:41:45 +08:00
|
|
|
del_timer_sync(&port->multicast_router_timer);
|
2016-06-28 22:57:06 +08:00
|
|
|
free_percpu(port->mcast_stats);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
static void br_multicast_enable(struct bridge_mcast_own_query *query)
|
2010-02-28 03:41:50 +08:00
|
|
|
{
|
2013-08-30 23:28:17 +08:00
|
|
|
query->startup_sent = 0;
|
2010-02-28 03:41:50 +08:00
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
if (try_to_del_timer_sync(&query->timer) >= 0 ||
|
|
|
|
del_timer(&query->timer))
|
|
|
|
mod_timer(&query->timer, jiffies);
|
2010-02-28 03:41:50 +08:00
|
|
|
}
|
|
|
|
|
2016-10-19 00:09:48 +08:00
|
|
|
static void __br_multicast_enable_port(struct net_bridge_port *port)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
|
|
|
struct net_bridge *br = port->br;
|
|
|
|
|
2018-09-26 22:01:03 +08:00
|
|
|
if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || !netif_running(br->dev))
|
2016-10-19 00:09:48 +08:00
|
|
|
return;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_enable(&port->ip4_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_enable(&port->ip6_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2016-02-27 04:20:01 +08:00
|
|
|
if (port->multicast_router == MDB_RTR_TYPE_PERM &&
|
|
|
|
hlist_unhashed(&port->rlist))
|
2015-06-19 16:22:57 +08:00
|
|
|
br_multicast_add_router(br, port);
|
2016-10-19 00:09:48 +08:00
|
|
|
}
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2016-10-19 00:09:48 +08:00
|
|
|
void br_multicast_enable_port(struct net_bridge_port *port)
|
|
|
|
{
|
|
|
|
struct net_bridge *br = port->br;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
__br_multicast_enable_port(port);
|
2010-02-28 03:41:45 +08:00
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_disable_port(struct net_bridge_port *port)
|
|
|
|
{
|
|
|
|
struct net_bridge *br = port->br;
|
|
|
|
struct net_bridge_port_group *pg;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 09:06:00 +08:00
|
|
|
struct hlist_node *n;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 09:06:00 +08:00
|
|
|
hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
|
2016-02-03 16:57:05 +08:00
|
|
|
if (!(pg->flags & MDB_PG_FLAGS_PERMANENT))
|
2020-09-07 17:56:06 +08:00
|
|
|
br_multicast_find_del_pg(br, pg);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2017-02-09 21:54:41 +08:00
|
|
|
__del_port_router(port);
|
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
del_timer(&port->multicast_router_timer);
|
2014-06-08 00:26:26 +08:00
|
|
|
del_timer(&port->ip4_own_query.timer);
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2014-06-08 00:26:26 +08:00
|
|
|
del_timer(&port->ip6_own_query.timer);
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2010-02-28 03:41:45 +08:00
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:15 +08:00
|
|
|
static int __grp_src_delete_marked(struct net_bridge_port_group *pg)
|
|
|
|
{
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
struct hlist_node *tmp;
|
|
|
|
int deleted = 0;
|
|
|
|
|
|
|
|
hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
|
|
|
|
if (ent->flags & BR_SGRP_F_DELETE) {
|
|
|
|
br_multicast_del_group_src(ent);
|
|
|
|
deleted++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return deleted;
|
|
|
|
}
|
|
|
|
|
2020-09-22 15:30:23 +08:00
|
|
|
static void __grp_src_mod_timer(struct net_bridge_group_src *src,
|
|
|
|
unsigned long expires)
|
|
|
|
{
|
|
|
|
mod_timer(&src->timer, expires);
|
|
|
|
br_multicast_fwd_src_handle(src);
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:16 +08:00
|
|
|
static void __grp_src_query_marked_and_rexmit(struct net_bridge_port_group *pg)
|
|
|
|
{
|
|
|
|
struct bridge_mcast_other_query *other_query = NULL;
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:16 +08:00
|
|
|
u32 lmqc = br->multicast_last_member_count;
|
|
|
|
unsigned long lmqt, lmi, now = jiffies;
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
|
|
|
|
if (!netif_running(br->dev) ||
|
|
|
|
!br_opt_get(br, BROPT_MULTICAST_ENABLED))
|
|
|
|
return;
|
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
if (pg->key.addr.proto == htons(ETH_P_IP))
|
2020-09-07 17:56:16 +08:00
|
|
|
other_query = &br->ip4_other_query;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
else
|
|
|
|
other_query = &br->ip6_other_query;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
lmqt = now + br_multicast_lmqt(br);
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node) {
|
|
|
|
if (ent->flags & BR_SGRP_F_SEND) {
|
|
|
|
ent->flags &= ~BR_SGRP_F_SEND;
|
|
|
|
if (ent->timer.expires > lmqt) {
|
|
|
|
if (br_opt_get(br, BROPT_MULTICAST_QUERIER) &&
|
|
|
|
other_query &&
|
|
|
|
!timer_pending(&other_query->timer))
|
|
|
|
ent->src_query_rexmit_cnt = lmqc;
|
2020-09-22 15:30:23 +08:00
|
|
|
__grp_src_mod_timer(ent, lmqt);
|
2020-09-07 17:56:16 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!br_opt_get(br, BROPT_MULTICAST_QUERIER) ||
|
|
|
|
!other_query || timer_pending(&other_query->timer))
|
|
|
|
return;
|
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
__br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
|
|
|
|
&pg->key.addr, true, 1, NULL);
|
2020-09-07 17:56:16 +08:00
|
|
|
|
|
|
|
lmi = now + br->multicast_last_member_interval;
|
|
|
|
if (!timer_pending(&pg->rexmit_timer) ||
|
|
|
|
time_after(pg->rexmit_timer.expires, lmi))
|
|
|
|
mod_timer(&pg->rexmit_timer, lmi);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __grp_send_query_and_rexmit(struct net_bridge_port_group *pg)
|
|
|
|
{
|
|
|
|
struct bridge_mcast_other_query *other_query = NULL;
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:16 +08:00
|
|
|
unsigned long now = jiffies, lmi;
|
|
|
|
|
|
|
|
if (!netif_running(br->dev) ||
|
|
|
|
!br_opt_get(br, BROPT_MULTICAST_ENABLED))
|
|
|
|
return;
|
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
if (pg->key.addr.proto == htons(ETH_P_IP))
|
2020-09-07 17:56:16 +08:00
|
|
|
other_query = &br->ip4_other_query;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
else
|
|
|
|
other_query = &br->ip6_other_query;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (br_opt_get(br, BROPT_MULTICAST_QUERIER) &&
|
|
|
|
other_query && !timer_pending(&other_query->timer)) {
|
|
|
|
lmi = now + br->multicast_last_member_interval;
|
|
|
|
pg->grp_query_rexmit_cnt = br->multicast_last_member_count - 1;
|
2020-09-22 15:30:22 +08:00
|
|
|
__br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
|
|
|
|
&pg->key.addr, false, 0, NULL);
|
2020-09-07 17:56:16 +08:00
|
|
|
if (!timer_pending(&pg->rexmit_timer) ||
|
|
|
|
time_after(pg->rexmit_timer.expires, lmi))
|
|
|
|
mod_timer(&pg->rexmit_timer, lmi);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pg->filter_mode == MCAST_EXCLUDE &&
|
|
|
|
(!timer_pending(&pg->timer) ||
|
|
|
|
time_after(pg->timer.expires, now + br_multicast_lmqt(br))))
|
|
|
|
mod_timer(&pg->timer, now + br_multicast_lmqt(br));
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:14 +08:00
|
|
|
/* State Msg type New state Actions
|
|
|
|
* INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI
|
|
|
|
* INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI
|
|
|
|
* EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI
|
|
|
|
*/
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool br_multicast_isinc_allow(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:58 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:14 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:14 +08:00
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
unsigned long now = jiffies;
|
|
|
|
bool changed = false;
|
|
|
|
struct br_ip src_ip;
|
|
|
|
u32 src_idx;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:14 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:14 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (!ent) {
|
|
|
|
ent = br_multicast_new_group_src(pg, &src_ip);
|
|
|
|
if (ent)
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ent)
|
2020-09-22 15:30:23 +08:00
|
|
|
__grp_src_mod_timer(ent, now + br_multicast_gmi(br));
|
2020-09-07 17:56:14 +08:00
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:58 +08:00
|
|
|
if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
|
|
|
|
changed = true;
|
|
|
|
|
2020-09-07 17:56:14 +08:00
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:15 +08:00
|
|
|
/* State Msg type New state Actions
|
|
|
|
* INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
|
|
|
|
* Delete (A-B)
|
|
|
|
* Group Timer=GMI
|
|
|
|
*/
|
2021-01-20 22:51:51 +08:00
|
|
|
static void __grp_src_isexc_incl(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:15 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
struct br_ip src_ip;
|
|
|
|
u32 src_idx;
|
|
|
|
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
|
|
|
ent->flags |= BR_SGRP_F_DELETE;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:15 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:15 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (ent)
|
|
|
|
ent->flags &= ~BR_SGRP_F_DELETE;
|
|
|
|
else
|
2020-09-22 15:30:23 +08:00
|
|
|
ent = br_multicast_new_group_src(pg, &src_ip);
|
|
|
|
if (ent)
|
|
|
|
br_multicast_fwd_src_handle(ent);
|
2020-09-07 17:56:15 +08:00
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:59 +08:00
|
|
|
br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type);
|
|
|
|
|
2020-09-07 17:56:15 +08:00
|
|
|
__grp_src_delete_marked(pg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* State Msg type New state Actions
|
|
|
|
* EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI
|
|
|
|
* Delete (X-A)
|
|
|
|
* Delete (Y-A)
|
|
|
|
* Group Timer=GMI
|
|
|
|
*/
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool __grp_src_isexc_excl(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:15 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:15 +08:00
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
unsigned long now = jiffies;
|
|
|
|
bool changed = false;
|
|
|
|
struct br_ip src_ip;
|
|
|
|
u32 src_idx;
|
|
|
|
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
|
|
|
ent->flags |= BR_SGRP_F_DELETE;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:15 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:15 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
|
|
|
ent->flags &= ~BR_SGRP_F_DELETE;
|
|
|
|
} else {
|
|
|
|
ent = br_multicast_new_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
2020-09-22 15:30:23 +08:00
|
|
|
__grp_src_mod_timer(ent,
|
|
|
|
now + br_multicast_gmi(br));
|
2020-09-07 17:56:15 +08:00
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:59 +08:00
|
|
|
if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
|
|
|
|
changed = true;
|
|
|
|
|
2020-09-07 17:56:15 +08:00
|
|
|
if (__grp_src_delete_marked(pg))
|
|
|
|
changed = true;
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool br_multicast_isexc(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:15 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:15 +08:00
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
switch (pg->filter_mode) {
|
|
|
|
case MCAST_INCLUDE:
|
2021-01-20 22:51:59 +08:00
|
|
|
__grp_src_isexc_incl(pg, h_addr, srcs, nsrcs, addr_size,
|
|
|
|
grec_type);
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE);
|
2020-09-07 17:56:15 +08:00
|
|
|
changed = true;
|
|
|
|
break;
|
|
|
|
case MCAST_EXCLUDE:
|
2021-01-20 22:51:59 +08:00
|
|
|
changed = __grp_src_isexc_excl(pg, h_addr, srcs, nsrcs, addr_size,
|
|
|
|
grec_type);
|
2020-09-07 17:56:15 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
pg->filter_mode = MCAST_EXCLUDE;
|
|
|
|
mod_timer(&pg->timer, jiffies + br_multicast_gmi(br));
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:16 +08:00
|
|
|
/* State Msg type New state Actions
|
|
|
|
* INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI
|
|
|
|
* Send Q(G,A-B)
|
|
|
|
*/
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool __grp_src_toin_incl(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:16 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:16 +08:00
|
|
|
u32 src_idx, to_send = pg->src_ents;
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
unsigned long now = jiffies;
|
|
|
|
bool changed = false;
|
|
|
|
struct br_ip src_ip;
|
|
|
|
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
|
|
|
ent->flags |= BR_SGRP_F_SEND;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:16 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:16 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
|
|
|
ent->flags &= ~BR_SGRP_F_SEND;
|
|
|
|
to_send--;
|
|
|
|
} else {
|
|
|
|
ent = br_multicast_new_group_src(pg, &src_ip);
|
|
|
|
if (ent)
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
if (ent)
|
2020-09-22 15:30:23 +08:00
|
|
|
__grp_src_mod_timer(ent, now + br_multicast_gmi(br));
|
2020-09-07 17:56:16 +08:00
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:59 +08:00
|
|
|
if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
|
|
|
|
changed = true;
|
|
|
|
|
2020-09-07 17:56:16 +08:00
|
|
|
if (to_send)
|
|
|
|
__grp_src_query_marked_and_rexmit(pg);
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* State Msg type New state Actions
|
|
|
|
* EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI
|
|
|
|
* Send Q(G,X-A)
|
|
|
|
* Send Q(G)
|
|
|
|
*/
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool __grp_src_toin_excl(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:16 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:16 +08:00
|
|
|
u32 src_idx, to_send = pg->src_ents;
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
unsigned long now = jiffies;
|
|
|
|
bool changed = false;
|
|
|
|
struct br_ip src_ip;
|
|
|
|
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
|
|
|
if (timer_pending(&ent->timer))
|
|
|
|
ent->flags |= BR_SGRP_F_SEND;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:16 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:16 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
|
|
|
if (timer_pending(&ent->timer)) {
|
|
|
|
ent->flags &= ~BR_SGRP_F_SEND;
|
|
|
|
to_send--;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ent = br_multicast_new_group_src(pg, &src_ip);
|
|
|
|
if (ent)
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
if (ent)
|
2020-09-22 15:30:23 +08:00
|
|
|
__grp_src_mod_timer(ent, now + br_multicast_gmi(br));
|
2020-09-07 17:56:16 +08:00
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:59 +08:00
|
|
|
if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
|
|
|
|
changed = true;
|
|
|
|
|
2020-09-07 17:56:16 +08:00
|
|
|
if (to_send)
|
|
|
|
__grp_src_query_marked_and_rexmit(pg);
|
|
|
|
|
|
|
|
__grp_send_query_and_rexmit(pg);
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool br_multicast_toin(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:16 +08:00
|
|
|
{
|
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
switch (pg->filter_mode) {
|
|
|
|
case MCAST_INCLUDE:
|
2021-01-20 22:51:59 +08:00
|
|
|
changed = __grp_src_toin_incl(pg, h_addr, srcs, nsrcs, addr_size,
|
|
|
|
grec_type);
|
2020-09-07 17:56:16 +08:00
|
|
|
break;
|
|
|
|
case MCAST_EXCLUDE:
|
2021-01-20 22:51:59 +08:00
|
|
|
changed = __grp_src_toin_excl(pg, h_addr, srcs, nsrcs, addr_size,
|
|
|
|
grec_type);
|
2020-09-07 17:56:16 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:59 +08:00
|
|
|
if (br_multicast_eht_should_del_pg(pg)) {
|
|
|
|
br_multicast_find_del_pg(pg->key.port->br, pg);
|
|
|
|
/* a notification has already been sent and we shouldn't
|
|
|
|
* access pg after the delete so we have to return false
|
|
|
|
*/
|
|
|
|
changed = false;
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:16 +08:00
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* State Msg type New state Actions
|
|
|
|
* INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
|
|
|
|
* Delete (A-B)
|
|
|
|
* Send Q(G,A*B)
|
|
|
|
* Group Timer=GMI
|
|
|
|
*/
|
2021-01-20 22:51:51 +08:00
|
|
|
static void __grp_src_toex_incl(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:16 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
u32 src_idx, to_send = 0;
|
|
|
|
struct br_ip src_ip;
|
|
|
|
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
|
|
|
ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:16 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:16 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
|
|
|
ent->flags = (ent->flags & ~BR_SGRP_F_DELETE) |
|
|
|
|
BR_SGRP_F_SEND;
|
|
|
|
to_send++;
|
|
|
|
} else {
|
2020-09-22 15:30:23 +08:00
|
|
|
ent = br_multicast_new_group_src(pg, &src_ip);
|
2020-09-07 17:56:16 +08:00
|
|
|
}
|
2020-09-22 15:30:23 +08:00
|
|
|
if (ent)
|
|
|
|
br_multicast_fwd_src_handle(ent);
|
2020-09-07 17:56:16 +08:00
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:59 +08:00
|
|
|
br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type);
|
|
|
|
|
2020-09-07 17:56:16 +08:00
|
|
|
__grp_src_delete_marked(pg);
|
|
|
|
if (to_send)
|
|
|
|
__grp_src_query_marked_and_rexmit(pg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* State Msg type New state Actions
|
|
|
|
* EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer
|
|
|
|
* Delete (X-A)
|
|
|
|
* Delete (Y-A)
|
|
|
|
* Send Q(G,A-Y)
|
|
|
|
* Group Timer=GMI
|
|
|
|
*/
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool __grp_src_toex_excl(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:16 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
u32 src_idx, to_send = 0;
|
|
|
|
bool changed = false;
|
|
|
|
struct br_ip src_ip;
|
|
|
|
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
|
|
|
ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:16 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:16 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
|
|
|
ent->flags &= ~BR_SGRP_F_DELETE;
|
|
|
|
} else {
|
|
|
|
ent = br_multicast_new_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
2020-09-22 15:30:23 +08:00
|
|
|
__grp_src_mod_timer(ent, pg->timer.expires);
|
2020-09-07 17:56:16 +08:00
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ent && timer_pending(&ent->timer)) {
|
|
|
|
ent->flags |= BR_SGRP_F_SEND;
|
|
|
|
to_send++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:59 +08:00
|
|
|
if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
|
|
|
|
changed = true;
|
|
|
|
|
2020-09-07 17:56:16 +08:00
|
|
|
if (__grp_src_delete_marked(pg))
|
|
|
|
changed = true;
|
|
|
|
if (to_send)
|
|
|
|
__grp_src_query_marked_and_rexmit(pg);
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool br_multicast_toex(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:59 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size,
|
|
|
|
int grec_type)
|
2020-09-07 17:56:16 +08:00
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
struct net_bridge *br = pg->key.port->br;
|
2020-09-07 17:56:16 +08:00
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
switch (pg->filter_mode) {
|
|
|
|
case MCAST_INCLUDE:
|
2021-01-20 22:51:59 +08:00
|
|
|
__grp_src_toex_incl(pg, h_addr, srcs, nsrcs, addr_size,
|
|
|
|
grec_type);
|
net: bridge: mcast: handle port group filter modes
We need to handle group filter mode transitions and initial state.
To change a port group's INCLUDE -> EXCLUDE mode (or when we have added
a new port group in EXCLUDE mode) we need to add that port to all of
*,G ports' S,G entries for proper replication. When the EXCLUDE state is
changed from IGMPv3 report, br_multicast_fwd_filter_exclude() must be
called after the source list processing because the assumption is that
all of the group's S,G entries will be created before transitioning to
EXCLUDE mode, i.e. most importantly its blocked entries will already be
added so it will not get automatically added to them.
The transition EXCLUDE -> INCLUDE happens only when a port group timer
expires, it requires us to remove that port from all of *,G ports' S,G
entries where it was automatically added previously.
Finally when we are adding a new S,G entry we must add all of *,G's
EXCLUDE ports to it.
In order to distinguish automatically added *,G EXCLUDE ports we have a
new port group flag - MDB_PG_FLAGS_STAR_EXCL.
Signed-off-by: Nikolay Aleksandrov <nikolay@nvidia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-09-22 15:30:24 +08:00
|
|
|
br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE);
|
2020-09-07 17:56:16 +08:00
|
|
|
changed = true;
|
|
|
|
break;
|
|
|
|
case MCAST_EXCLUDE:
|
2021-01-20 22:51:59 +08:00
|
|
|
changed = __grp_src_toex_excl(pg, h_addr, srcs, nsrcs, addr_size,
|
|
|
|
grec_type);
|
2020-09-07 17:56:16 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
pg->filter_mode = MCAST_EXCLUDE;
|
|
|
|
mod_timer(&pg->timer, jiffies + br_multicast_gmi(br));
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:17 +08:00
|
|
|
/* State Msg type New state Actions
|
|
|
|
* INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B)
|
|
|
|
*/
|
2021-01-20 22:51:52 +08:00
|
|
|
static bool __grp_src_block_incl(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:58 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
|
2020-09-07 17:56:17 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
u32 src_idx, to_send = 0;
|
2021-01-20 22:51:52 +08:00
|
|
|
bool changed = false;
|
2020-09-07 17:56:17 +08:00
|
|
|
struct br_ip src_ip;
|
|
|
|
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
|
|
|
ent->flags &= ~BR_SGRP_F_SEND;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:17 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:17 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
|
|
|
ent->flags |= BR_SGRP_F_SEND;
|
|
|
|
to_send++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:58 +08:00
|
|
|
if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
|
|
|
|
changed = true;
|
|
|
|
|
2020-09-07 17:56:17 +08:00
|
|
|
if (to_send)
|
|
|
|
__grp_src_query_marked_and_rexmit(pg);
|
|
|
|
|
2021-01-20 22:51:52 +08:00
|
|
|
if (pg->filter_mode == MCAST_INCLUDE && hlist_empty(&pg->src_list)) {
|
2020-09-22 15:30:22 +08:00
|
|
|
br_multicast_find_del_pg(pg->key.port->br, pg);
|
2021-01-20 22:51:52 +08:00
|
|
|
/* a notification has already been sent and we shouldn't access
|
|
|
|
* pg after the delete thus we have to return false
|
|
|
|
*/
|
|
|
|
changed = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return changed;
|
2020-09-07 17:56:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* State Msg type New state Actions
|
|
|
|
* EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer
|
|
|
|
* Send Q(G,A-Y)
|
|
|
|
*/
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool __grp_src_block_excl(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:58 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
|
2020-09-07 17:56:17 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_group_src *ent;
|
|
|
|
u32 src_idx, to_send = 0;
|
|
|
|
bool changed = false;
|
|
|
|
struct br_ip src_ip;
|
|
|
|
|
|
|
|
hlist_for_each_entry(ent, &pg->src_list, node)
|
|
|
|
ent->flags &= ~BR_SGRP_F_SEND;
|
|
|
|
|
|
|
|
memset(&src_ip, 0, sizeof(src_ip));
|
2020-09-22 15:30:22 +08:00
|
|
|
src_ip.proto = pg->key.addr.proto;
|
2020-09-07 17:56:17 +08:00
|
|
|
for (src_idx = 0; src_idx < nsrcs; src_idx++) {
|
2021-01-20 22:51:53 +08:00
|
|
|
memcpy(&src_ip.src, srcs + (src_idx * addr_size), addr_size);
|
2020-09-07 17:56:17 +08:00
|
|
|
ent = br_multicast_find_group_src(pg, &src_ip);
|
|
|
|
if (!ent) {
|
|
|
|
ent = br_multicast_new_group_src(pg, &src_ip);
|
|
|
|
if (ent) {
|
2020-09-22 15:30:23 +08:00
|
|
|
__grp_src_mod_timer(ent, pg->timer.expires);
|
2020-09-07 17:56:17 +08:00
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ent && timer_pending(&ent->timer)) {
|
|
|
|
ent->flags |= BR_SGRP_F_SEND;
|
|
|
|
to_send++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:58 +08:00
|
|
|
if (br_multicast_eht_handle(pg, h_addr, srcs, nsrcs, addr_size, grec_type))
|
|
|
|
changed = true;
|
|
|
|
|
2020-09-07 17:56:17 +08:00
|
|
|
if (to_send)
|
|
|
|
__grp_src_query_marked_and_rexmit(pg);
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2021-01-20 22:51:51 +08:00
|
|
|
static bool br_multicast_block(struct net_bridge_port_group *pg, void *h_addr,
|
2021-01-20 22:51:58 +08:00
|
|
|
void *srcs, u32 nsrcs, size_t addr_size, int grec_type)
|
2020-09-07 17:56:17 +08:00
|
|
|
{
|
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
switch (pg->filter_mode) {
|
|
|
|
case MCAST_INCLUDE:
|
2021-01-20 22:51:58 +08:00
|
|
|
changed = __grp_src_block_incl(pg, h_addr, srcs, nsrcs, addr_size,
|
|
|
|
grec_type);
|
2020-09-07 17:56:17 +08:00
|
|
|
break;
|
|
|
|
case MCAST_EXCLUDE:
|
2021-01-20 22:51:58 +08:00
|
|
|
changed = __grp_src_block_excl(pg, h_addr, srcs, nsrcs, addr_size,
|
|
|
|
grec_type);
|
2020-09-07 17:56:17 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2020-09-07 17:56:14 +08:00
|
|
|
static struct net_bridge_port_group *
|
|
|
|
br_multicast_find_port(struct net_bridge_mdb_entry *mp,
|
|
|
|
struct net_bridge_port *p,
|
|
|
|
const unsigned char *src)
|
|
|
|
{
|
2020-09-08 15:17:13 +08:00
|
|
|
struct net_bridge *br __maybe_unused = mp->br;
|
2020-09-07 17:56:14 +08:00
|
|
|
struct net_bridge_port_group *pg;
|
|
|
|
|
|
|
|
for (pg = mlock_dereference(mp->ports, br);
|
|
|
|
pg;
|
|
|
|
pg = mlock_dereference(pg->next, br))
|
|
|
|
if (br_port_group_equal(pg, p, src))
|
|
|
|
return pg;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-04-18 11:42:07 +08:00
|
|
|
static int br_ip4_multicast_igmp3_report(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-10-29 03:45:07 +08:00
|
|
|
struct sk_buff *skb,
|
|
|
|
u16 vid)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2020-09-07 17:56:14 +08:00
|
|
|
bool igmpv2 = br->multicast_igmp_version == 2;
|
|
|
|
struct net_bridge_mdb_entry *mdst;
|
|
|
|
struct net_bridge_port_group *pg;
|
2017-01-22 04:01:32 +08:00
|
|
|
const unsigned char *src;
|
2010-02-28 03:41:45 +08:00
|
|
|
struct igmpv3_report *ih;
|
|
|
|
struct igmpv3_grec *grec;
|
2020-09-07 17:56:14 +08:00
|
|
|
int i, len, num, type;
|
2021-01-20 22:51:51 +08:00
|
|
|
__be32 group, *h_addr;
|
2020-09-07 17:56:14 +08:00
|
|
|
bool changed = false;
|
|
|
|
int err = 0;
|
2019-07-02 20:00:18 +08:00
|
|
|
u16 nsrcs;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
ih = igmpv3_report_hdr(skb);
|
|
|
|
num = ntohs(ih->ngrec);
|
2015-09-12 00:39:48 +08:00
|
|
|
len = skb_transport_offset(skb) + sizeof(*ih);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
len += sizeof(*grec);
|
2019-01-21 14:26:25 +08:00
|
|
|
if (!ip_mc_may_pull(skb, len))
|
2010-02-28 03:41:45 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-04-08 12:20:47 +08:00
|
|
|
grec = (void *)(skb->data + len - sizeof(*grec));
|
2010-02-28 03:41:45 +08:00
|
|
|
group = grec->grec_mca;
|
|
|
|
type = grec->grec_type;
|
2019-07-02 20:00:18 +08:00
|
|
|
nsrcs = ntohs(grec->grec_nsrcs);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2019-07-02 20:00:18 +08:00
|
|
|
len += nsrcs * 4;
|
2019-01-21 14:26:25 +08:00
|
|
|
if (!ip_mc_may_pull(skb, len))
|
2010-02-28 03:41:45 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case IGMPV3_MODE_IS_INCLUDE:
|
|
|
|
case IGMPV3_MODE_IS_EXCLUDE:
|
|
|
|
case IGMPV3_CHANGE_TO_INCLUDE:
|
|
|
|
case IGMPV3_CHANGE_TO_EXCLUDE:
|
|
|
|
case IGMPV3_ALLOW_NEW_SOURCES:
|
|
|
|
case IGMPV3_BLOCK_OLD_SOURCES:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-01-22 04:01:32 +08:00
|
|
|
src = eth_hdr(skb)->h_source;
|
2020-09-07 17:56:14 +08:00
|
|
|
if (nsrcs == 0 &&
|
|
|
|
(type == IGMPV3_CHANGE_TO_INCLUDE ||
|
|
|
|
type == IGMPV3_MODE_IS_INCLUDE)) {
|
|
|
|
if (!port || igmpv2) {
|
|
|
|
br_ip4_multicast_leave_group(br, port, group, vid, src);
|
|
|
|
continue;
|
|
|
|
}
|
2015-07-13 20:28:37 +08:00
|
|
|
} else {
|
2017-01-22 04:01:32 +08:00
|
|
|
err = br_ip4_multicast_add_group(br, port, group, vid,
|
2020-09-07 17:56:14 +08:00
|
|
|
src, igmpv2);
|
2015-07-13 20:28:37 +08:00
|
|
|
if (err)
|
|
|
|
break;
|
|
|
|
}
|
2020-09-07 17:56:14 +08:00
|
|
|
|
|
|
|
if (!port || igmpv2)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
|
|
|
mdst = br_mdb_ip4_get(br, group, vid);
|
|
|
|
if (!mdst)
|
|
|
|
goto unlock_continue;
|
|
|
|
pg = br_multicast_find_port(mdst, port, src);
|
|
|
|
if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
|
|
|
|
goto unlock_continue;
|
2021-01-20 22:51:51 +08:00
|
|
|
/* reload grec and host addr */
|
2020-09-07 17:56:14 +08:00
|
|
|
grec = (void *)(skb->data + len - sizeof(*grec) - (nsrcs * 4));
|
2021-01-20 22:51:51 +08:00
|
|
|
h_addr = &ip_hdr(skb)->saddr;
|
2020-09-07 17:56:14 +08:00
|
|
|
switch (type) {
|
|
|
|
case IGMPV3_ALLOW_NEW_SOURCES:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_isinc_allow(pg, h_addr, grec->grec_src,
|
2021-01-20 22:51:58 +08:00
|
|
|
nsrcs, sizeof(__be32), type);
|
2020-09-07 17:56:14 +08:00
|
|
|
break;
|
2020-09-07 17:56:15 +08:00
|
|
|
case IGMPV3_MODE_IS_INCLUDE:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_isinc_allow(pg, h_addr, grec->grec_src,
|
2021-01-20 22:51:58 +08:00
|
|
|
nsrcs, sizeof(__be32), type);
|
2020-09-07 17:56:15 +08:00
|
|
|
break;
|
|
|
|
case IGMPV3_MODE_IS_EXCLUDE:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_isexc(pg, h_addr, grec->grec_src,
|
2021-01-20 22:51:59 +08:00
|
|
|
nsrcs, sizeof(__be32), type);
|
2020-09-07 17:56:15 +08:00
|
|
|
break;
|
2020-09-07 17:56:16 +08:00
|
|
|
case IGMPV3_CHANGE_TO_INCLUDE:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_toin(pg, h_addr, grec->grec_src,
|
2021-01-20 22:51:59 +08:00
|
|
|
nsrcs, sizeof(__be32), type);
|
2020-09-07 17:56:16 +08:00
|
|
|
break;
|
|
|
|
case IGMPV3_CHANGE_TO_EXCLUDE:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_toex(pg, h_addr, grec->grec_src,
|
2021-01-20 22:51:59 +08:00
|
|
|
nsrcs, sizeof(__be32), type);
|
2020-09-07 17:56:16 +08:00
|
|
|
break;
|
2020-09-07 17:56:17 +08:00
|
|
|
case IGMPV3_BLOCK_OLD_SOURCES:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_block(pg, h_addr, grec->grec_src,
|
2021-01-20 22:51:58 +08:00
|
|
|
nsrcs, sizeof(__be32), type);
|
2020-09-07 17:56:17 +08:00
|
|
|
break;
|
2020-09-07 17:56:14 +08:00
|
|
|
}
|
|
|
|
if (changed)
|
|
|
|
br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB);
|
|
|
|
unlock_continue:
|
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2010-04-23 00:54:22 +08:00
|
|
|
static int br_ip6_multicast_mld2_report(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-10-29 03:45:07 +08:00
|
|
|
struct sk_buff *skb,
|
|
|
|
u16 vid)
|
2010-04-23 00:54:22 +08:00
|
|
|
{
|
2020-09-07 17:56:14 +08:00
|
|
|
bool mldv1 = br->multicast_mld_version == 1;
|
|
|
|
struct net_bridge_mdb_entry *mdst;
|
|
|
|
struct net_bridge_port_group *pg;
|
2019-01-21 14:26:25 +08:00
|
|
|
unsigned int nsrcs_offset;
|
2017-01-22 04:01:32 +08:00
|
|
|
const unsigned char *src;
|
2010-04-23 00:54:22 +08:00
|
|
|
struct icmp6hdr *icmp6h;
|
2021-01-20 22:51:51 +08:00
|
|
|
struct in6_addr *h_addr;
|
2010-04-23 00:54:22 +08:00
|
|
|
struct mld2_grec *grec;
|
2019-01-21 14:26:25 +08:00
|
|
|
unsigned int grec_len;
|
2020-09-07 17:56:14 +08:00
|
|
|
bool changed = false;
|
|
|
|
int i, len, num;
|
2010-04-23 00:54:22 +08:00
|
|
|
int err = 0;
|
|
|
|
|
2019-01-21 14:26:25 +08:00
|
|
|
if (!ipv6_mc_may_pull(skb, sizeof(*icmp6h)))
|
2010-04-23 00:54:22 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
icmp6h = icmp6_hdr(skb);
|
|
|
|
num = ntohs(icmp6h->icmp6_dataun.un_data16[1]);
|
2015-09-12 00:39:48 +08:00
|
|
|
len = skb_transport_offset(skb) + sizeof(*icmp6h);
|
2010-04-23 00:54:22 +08:00
|
|
|
|
|
|
|
for (i = 0; i < num; i++) {
|
2019-07-02 20:00:18 +08:00
|
|
|
__be16 *_nsrcs, __nsrcs;
|
|
|
|
u16 nsrcs;
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2019-01-21 14:26:25 +08:00
|
|
|
nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs);
|
|
|
|
|
|
|
|
if (skb_transport_offset(skb) + ipv6_transport_len(skb) <
|
2020-07-06 03:10:17 +08:00
|
|
|
nsrcs_offset + sizeof(__nsrcs))
|
2019-01-21 14:26:25 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2019-07-02 20:00:18 +08:00
|
|
|
_nsrcs = skb_header_pointer(skb, nsrcs_offset,
|
|
|
|
sizeof(__nsrcs), &__nsrcs);
|
|
|
|
if (!_nsrcs)
|
2010-04-23 00:54:22 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2019-07-02 20:00:18 +08:00
|
|
|
nsrcs = ntohs(*_nsrcs);
|
|
|
|
grec_len = struct_size(grec, grec_src, nsrcs);
|
2019-01-21 14:26:25 +08:00
|
|
|
|
|
|
|
if (!ipv6_mc_may_pull(skb, len + grec_len))
|
2010-04-23 00:54:22 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
grec = (struct mld2_grec *)(skb->data + len);
|
2019-01-21 14:26:25 +08:00
|
|
|
len += grec_len;
|
2010-04-23 00:54:22 +08:00
|
|
|
|
|
|
|
switch (grec->grec_type) {
|
|
|
|
case MLD2_MODE_IS_INCLUDE:
|
|
|
|
case MLD2_MODE_IS_EXCLUDE:
|
|
|
|
case MLD2_CHANGE_TO_INCLUDE:
|
|
|
|
case MLD2_CHANGE_TO_EXCLUDE:
|
|
|
|
case MLD2_ALLOW_NEW_SOURCES:
|
|
|
|
case MLD2_BLOCK_OLD_SOURCES:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-01-22 04:01:32 +08:00
|
|
|
src = eth_hdr(skb)->h_source;
|
2015-07-13 20:28:37 +08:00
|
|
|
if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
|
|
|
|
grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
|
2019-07-02 20:00:18 +08:00
|
|
|
nsrcs == 0) {
|
2020-09-07 17:56:14 +08:00
|
|
|
if (!port || mldv1) {
|
|
|
|
br_ip6_multicast_leave_group(br, port,
|
|
|
|
&grec->grec_mca,
|
|
|
|
vid, src);
|
|
|
|
continue;
|
|
|
|
}
|
2015-07-13 20:28:37 +08:00
|
|
|
} else {
|
|
|
|
err = br_ip6_multicast_add_group(br, port,
|
2017-01-22 04:01:32 +08:00
|
|
|
&grec->grec_mca, vid,
|
2020-09-07 17:56:14 +08:00
|
|
|
src, mldv1);
|
2016-08-31 20:16:44 +08:00
|
|
|
if (err)
|
2015-07-13 20:28:37 +08:00
|
|
|
break;
|
|
|
|
}
|
2020-09-07 17:56:14 +08:00
|
|
|
|
|
|
|
if (!port || mldv1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
|
|
|
mdst = br_mdb_ip6_get(br, &grec->grec_mca, vid);
|
|
|
|
if (!mdst)
|
|
|
|
goto unlock_continue;
|
|
|
|
pg = br_multicast_find_port(mdst, port, src);
|
|
|
|
if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
|
|
|
|
goto unlock_continue;
|
2021-01-20 22:51:51 +08:00
|
|
|
h_addr = &ipv6_hdr(skb)->saddr;
|
2020-09-07 17:56:14 +08:00
|
|
|
switch (grec->grec_type) {
|
|
|
|
case MLD2_ALLOW_NEW_SOURCES:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_isinc_allow(pg, h_addr,
|
|
|
|
grec->grec_src, nsrcs,
|
2021-01-20 22:51:58 +08:00
|
|
|
sizeof(struct in6_addr),
|
|
|
|
grec->grec_type);
|
2020-09-07 17:56:14 +08:00
|
|
|
break;
|
2020-09-07 17:56:15 +08:00
|
|
|
case MLD2_MODE_IS_INCLUDE:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_isinc_allow(pg, h_addr,
|
|
|
|
grec->grec_src, nsrcs,
|
2021-01-20 22:51:58 +08:00
|
|
|
sizeof(struct in6_addr),
|
|
|
|
grec->grec_type);
|
2020-09-07 17:56:15 +08:00
|
|
|
break;
|
|
|
|
case MLD2_MODE_IS_EXCLUDE:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_isexc(pg, h_addr,
|
|
|
|
grec->grec_src, nsrcs,
|
2021-01-20 22:51:59 +08:00
|
|
|
sizeof(struct in6_addr),
|
|
|
|
grec->grec_type);
|
2020-09-07 17:56:15 +08:00
|
|
|
break;
|
2020-09-07 17:56:16 +08:00
|
|
|
case MLD2_CHANGE_TO_INCLUDE:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_toin(pg, h_addr,
|
|
|
|
grec->grec_src, nsrcs,
|
2021-01-20 22:51:59 +08:00
|
|
|
sizeof(struct in6_addr),
|
|
|
|
grec->grec_type);
|
2020-09-07 17:56:16 +08:00
|
|
|
break;
|
|
|
|
case MLD2_CHANGE_TO_EXCLUDE:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_toex(pg, h_addr,
|
|
|
|
grec->grec_src, nsrcs,
|
2021-01-20 22:51:59 +08:00
|
|
|
sizeof(struct in6_addr),
|
|
|
|
grec->grec_type);
|
2020-09-07 17:56:16 +08:00
|
|
|
break;
|
2020-09-07 17:56:17 +08:00
|
|
|
case MLD2_BLOCK_OLD_SOURCES:
|
2021-01-20 22:51:51 +08:00
|
|
|
changed = br_multicast_block(pg, h_addr,
|
|
|
|
grec->grec_src, nsrcs,
|
2021-01-20 22:51:58 +08:00
|
|
|
sizeof(struct in6_addr),
|
|
|
|
grec->grec_type);
|
2020-09-07 17:56:17 +08:00
|
|
|
break;
|
2020-09-07 17:56:14 +08:00
|
|
|
}
|
|
|
|
if (changed)
|
|
|
|
br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB);
|
|
|
|
unlock_continue:
|
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
static bool br_ip4_multicast_select_querier(struct net_bridge *br,
|
2014-06-08 00:26:29 +08:00
|
|
|
struct net_bridge_port *port,
|
2014-06-08 00:26:27 +08:00
|
|
|
__be32 saddr)
|
|
|
|
{
|
|
|
|
if (!timer_pending(&br->ip4_own_query.timer) &&
|
|
|
|
!timer_pending(&br->ip4_other_query.timer))
|
|
|
|
goto update;
|
|
|
|
|
2020-09-22 15:30:16 +08:00
|
|
|
if (!br->ip4_querier.addr.src.ip4)
|
2014-06-08 00:26:27 +08:00
|
|
|
goto update;
|
|
|
|
|
2020-09-22 15:30:16 +08:00
|
|
|
if (ntohl(saddr) <= ntohl(br->ip4_querier.addr.src.ip4))
|
2014-06-08 00:26:27 +08:00
|
|
|
goto update;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
update:
|
2020-09-22 15:30:16 +08:00
|
|
|
br->ip4_querier.addr.src.ip4 = saddr;
|
2014-06-08 00:26:27 +08:00
|
|
|
|
2014-06-08 00:26:29 +08:00
|
|
|
/* update protected by general multicast_lock by caller */
|
|
|
|
rcu_assign_pointer(br->ip4_querier.port, port);
|
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
static bool br_ip6_multicast_select_querier(struct net_bridge *br,
|
2014-06-08 00:26:29 +08:00
|
|
|
struct net_bridge_port *port,
|
2014-06-08 00:26:27 +08:00
|
|
|
struct in6_addr *saddr)
|
|
|
|
{
|
|
|
|
if (!timer_pending(&br->ip6_own_query.timer) &&
|
|
|
|
!timer_pending(&br->ip6_other_query.timer))
|
|
|
|
goto update;
|
|
|
|
|
2020-09-22 15:30:16 +08:00
|
|
|
if (ipv6_addr_cmp(saddr, &br->ip6_querier.addr.src.ip6) <= 0)
|
2014-06-08 00:26:27 +08:00
|
|
|
goto update;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
update:
|
2020-09-22 15:30:16 +08:00
|
|
|
br->ip6_querier.addr.src.ip6 = *saddr;
|
2014-06-08 00:26:27 +08:00
|
|
|
|
2014-06-08 00:26:29 +08:00
|
|
|
/* update protected by general multicast_lock by caller */
|
|
|
|
rcu_assign_pointer(br->ip6_querier.port, port);
|
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static bool br_multicast_select_querier(struct net_bridge *br,
|
2014-06-08 00:26:29 +08:00
|
|
|
struct net_bridge_port *port,
|
2014-06-08 00:26:27 +08:00
|
|
|
struct br_ip *saddr)
|
|
|
|
{
|
|
|
|
switch (saddr->proto) {
|
|
|
|
case htons(ETH_P_IP):
|
2020-09-22 15:30:16 +08:00
|
|
|
return br_ip4_multicast_select_querier(br, port, saddr->src.ip4);
|
2014-06-08 00:26:27 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
case htons(ETH_P_IPV6):
|
2020-09-22 15:30:16 +08:00
|
|
|
return br_ip6_multicast_select_querier(br, port, &saddr->src.ip6);
|
2014-06-08 00:26:27 +08:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
static void
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_update_query_timer(struct net_bridge *br,
|
|
|
|
struct bridge_mcast_other_query *query,
|
|
|
|
unsigned long max_delay)
|
2013-08-01 07:06:20 +08:00
|
|
|
{
|
2014-06-08 00:26:26 +08:00
|
|
|
if (!timer_pending(&query->timer))
|
|
|
|
query->delay_time = jiffies + max_delay;
|
2013-08-01 07:06:20 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
mod_timer(&query->timer, jiffies + br->multicast_querier_interval);
|
2013-08-01 07:06:20 +08:00
|
|
|
}
|
|
|
|
|
2017-02-09 21:54:42 +08:00
|
|
|
static void br_port_mc_router_state_change(struct net_bridge_port *p,
|
|
|
|
bool is_mc_router)
|
|
|
|
{
|
|
|
|
struct switchdev_attr attr = {
|
|
|
|
.orig_dev = p->dev,
|
|
|
|
.id = SWITCHDEV_ATTR_ID_PORT_MROUTER,
|
|
|
|
.flags = SWITCHDEV_F_DEFER,
|
|
|
|
.u.mrouter = is_mc_router,
|
|
|
|
};
|
|
|
|
|
|
|
|
switchdev_port_attr_set(p->dev, &attr);
|
|
|
|
}
|
|
|
|
|
2010-04-27 23:01:04 +08:00
|
|
|
/*
|
2013-06-21 15:37:25 +08:00
|
|
|
* Add port to router_list
|
2010-04-27 23:01:04 +08:00
|
|
|
* list is maintained ordered by pointer value
|
|
|
|
* and locked by br->multicast_lock and RCU
|
|
|
|
*/
|
2010-02-28 03:41:49 +08:00
|
|
|
static void br_multicast_add_router(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port)
|
|
|
|
{
|
2010-04-27 15:13:11 +08:00
|
|
|
struct net_bridge_port *p;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 09:06:00 +08:00
|
|
|
struct hlist_node *slot = NULL;
|
2010-04-27 15:13:11 +08:00
|
|
|
|
2015-06-10 01:23:57 +08:00
|
|
|
if (!hlist_unhashed(&port->rlist))
|
|
|
|
return;
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 09:06:00 +08:00
|
|
|
hlist_for_each_entry(p, &br->router_list, rlist) {
|
2010-04-27 23:01:04 +08:00
|
|
|
if ((unsigned long) port >= (unsigned long) p)
|
|
|
|
break;
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 09:06:00 +08:00
|
|
|
slot = &p->rlist;
|
2010-04-27 15:13:11 +08:00
|
|
|
}
|
|
|
|
|
2010-04-27 23:01:04 +08:00
|
|
|
if (slot)
|
2014-08-07 07:09:16 +08:00
|
|
|
hlist_add_behind_rcu(&port->rlist, slot);
|
2010-04-27 15:13:11 +08:00
|
|
|
else
|
|
|
|
hlist_add_head_rcu(&port->rlist, &br->router_list);
|
2015-07-23 20:00:53 +08:00
|
|
|
br_rtr_notify(br->dev, port, RTM_NEWMDB);
|
2017-02-09 21:54:42 +08:00
|
|
|
br_port_mc_router_state_change(port, true);
|
2010-02-28 03:41:49 +08:00
|
|
|
}
|
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
static void br_multicast_mark_router(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port)
|
|
|
|
{
|
|
|
|
unsigned long now = jiffies;
|
|
|
|
|
|
|
|
if (!port) {
|
2017-10-09 17:15:31 +08:00
|
|
|
if (br->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) {
|
|
|
|
if (!timer_pending(&br->multicast_router_timer))
|
|
|
|
br_mc_router_state_change(br, true);
|
2010-02-28 03:41:45 +08:00
|
|
|
mod_timer(&br->multicast_router_timer,
|
|
|
|
now + br->multicast_querier_interval);
|
2017-10-09 17:15:31 +08:00
|
|
|
}
|
2010-02-28 03:41:45 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-02-27 04:20:03 +08:00
|
|
|
if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
|
|
|
|
port->multicast_router == MDB_RTR_TYPE_PERM)
|
2010-02-28 03:41:45 +08:00
|
|
|
return;
|
|
|
|
|
2010-02-28 03:41:49 +08:00
|
|
|
br_multicast_add_router(br, port);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
mod_timer(&port->multicast_router_timer,
|
|
|
|
now + br->multicast_querier_interval);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void br_multicast_query_received(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_other_query *query,
|
2014-06-08 00:26:27 +08:00
|
|
|
struct br_ip *saddr,
|
2013-08-01 07:06:20 +08:00
|
|
|
unsigned long max_delay)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2014-06-08 00:26:29 +08:00
|
|
|
if (!br_multicast_select_querier(br, port, saddr))
|
2010-02-28 03:41:45 +08:00
|
|
|
return;
|
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
br_multicast_update_query_timer(br, query, max_delay);
|
2019-02-22 21:22:32 +08:00
|
|
|
br_multicast_mark_router(br, port);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2018-08-06 11:07:23 +08:00
|
|
|
static void br_ip4_multicast_query(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
u16 vid)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2019-01-21 14:26:25 +08:00
|
|
|
unsigned int transport_len = ip_transport_len(skb);
|
2011-04-22 12:53:02 +08:00
|
|
|
const struct iphdr *iph = ip_hdr(skb);
|
2010-02-28 03:41:45 +08:00
|
|
|
struct igmphdr *ih = igmp_hdr(skb);
|
|
|
|
struct net_bridge_mdb_entry *mp;
|
|
|
|
struct igmpv3_query *ih3;
|
|
|
|
struct net_bridge_port_group *p;
|
2010-11-15 14:38:10 +08:00
|
|
|
struct net_bridge_port_group __rcu **pp;
|
2014-06-08 00:26:27 +08:00
|
|
|
struct br_ip saddr;
|
2010-02-28 03:41:45 +08:00
|
|
|
unsigned long max_delay;
|
|
|
|
unsigned long now = jiffies;
|
|
|
|
__be32 group;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
if (!netif_running(br->dev) ||
|
|
|
|
(port && port->state == BR_STATE_DISABLED))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
group = ih->group;
|
|
|
|
|
2019-01-21 14:26:25 +08:00
|
|
|
if (transport_len == sizeof(*ih)) {
|
2010-02-28 03:41:45 +08:00
|
|
|
max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
|
|
|
|
|
|
|
|
if (!max_delay) {
|
|
|
|
max_delay = 10 * HZ;
|
|
|
|
group = 0;
|
|
|
|
}
|
2019-01-21 14:26:25 +08:00
|
|
|
} else if (transport_len >= sizeof(*ih3)) {
|
2010-02-28 03:41:45 +08:00
|
|
|
ih3 = igmpv3_query_hdr(skb);
|
2020-09-07 17:56:18 +08:00
|
|
|
if (ih3->nsrcs ||
|
|
|
|
(br->multicast_igmp_version == 3 && group && ih3->suppress))
|
2010-03-14 04:27:21 +08:00
|
|
|
goto out;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2010-03-16 03:27:00 +08:00
|
|
|
max_delay = ih3->code ?
|
|
|
|
IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1;
|
2015-05-02 20:01:07 +08:00
|
|
|
} else {
|
2014-03-11 05:25:24 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
if (!group) {
|
|
|
|
saddr.proto = htons(ETH_P_IP);
|
2020-09-22 15:30:16 +08:00
|
|
|
saddr.src.ip4 = iph->saddr;
|
2013-08-01 07:06:20 +08:00
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
br_multicast_query_received(br, port, &br->ip4_other_query,
|
|
|
|
&saddr, max_delay);
|
2010-02-28 03:41:45 +08:00
|
|
|
goto out;
|
2014-06-08 00:26:27 +08:00
|
|
|
}
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
mp = br_mdb_ip4_get(br, group, vid);
|
2010-02-28 03:41:45 +08:00
|
|
|
if (!mp)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
max_delay *= br->multicast_last_member_count;
|
|
|
|
|
2017-11-10 06:10:57 +08:00
|
|
|
if (mp->host_joined &&
|
2010-02-28 03:41:45 +08:00
|
|
|
(timer_pending(&mp->timer) ?
|
|
|
|
time_after(mp->timer.expires, now + max_delay) :
|
|
|
|
try_to_del_timer_sync(&mp->timer) >= 0))
|
|
|
|
mod_timer(&mp->timer, now + max_delay);
|
|
|
|
|
2010-11-15 14:38:10 +08:00
|
|
|
for (pp = &mp->ports;
|
|
|
|
(p = mlock_dereference(*pp, br)) != NULL;
|
|
|
|
pp = &p->next) {
|
2010-02-28 03:41:45 +08:00
|
|
|
if (timer_pending(&p->timer) ?
|
|
|
|
time_after(p->timer.expires, now + max_delay) :
|
2020-09-07 17:56:18 +08:00
|
|
|
try_to_del_timer_sync(&p->timer) >= 0 &&
|
|
|
|
(br->multicast_igmp_version == 2 ||
|
|
|
|
p->filter_mode == MCAST_EXCLUDE))
|
2011-02-11 20:42:07 +08:00
|
|
|
mod_timer(&p->timer, now + max_delay);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2010-04-23 00:54:22 +08:00
|
|
|
static int br_ip6_multicast_query(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-10-29 03:45:07 +08:00
|
|
|
struct sk_buff *skb,
|
|
|
|
u16 vid)
|
2010-04-23 00:54:22 +08:00
|
|
|
{
|
2019-01-21 14:26:25 +08:00
|
|
|
unsigned int transport_len = ipv6_transport_len(skb);
|
2012-12-13 14:51:28 +08:00
|
|
|
struct mld_msg *mld;
|
2010-04-23 00:54:22 +08:00
|
|
|
struct net_bridge_mdb_entry *mp;
|
|
|
|
struct mld2_query *mld2q;
|
2010-11-15 14:38:10 +08:00
|
|
|
struct net_bridge_port_group *p;
|
|
|
|
struct net_bridge_port_group __rcu **pp;
|
2014-06-08 00:26:27 +08:00
|
|
|
struct br_ip saddr;
|
2010-04-23 00:54:22 +08:00
|
|
|
unsigned long max_delay;
|
|
|
|
unsigned long now = jiffies;
|
2016-05-04 23:25:02 +08:00
|
|
|
unsigned int offset = skb_transport_offset(skb);
|
2011-04-22 12:53:02 +08:00
|
|
|
const struct in6_addr *group = NULL;
|
2014-03-11 05:25:24 +08:00
|
|
|
bool is_general_query;
|
2010-04-23 00:54:22 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
if (!netif_running(br->dev) ||
|
|
|
|
(port && port->state == BR_STATE_DISABLED))
|
|
|
|
goto out;
|
|
|
|
|
2019-01-21 14:26:25 +08:00
|
|
|
if (transport_len == sizeof(*mld)) {
|
2016-05-04 23:25:02 +08:00
|
|
|
if (!pskb_may_pull(skb, offset + sizeof(*mld))) {
|
2010-04-23 00:54:22 +08:00
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
mld = (struct mld_msg *) icmp6_hdr(skb);
|
2012-07-10 07:56:12 +08:00
|
|
|
max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));
|
2010-04-23 00:54:22 +08:00
|
|
|
if (max_delay)
|
|
|
|
group = &mld->mld_mca;
|
2013-08-06 06:32:05 +08:00
|
|
|
} else {
|
2016-05-04 23:25:02 +08:00
|
|
|
if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) {
|
2010-04-23 00:54:22 +08:00
|
|
|
err = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
mld2q = (struct mld2_query *)icmp6_hdr(skb);
|
|
|
|
if (!mld2q->mld2q_nsrcs)
|
|
|
|
group = &mld2q->mld2q_mca;
|
2020-09-07 17:56:18 +08:00
|
|
|
if (br->multicast_mld_version == 2 &&
|
|
|
|
!ipv6_addr_any(&mld2q->mld2q_mca) &&
|
|
|
|
mld2q->mld2q_suppress)
|
|
|
|
goto out;
|
2013-09-04 06:19:39 +08:00
|
|
|
|
|
|
|
max_delay = max(msecs_to_jiffies(mldv2_mrc(mld2q)), 1UL);
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
|
2014-03-11 05:25:24 +08:00
|
|
|
is_general_query = group && ipv6_addr_any(group);
|
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
if (is_general_query) {
|
|
|
|
saddr.proto = htons(ETH_P_IPV6);
|
2020-09-22 15:30:16 +08:00
|
|
|
saddr.src.ip6 = ipv6_hdr(skb)->saddr;
|
2013-08-01 07:06:20 +08:00
|
|
|
|
2014-06-08 00:26:27 +08:00
|
|
|
br_multicast_query_received(br, port, &br->ip6_other_query,
|
|
|
|
&saddr, max_delay);
|
2010-04-23 00:54:22 +08:00
|
|
|
goto out;
|
2014-06-12 07:41:23 +08:00
|
|
|
} else if (!group) {
|
|
|
|
goto out;
|
2014-06-08 00:26:27 +08:00
|
|
|
}
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
mp = br_mdb_ip6_get(br, group, vid);
|
2010-04-23 00:54:22 +08:00
|
|
|
if (!mp)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
max_delay *= br->multicast_last_member_count;
|
2017-11-10 06:10:57 +08:00
|
|
|
if (mp->host_joined &&
|
2010-04-23 00:54:22 +08:00
|
|
|
(timer_pending(&mp->timer) ?
|
|
|
|
time_after(mp->timer.expires, now + max_delay) :
|
|
|
|
try_to_del_timer_sync(&mp->timer) >= 0))
|
|
|
|
mod_timer(&mp->timer, now + max_delay);
|
|
|
|
|
2010-11-15 14:38:10 +08:00
|
|
|
for (pp = &mp->ports;
|
|
|
|
(p = mlock_dereference(*pp, br)) != NULL;
|
|
|
|
pp = &p->next) {
|
2010-04-23 00:54:22 +08:00
|
|
|
if (timer_pending(&p->timer) ?
|
|
|
|
time_after(p->timer.expires, now + max_delay) :
|
2020-09-07 17:56:18 +08:00
|
|
|
try_to_del_timer_sync(&p->timer) >= 0 &&
|
|
|
|
(br->multicast_mld_version == 1 ||
|
|
|
|
p->filter_mode == MCAST_EXCLUDE))
|
2011-02-11 20:42:07 +08:00
|
|
|
mod_timer(&p->timer, now + max_delay);
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
static void
|
|
|
|
br_multicast_leave_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
struct br_ip *group,
|
|
|
|
struct bridge_mcast_other_query *other_query,
|
2017-01-22 04:01:32 +08:00
|
|
|
struct bridge_mcast_own_query *own_query,
|
|
|
|
const unsigned char *src)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_mdb_entry *mp;
|
|
|
|
struct net_bridge_port_group *p;
|
|
|
|
unsigned long now;
|
|
|
|
unsigned long time;
|
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
if (!netif_running(br->dev) ||
|
2015-07-28 18:28:27 +08:00
|
|
|
(port && port->state == BR_STATE_DISABLED))
|
2010-02-28 03:41:45 +08:00
|
|
|
goto out;
|
|
|
|
|
2018-12-05 21:14:24 +08:00
|
|
|
mp = br_mdb_ip_get(br, group);
|
2010-02-28 03:41:45 +08:00
|
|
|
if (!mp)
|
|
|
|
goto out;
|
|
|
|
|
2015-07-28 18:28:27 +08:00
|
|
|
if (port && (port->flags & BR_MULTICAST_FAST_LEAVE)) {
|
|
|
|
struct net_bridge_port_group __rcu **pp;
|
|
|
|
|
|
|
|
for (pp = &mp->ports;
|
|
|
|
(p = mlock_dereference(*pp, br)) != NULL;
|
|
|
|
pp = &p->next) {
|
2017-01-22 04:01:32 +08:00
|
|
|
if (!br_port_group_equal(p, port, src))
|
2015-07-28 18:28:27 +08:00
|
|
|
continue;
|
|
|
|
|
2019-07-30 19:21:00 +08:00
|
|
|
if (p->flags & MDB_PG_FLAGS_PERMANENT)
|
|
|
|
break;
|
|
|
|
|
2020-09-07 17:56:06 +08:00
|
|
|
p->flags |= MDB_PG_FLAGS_FAST_LEAVE;
|
|
|
|
br_multicast_del_pg(mp, p, pp);
|
2015-07-28 18:28:27 +08:00
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (timer_pending(&other_query->timer))
|
|
|
|
goto out;
|
|
|
|
|
2018-09-26 22:01:04 +08:00
|
|
|
if (br_opt_get(br, BROPT_MULTICAST_QUERIER)) {
|
2020-09-07 17:56:09 +08:00
|
|
|
__br_multicast_send_query(br, port, NULL, NULL, &mp->addr,
|
2020-09-07 17:56:10 +08:00
|
|
|
false, 0, NULL);
|
2013-05-22 05:52:56 +08:00
|
|
|
|
|
|
|
time = jiffies + br->multicast_last_member_count *
|
|
|
|
br->multicast_last_member_interval;
|
2013-08-30 23:28:17 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
mod_timer(&own_query->timer, time);
|
2013-05-22 05:52:56 +08:00
|
|
|
|
|
|
|
for (p = mlock_dereference(mp->ports, br);
|
|
|
|
p != NULL;
|
|
|
|
p = mlock_dereference(p->next, br)) {
|
2017-01-22 04:01:32 +08:00
|
|
|
if (!br_port_group_equal(p, port, src))
|
2013-05-22 05:52:56 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!hlist_unhashed(&p->mglist) &&
|
|
|
|
(timer_pending(&p->timer) ?
|
|
|
|
time_after(p->timer.expires, time) :
|
|
|
|
try_to_del_timer_sync(&p->timer) >= 0)) {
|
|
|
|
mod_timer(&p->timer, time);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
now = jiffies;
|
|
|
|
time = now + br->multicast_last_member_count *
|
|
|
|
br->multicast_last_member_interval;
|
|
|
|
|
|
|
|
if (!port) {
|
2017-11-10 06:10:57 +08:00
|
|
|
if (mp->host_joined &&
|
2010-02-28 03:41:45 +08:00
|
|
|
(timer_pending(&mp->timer) ?
|
|
|
|
time_after(mp->timer.expires, time) :
|
|
|
|
try_to_del_timer_sync(&mp->timer) >= 0)) {
|
|
|
|
mod_timer(&mp->timer, time);
|
|
|
|
}
|
2013-10-20 06:58:57 +08:00
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (p = mlock_dereference(mp->ports, br);
|
|
|
|
p != NULL;
|
|
|
|
p = mlock_dereference(p->next, br)) {
|
2020-09-22 15:30:22 +08:00
|
|
|
if (p->key.port != port)
|
2013-10-20 06:58:57 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!hlist_unhashed(&p->mglist) &&
|
|
|
|
(timer_pending(&p->timer) ?
|
|
|
|
time_after(p->timer.expires, time) :
|
|
|
|
try_to_del_timer_sync(&p->timer) >= 0)) {
|
|
|
|
mod_timer(&p->timer, time);
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
out:
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2010-04-18 11:42:07 +08:00
|
|
|
static void br_ip4_multicast_leave_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-02-13 20:00:17 +08:00
|
|
|
__be32 group,
|
2017-01-22 04:01:32 +08:00
|
|
|
__u16 vid,
|
|
|
|
const unsigned char *src)
|
2010-04-18 11:42:07 +08:00
|
|
|
{
|
|
|
|
struct br_ip br_group;
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_own_query *own_query;
|
2010-04-18 11:42:07 +08:00
|
|
|
|
|
|
|
if (ipv4_is_local_multicast(group))
|
|
|
|
return;
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
own_query = port ? &port->ip4_own_query : &br->ip4_own_query;
|
|
|
|
|
2019-04-04 04:27:24 +08:00
|
|
|
memset(&br_group, 0, sizeof(br_group));
|
2020-09-22 15:30:17 +08:00
|
|
|
br_group.dst.ip4 = group;
|
2010-04-18 11:42:07 +08:00
|
|
|
br_group.proto = htons(ETH_P_IP);
|
2013-02-13 20:00:17 +08:00
|
|
|
br_group.vid = vid;
|
2010-04-18 11:42:07 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_leave_group(br, port, &br_group, &br->ip4_other_query,
|
2017-01-22 04:01:32 +08:00
|
|
|
own_query, src);
|
2010-04-18 11:42:07 +08:00
|
|
|
}
|
|
|
|
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2010-04-23 00:54:22 +08:00
|
|
|
static void br_ip6_multicast_leave_group(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-02-13 20:00:17 +08:00
|
|
|
const struct in6_addr *group,
|
2017-01-22 04:01:32 +08:00
|
|
|
__u16 vid,
|
|
|
|
const unsigned char *src)
|
2010-04-23 00:54:22 +08:00
|
|
|
{
|
|
|
|
struct br_ip br_group;
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_own_query *own_query;
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2013-09-04 08:13:39 +08:00
|
|
|
if (ipv6_addr_is_ll_all_nodes(group))
|
2010-04-23 00:54:22 +08:00
|
|
|
return;
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
own_query = port ? &port->ip6_own_query : &br->ip6_own_query;
|
|
|
|
|
2019-04-04 04:27:24 +08:00
|
|
|
memset(&br_group, 0, sizeof(br_group));
|
2020-09-22 15:30:17 +08:00
|
|
|
br_group.dst.ip6 = *group;
|
2010-04-23 00:54:22 +08:00
|
|
|
br_group.proto = htons(ETH_P_IPV6);
|
2013-02-13 20:00:17 +08:00
|
|
|
br_group.vid = vid;
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_leave_group(br, port, &br_group, &br->ip6_other_query,
|
2017-01-22 04:01:32 +08:00
|
|
|
own_query, src);
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
#endif
|
2010-04-18 11:42:07 +08:00
|
|
|
|
2016-06-28 22:57:06 +08:00
|
|
|
static void br_multicast_err_count(const struct net_bridge *br,
|
|
|
|
const struct net_bridge_port *p,
|
|
|
|
__be16 proto)
|
|
|
|
{
|
|
|
|
struct bridge_mcast_stats __percpu *stats;
|
|
|
|
struct bridge_mcast_stats *pstats;
|
|
|
|
|
2018-09-26 22:01:04 +08:00
|
|
|
if (!br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
|
2016-06-28 22:57:06 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (p)
|
|
|
|
stats = p->mcast_stats;
|
|
|
|
else
|
|
|
|
stats = br->mcast_stats;
|
|
|
|
if (WARN_ON(!stats))
|
|
|
|
return;
|
|
|
|
|
|
|
|
pstats = this_cpu_ptr(stats);
|
|
|
|
|
|
|
|
u64_stats_update_begin(&pstats->syncp);
|
|
|
|
switch (proto) {
|
|
|
|
case htons(ETH_P_IP):
|
|
|
|
pstats->mstats.igmp_parse_errors++;
|
|
|
|
break;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
case htons(ETH_P_IPV6):
|
|
|
|
pstats->mstats.mld_parse_errors++;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
u64_stats_update_end(&pstats->syncp);
|
|
|
|
}
|
|
|
|
|
2016-10-31 20:21:05 +08:00
|
|
|
static void br_multicast_pim(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
const struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
unsigned int offset = skb_transport_offset(skb);
|
|
|
|
struct pimhdr *pimhdr, _pimhdr;
|
|
|
|
|
|
|
|
pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr);
|
|
|
|
if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION ||
|
|
|
|
pim_hdr_type(pimhdr) != PIM_TYPE_HELLO)
|
|
|
|
return;
|
|
|
|
|
|
|
|
br_multicast_mark_router(br, port);
|
|
|
|
}
|
|
|
|
|
2019-01-21 14:26:28 +08:00
|
|
|
static int br_ip4_multicast_mrd_rcv(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
if (ip_hdr(skb)->protocol != IPPROTO_IGMP ||
|
|
|
|
igmp_hdr(skb)->type != IGMP_MRDISC_ADV)
|
|
|
|
return -ENOMSG;
|
|
|
|
|
|
|
|
br_multicast_mark_router(br, port);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
static int br_multicast_ipv4_rcv(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-10-29 03:45:07 +08:00
|
|
|
struct sk_buff *skb,
|
|
|
|
u16 vid)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2017-01-22 04:01:32 +08:00
|
|
|
const unsigned char *src;
|
2010-02-28 03:41:45 +08:00
|
|
|
struct igmphdr *ih;
|
|
|
|
int err;
|
|
|
|
|
2019-01-21 14:26:25 +08:00
|
|
|
err = ip_mc_check_igmp(skb);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2015-05-02 20:01:07 +08:00
|
|
|
if (err == -ENOMSG) {
|
2016-10-31 20:21:05 +08:00
|
|
|
if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) {
|
2011-06-23 10:39:12 +08:00
|
|
|
BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
|
2016-10-31 20:21:05 +08:00
|
|
|
} else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) {
|
|
|
|
if (ip_hdr(skb)->protocol == IPPROTO_PIM)
|
|
|
|
br_multicast_pim(br, port, skb);
|
2019-01-21 14:26:28 +08:00
|
|
|
} else if (ipv4_is_all_snoopers(ip_hdr(skb)->daddr)) {
|
2019-02-19 10:17:09 +08:00
|
|
|
br_ip4_multicast_mrd_rcv(br, port, skb);
|
2016-10-31 20:21:05 +08:00
|
|
|
}
|
2019-01-21 14:26:28 +08:00
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
return 0;
|
2015-05-02 20:01:07 +08:00
|
|
|
} else if (err < 0) {
|
2016-06-28 22:57:06 +08:00
|
|
|
br_multicast_err_count(br, port, skb->protocol);
|
2015-05-02 20:01:07 +08:00
|
|
|
return err;
|
2011-06-23 10:39:12 +08:00
|
|
|
}
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2015-05-02 20:01:07 +08:00
|
|
|
ih = igmp_hdr(skb);
|
2017-01-22 04:01:32 +08:00
|
|
|
src = eth_hdr(skb)->h_source;
|
2016-06-28 22:57:06 +08:00
|
|
|
BR_INPUT_SKB_CB(skb)->igmp = ih->type;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
switch (ih->type) {
|
|
|
|
case IGMP_HOST_MEMBERSHIP_REPORT:
|
|
|
|
case IGMPV2_HOST_MEMBERSHIP_REPORT:
|
2011-06-13 23:04:43 +08:00
|
|
|
BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
|
2020-09-07 17:56:07 +08:00
|
|
|
err = br_ip4_multicast_add_group(br, port, ih->group, vid, src,
|
|
|
|
true);
|
2010-02-28 03:41:45 +08:00
|
|
|
break;
|
|
|
|
case IGMPV3_HOST_MEMBERSHIP_REPORT:
|
2019-01-21 14:26:25 +08:00
|
|
|
err = br_ip4_multicast_igmp3_report(br, port, skb, vid);
|
2010-02-28 03:41:45 +08:00
|
|
|
break;
|
|
|
|
case IGMP_HOST_MEMBERSHIP_QUERY:
|
2019-01-21 14:26:25 +08:00
|
|
|
br_ip4_multicast_query(br, port, skb, vid);
|
2010-02-28 03:41:45 +08:00
|
|
|
break;
|
|
|
|
case IGMP_HOST_LEAVE_MESSAGE:
|
2017-01-22 04:01:32 +08:00
|
|
|
br_ip4_multicast_leave_group(br, port, ih->group, vid, src);
|
2010-02-28 03:41:45 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-07-07 03:12:21 +08:00
|
|
|
br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
|
2016-06-28 22:57:06 +08:00
|
|
|
BR_MCAST_DIR_RX);
|
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2019-01-21 14:26:28 +08:00
|
|
|
static int br_ip6_multicast_mrd_rcv(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
|
|
|
struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (ipv6_hdr(skb)->nexthdr != IPPROTO_ICMPV6)
|
|
|
|
return -ENOMSG;
|
|
|
|
|
|
|
|
ret = ipv6_mc_check_icmpv6(skb);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV)
|
|
|
|
return -ENOMSG;
|
|
|
|
|
|
|
|
br_multicast_mark_router(br, port);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-23 00:54:22 +08:00
|
|
|
static int br_multicast_ipv6_rcv(struct net_bridge *br,
|
|
|
|
struct net_bridge_port *port,
|
2013-10-29 03:45:07 +08:00
|
|
|
struct sk_buff *skb,
|
|
|
|
u16 vid)
|
2010-04-23 00:54:22 +08:00
|
|
|
{
|
2017-01-22 04:01:32 +08:00
|
|
|
const unsigned char *src;
|
2015-05-02 20:01:07 +08:00
|
|
|
struct mld_msg *mld;
|
2010-04-23 00:54:22 +08:00
|
|
|
int err;
|
|
|
|
|
2019-01-21 14:26:25 +08:00
|
|
|
err = ipv6_mc_check_mld(skb);
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2015-05-02 20:01:07 +08:00
|
|
|
if (err == -ENOMSG) {
|
|
|
|
if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr))
|
|
|
|
BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
|
2019-01-21 14:26:28 +08:00
|
|
|
|
|
|
|
if (ipv6_addr_is_all_snoopers(&ipv6_hdr(skb)->daddr)) {
|
|
|
|
err = br_ip6_multicast_mrd_rcv(br, port, skb);
|
|
|
|
|
|
|
|
if (err < 0 && err != -ENOMSG) {
|
|
|
|
br_multicast_err_count(br, port, skb->protocol);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-23 00:54:22 +08:00
|
|
|
return 0;
|
2015-05-02 20:01:07 +08:00
|
|
|
} else if (err < 0) {
|
2016-06-28 22:57:06 +08:00
|
|
|
br_multicast_err_count(br, port, skb->protocol);
|
2015-05-02 20:01:07 +08:00
|
|
|
return err;
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
|
2015-05-02 20:01:07 +08:00
|
|
|
mld = (struct mld_msg *)skb_transport_header(skb);
|
2016-06-28 22:57:06 +08:00
|
|
|
BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type;
|
2010-04-23 00:54:22 +08:00
|
|
|
|
2015-05-02 20:01:07 +08:00
|
|
|
switch (mld->mld_type) {
|
2010-04-23 00:54:22 +08:00
|
|
|
case ICMPV6_MGM_REPORT:
|
2017-01-22 04:01:32 +08:00
|
|
|
src = eth_hdr(skb)->h_source;
|
2011-06-13 23:06:58 +08:00
|
|
|
BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
|
2017-01-22 04:01:32 +08:00
|
|
|
err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid,
|
2020-09-07 17:56:07 +08:00
|
|
|
src, true);
|
2010-04-23 00:54:22 +08:00
|
|
|
break;
|
|
|
|
case ICMPV6_MLD2_REPORT:
|
2019-01-21 14:26:25 +08:00
|
|
|
err = br_ip6_multicast_mld2_report(br, port, skb, vid);
|
2010-04-23 00:54:22 +08:00
|
|
|
break;
|
|
|
|
case ICMPV6_MGM_QUERY:
|
2019-01-21 14:26:25 +08:00
|
|
|
err = br_ip6_multicast_query(br, port, skb, vid);
|
2010-04-23 00:54:22 +08:00
|
|
|
break;
|
|
|
|
case ICMPV6_MGM_REDUCTION:
|
2017-01-22 04:01:32 +08:00
|
|
|
src = eth_hdr(skb)->h_source;
|
|
|
|
br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid, src);
|
2015-05-02 20:01:07 +08:00
|
|
|
break;
|
2010-04-23 00:54:22 +08:00
|
|
|
}
|
|
|
|
|
2016-07-07 03:12:21 +08:00
|
|
|
br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
|
2016-06-28 22:57:06 +08:00
|
|
|
BR_MCAST_DIR_RX);
|
|
|
|
|
2010-04-23 00:54:22 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
|
2013-10-29 03:45:07 +08:00
|
|
|
struct sk_buff *skb, u16 vid)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2016-06-28 22:57:06 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
2010-04-25 16:06:40 +08:00
|
|
|
BR_INPUT_SKB_CB(skb)->igmp = 0;
|
|
|
|
BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
|
|
|
|
|
2018-09-26 22:01:03 +08:00
|
|
|
if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
|
2010-02-28 03:41:45 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (skb->protocol) {
|
|
|
|
case htons(ETH_P_IP):
|
2016-06-28 22:57:06 +08:00
|
|
|
ret = br_multicast_ipv4_rcv(br, port, skb, vid);
|
|
|
|
break;
|
2011-12-10 17:48:31 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2010-04-23 00:54:22 +08:00
|
|
|
case htons(ETH_P_IPV6):
|
2016-06-28 22:57:06 +08:00
|
|
|
ret = br_multicast_ipv6_rcv(br, port, skb, vid);
|
|
|
|
break;
|
2010-04-23 00:54:22 +08:00
|
|
|
#endif
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2016-06-28 22:57:06 +08:00
|
|
|
return ret;
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
static void br_multicast_query_expired(struct net_bridge *br,
|
2014-06-08 00:26:29 +08:00
|
|
|
struct bridge_mcast_own_query *query,
|
|
|
|
struct bridge_mcast_querier *querier)
|
2013-08-30 23:28:17 +08:00
|
|
|
{
|
|
|
|
spin_lock(&br->multicast_lock);
|
|
|
|
if (query->startup_sent < br->multicast_startup_query_count)
|
|
|
|
query->startup_sent++;
|
|
|
|
|
2015-05-28 19:42:54 +08:00
|
|
|
RCU_INIT_POINTER(querier->port, NULL);
|
2013-08-30 23:28:17 +08:00
|
|
|
br_multicast_send_query(br, NULL, query);
|
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
}
|
|
|
|
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_ip4_multicast_query_expired(struct timer_list *t)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge *br = from_timer(br, t, ip4_own_query.timer);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2014-06-08 00:26:29 +08:00
|
|
|
br_multicast_query_expired(br, &br->ip4_own_query, &br->ip4_querier);
|
2013-08-30 23:28:17 +08:00
|
|
|
}
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2017-11-03 14:21:10 +08:00
|
|
|
static void br_ip6_multicast_query_expired(struct timer_list *t)
|
2013-08-30 23:28:17 +08:00
|
|
|
{
|
2017-11-03 14:21:10 +08:00
|
|
|
struct net_bridge *br = from_timer(br, t, ip6_own_query.timer);
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2014-06-08 00:26:29 +08:00
|
|
|
br_multicast_query_expired(br, &br->ip6_own_query, &br->ip6_querier);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2020-09-07 17:56:19 +08:00
|
|
|
static void br_multicast_gc_work(struct work_struct *work)
|
2020-09-07 17:56:07 +08:00
|
|
|
{
|
|
|
|
struct net_bridge *br = container_of(work, struct net_bridge,
|
2020-09-07 17:56:19 +08:00
|
|
|
mcast_gc_work);
|
2020-09-07 17:56:07 +08:00
|
|
|
HLIST_HEAD(deleted_head);
|
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
2020-09-07 17:56:19 +08:00
|
|
|
hlist_move_list(&br->mcast_gc_list, &deleted_head);
|
2020-09-07 17:56:07 +08:00
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
|
|
|
|
2020-09-07 17:56:19 +08:00
|
|
|
br_multicast_gc(&deleted_head);
|
2020-09-07 17:56:07 +08:00
|
|
|
}
|
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
void br_multicast_init(struct net_bridge *br)
|
|
|
|
{
|
2018-12-05 21:14:27 +08:00
|
|
|
br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2016-02-27 04:20:01 +08:00
|
|
|
br->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
|
2010-02-28 03:41:45 +08:00
|
|
|
br->multicast_last_member_count = 2;
|
|
|
|
br->multicast_startup_query_count = 2;
|
|
|
|
|
|
|
|
br->multicast_last_member_interval = HZ;
|
|
|
|
br->multicast_query_response_interval = 10 * HZ;
|
|
|
|
br->multicast_startup_query_interval = 125 * HZ / 4;
|
|
|
|
br->multicast_query_interval = 125 * HZ;
|
|
|
|
br->multicast_querier_interval = 255 * HZ;
|
|
|
|
br->multicast_membership_interval = 260 * HZ;
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br->ip4_other_query.delay_time = 0;
|
2014-06-08 00:26:29 +08:00
|
|
|
br->ip4_querier.port = NULL;
|
2016-11-21 20:03:25 +08:00
|
|
|
br->multicast_igmp_version = 2;
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2016-11-21 20:03:25 +08:00
|
|
|
br->multicast_mld_version = 1;
|
2014-06-08 00:26:26 +08:00
|
|
|
br->ip6_other_query.delay_time = 0;
|
2014-06-08 00:26:29 +08:00
|
|
|
br->ip6_querier.port = NULL;
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2018-10-01 16:57:01 +08:00
|
|
|
br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true);
|
2018-09-26 22:01:04 +08:00
|
|
|
br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
|
2013-08-01 07:06:20 +08:00
|
|
|
|
2010-02-28 03:41:45 +08:00
|
|
|
spin_lock_init(&br->multicast_lock);
|
2017-11-03 14:21:10 +08:00
|
|
|
timer_setup(&br->multicast_router_timer,
|
|
|
|
br_multicast_local_router_expired, 0);
|
|
|
|
timer_setup(&br->ip4_other_query.timer,
|
|
|
|
br_ip4_multicast_querier_expired, 0);
|
|
|
|
timer_setup(&br->ip4_own_query.timer,
|
|
|
|
br_ip4_multicast_query_expired, 0);
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2017-11-03 14:21:10 +08:00
|
|
|
timer_setup(&br->ip6_other_query.timer,
|
|
|
|
br_ip6_multicast_querier_expired, 0);
|
|
|
|
timer_setup(&br->ip6_own_query.timer,
|
|
|
|
br_ip6_multicast_query_expired, 0);
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2018-12-05 21:14:24 +08:00
|
|
|
INIT_HLIST_HEAD(&br->mdb_list);
|
2020-09-07 17:56:19 +08:00
|
|
|
INIT_HLIST_HEAD(&br->mcast_gc_list);
|
|
|
|
INIT_WORK(&br->mcast_gc_work, br_multicast_gc_work);
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
2019-01-21 14:26:27 +08:00
|
|
|
static void br_ip4_multicast_join_snoopers(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
struct in_device *in_dev = in_dev_get(br->dev);
|
|
|
|
|
|
|
|
if (!in_dev)
|
|
|
|
return;
|
|
|
|
|
2019-02-02 12:20:52 +08:00
|
|
|
__ip_mc_inc_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC);
|
2019-01-21 14:26:27 +08:00
|
|
|
in_dev_put(in_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
static void br_ip6_multicast_join_snoopers(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
struct in6_addr addr;
|
|
|
|
|
|
|
|
ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a));
|
|
|
|
ipv6_dev_mc_inc(br->dev, &addr);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void br_ip6_multicast_join_snoopers(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-12-05 07:56:28 +08:00
|
|
|
void br_multicast_join_snoopers(struct net_bridge *br)
|
2019-01-21 14:26:27 +08:00
|
|
|
{
|
|
|
|
br_ip4_multicast_join_snoopers(br);
|
|
|
|
br_ip6_multicast_join_snoopers(br);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void br_ip4_multicast_leave_snoopers(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
struct in_device *in_dev = in_dev_get(br->dev);
|
|
|
|
|
|
|
|
if (WARN_ON(!in_dev))
|
|
|
|
return;
|
|
|
|
|
2019-02-02 12:20:52 +08:00
|
|
|
__ip_mc_dec_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC);
|
2019-01-21 14:26:27 +08:00
|
|
|
in_dev_put(in_dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
static void br_ip6_multicast_leave_snoopers(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
struct in6_addr addr;
|
|
|
|
|
|
|
|
ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a));
|
|
|
|
ipv6_dev_mc_dec(br->dev, &addr);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline void br_ip6_multicast_leave_snoopers(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-12-05 07:56:28 +08:00
|
|
|
void br_multicast_leave_snoopers(struct net_bridge *br)
|
2019-01-21 14:26:27 +08:00
|
|
|
{
|
|
|
|
br_ip4_multicast_leave_snoopers(br);
|
|
|
|
br_ip6_multicast_leave_snoopers(br);
|
|
|
|
}
|
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
static void __br_multicast_open(struct net_bridge *br,
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_own_query *query)
|
2010-02-28 03:41:45 +08:00
|
|
|
{
|
2013-08-30 23:28:17 +08:00
|
|
|
query->startup_sent = 0;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
2018-09-26 22:01:03 +08:00
|
|
|
if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
|
2010-02-28 03:41:45 +08:00
|
|
|
return;
|
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
mod_timer(&query->timer, jiffies);
|
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_open(struct net_bridge *br)
|
|
|
|
{
|
2014-06-08 00:26:26 +08:00
|
|
|
__br_multicast_open(br, &br->ip4_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2014-06-08 00:26:26 +08:00
|
|
|
__br_multicast_open(br, &br->ip6_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_stop(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
del_timer_sync(&br->multicast_router_timer);
|
2014-06-08 00:26:26 +08:00
|
|
|
del_timer_sync(&br->ip4_other_query.timer);
|
|
|
|
del_timer_sync(&br->ip4_own_query.timer);
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2014-06-08 00:26:26 +08:00
|
|
|
del_timer_sync(&br->ip6_other_query.timer);
|
|
|
|
del_timer_sync(&br->ip6_own_query.timer);
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2015-07-15 22:16:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_dev_del(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
struct net_bridge_mdb_entry *mp;
|
2020-09-07 17:56:07 +08:00
|
|
|
HLIST_HEAD(deleted_head);
|
2018-12-05 21:14:24 +08:00
|
|
|
struct hlist_node *tmp;
|
2010-02-28 03:41:45 +08:00
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
2020-09-07 17:56:19 +08:00
|
|
|
hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node)
|
|
|
|
br_multicast_del_mdb_entry(mp);
|
|
|
|
hlist_move_list(&br->mcast_gc_list, &deleted_head);
|
2010-02-28 03:41:45 +08:00
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
2018-12-05 21:14:24 +08:00
|
|
|
|
2020-09-07 17:56:19 +08:00
|
|
|
br_multicast_gc(&deleted_head);
|
|
|
|
cancel_work_sync(&br->mcast_gc_work);
|
2020-09-07 17:56:07 +08:00
|
|
|
|
2018-12-05 21:14:25 +08:00
|
|
|
rcu_barrier();
|
2010-02-28 03:41:45 +08:00
|
|
|
}
|
2010-02-28 03:41:49 +08:00
|
|
|
|
|
|
|
int br_multicast_set_router(struct net_bridge *br, unsigned long val)
|
|
|
|
{
|
2015-05-23 09:12:34 +08:00
|
|
|
int err = -EINVAL;
|
2010-02-28 03:41:49 +08:00
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
|
|
|
|
|
|
|
switch (val) {
|
2016-02-27 04:20:01 +08:00
|
|
|
case MDB_RTR_TYPE_DISABLED:
|
|
|
|
case MDB_RTR_TYPE_PERM:
|
2017-10-09 17:15:31 +08:00
|
|
|
br_mc_router_state_change(br, val == MDB_RTR_TYPE_PERM);
|
2010-02-28 03:41:49 +08:00
|
|
|
del_timer(&br->multicast_router_timer);
|
2017-10-09 17:15:31 +08:00
|
|
|
br->multicast_router = val;
|
|
|
|
err = 0;
|
|
|
|
break;
|
2016-02-27 04:20:01 +08:00
|
|
|
case MDB_RTR_TYPE_TEMP_QUERY:
|
2017-10-09 17:15:31 +08:00
|
|
|
if (br->multicast_router != MDB_RTR_TYPE_TEMP_QUERY)
|
|
|
|
br_mc_router_state_change(br, false);
|
2010-02-28 03:41:49 +08:00
|
|
|
br->multicast_router = val;
|
|
|
|
err = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2016-02-27 04:20:01 +08:00
|
|
|
static void __del_port_router(struct net_bridge_port *p)
|
|
|
|
{
|
|
|
|
if (hlist_unhashed(&p->rlist))
|
|
|
|
return;
|
|
|
|
hlist_del_init_rcu(&p->rlist);
|
|
|
|
br_rtr_notify(p->br->dev, p, RTM_DELMDB);
|
2017-02-09 21:54:42 +08:00
|
|
|
br_port_mc_router_state_change(p, false);
|
2017-02-09 21:54:41 +08:00
|
|
|
|
|
|
|
/* don't allow timer refresh */
|
|
|
|
if (p->multicast_router == MDB_RTR_TYPE_TEMP)
|
|
|
|
p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
|
2016-02-27 04:20:01 +08:00
|
|
|
}
|
|
|
|
|
2010-02-28 03:41:49 +08:00
|
|
|
int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val)
|
|
|
|
{
|
|
|
|
struct net_bridge *br = p->br;
|
2016-02-27 04:20:03 +08:00
|
|
|
unsigned long now = jiffies;
|
2015-05-23 09:12:34 +08:00
|
|
|
int err = -EINVAL;
|
2010-02-28 03:41:49 +08:00
|
|
|
|
|
|
|
spin_lock(&br->multicast_lock);
|
2016-02-27 04:20:02 +08:00
|
|
|
if (p->multicast_router == val) {
|
2016-02-27 04:20:03 +08:00
|
|
|
/* Refresh the temp router port timer */
|
|
|
|
if (p->multicast_router == MDB_RTR_TYPE_TEMP)
|
|
|
|
mod_timer(&p->multicast_router_timer,
|
|
|
|
now + br->multicast_querier_interval);
|
2016-02-27 04:20:02 +08:00
|
|
|
err = 0;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2010-02-28 03:41:49 +08:00
|
|
|
switch (val) {
|
2016-02-27 04:20:01 +08:00
|
|
|
case MDB_RTR_TYPE_DISABLED:
|
|
|
|
p->multicast_router = MDB_RTR_TYPE_DISABLED;
|
|
|
|
__del_port_router(p);
|
|
|
|
del_timer(&p->multicast_router_timer);
|
|
|
|
break;
|
|
|
|
case MDB_RTR_TYPE_TEMP_QUERY:
|
|
|
|
p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
|
|
|
|
__del_port_router(p);
|
|
|
|
break;
|
|
|
|
case MDB_RTR_TYPE_PERM:
|
|
|
|
p->multicast_router = MDB_RTR_TYPE_PERM;
|
2010-02-28 03:41:49 +08:00
|
|
|
del_timer(&p->multicast_router_timer);
|
|
|
|
br_multicast_add_router(br, p);
|
|
|
|
break;
|
2016-02-27 04:20:03 +08:00
|
|
|
case MDB_RTR_TYPE_TEMP:
|
|
|
|
p->multicast_router = MDB_RTR_TYPE_TEMP;
|
|
|
|
br_multicast_mark_router(br, p);
|
|
|
|
break;
|
2016-02-27 04:20:01 +08:00
|
|
|
default:
|
|
|
|
goto unlock;
|
2010-02-28 03:41:49 +08:00
|
|
|
}
|
2016-02-27 04:20:01 +08:00
|
|
|
err = 0;
|
|
|
|
unlock:
|
2010-02-28 03:41:49 +08:00
|
|
|
spin_unlock(&br->multicast_lock);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
2010-02-28 03:41:50 +08:00
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
static void br_multicast_start_querier(struct net_bridge *br,
|
2014-06-08 00:26:26 +08:00
|
|
|
struct bridge_mcast_own_query *query)
|
2010-02-28 03:41:50 +08:00
|
|
|
{
|
|
|
|
struct net_bridge_port *port;
|
2012-04-13 10:37:42 +08:00
|
|
|
|
2013-08-30 23:28:17 +08:00
|
|
|
__br_multicast_open(br, query);
|
2012-04-13 10:37:42 +08:00
|
|
|
|
2019-04-11 20:08:25 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(port, &br->port_list, list) {
|
2012-04-13 10:37:42 +08:00
|
|
|
if (port->state == BR_STATE_DISABLED ||
|
|
|
|
port->state == BR_STATE_BLOCKING)
|
|
|
|
continue;
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
if (query == &br->ip4_own_query)
|
|
|
|
br_multicast_enable(&port->ip4_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
else
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_enable(&port->ip6_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2012-04-13 10:37:42 +08:00
|
|
|
}
|
2019-04-11 20:08:25 +08:00
|
|
|
rcu_read_unlock();
|
2012-04-13 10:37:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int br_multicast_toggle(struct net_bridge *br, unsigned long val)
|
|
|
|
{
|
2016-10-19 00:09:48 +08:00
|
|
|
struct net_bridge_port *port;
|
2020-12-05 07:56:28 +08:00
|
|
|
bool change_snoopers = false;
|
2010-02-28 03:41:50 +08:00
|
|
|
|
2011-11-10 13:48:03 +08:00
|
|
|
spin_lock_bh(&br->multicast_lock);
|
2018-09-26 22:01:03 +08:00
|
|
|
if (!!br_opt_get(br, BROPT_MULTICAST_ENABLED) == !!val)
|
2010-02-28 03:41:50 +08:00
|
|
|
goto unlock;
|
|
|
|
|
2018-09-26 22:01:03 +08:00
|
|
|
br_mc_disabled_update(br->dev, val);
|
|
|
|
br_opt_toggle(br, BROPT_MULTICAST_ENABLED, !!val);
|
2019-01-21 14:26:27 +08:00
|
|
|
if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) {
|
2020-12-05 07:56:28 +08:00
|
|
|
change_snoopers = true;
|
2010-02-28 03:41:50 +08:00
|
|
|
goto unlock;
|
2019-01-21 14:26:27 +08:00
|
|
|
}
|
2010-02-28 03:41:50 +08:00
|
|
|
|
2010-07-29 08:45:30 +08:00
|
|
|
if (!netif_running(br->dev))
|
|
|
|
goto unlock;
|
|
|
|
|
2016-10-19 00:09:48 +08:00
|
|
|
br_multicast_open(br);
|
|
|
|
list_for_each_entry(port, &br->port_list, list)
|
|
|
|
__br_multicast_enable_port(port);
|
2010-02-28 03:41:50 +08:00
|
|
|
|
2020-12-05 07:56:28 +08:00
|
|
|
change_snoopers = true;
|
|
|
|
|
2010-02-28 03:41:50 +08:00
|
|
|
unlock:
|
2011-11-10 13:48:03 +08:00
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
2010-02-28 03:41:50 +08:00
|
|
|
|
2020-12-05 07:56:28 +08:00
|
|
|
/* br_multicast_join_snoopers has the potential to cause
|
|
|
|
* an MLD Report/Leave to be delivered to br_multicast_rcv,
|
|
|
|
* which would in turn call br_multicast_add_group, which would
|
|
|
|
* attempt to acquire multicast_lock. This function should be
|
|
|
|
* called after the lock has been released to avoid deadlocks on
|
|
|
|
* multicast_lock.
|
|
|
|
*
|
|
|
|
* br_multicast_leave_snoopers does not have the problem since
|
|
|
|
* br_multicast_rcv first checks BROPT_MULTICAST_ENABLED, and
|
|
|
|
* returns without calling br_multicast_ipv4/6_rcv if it's not
|
|
|
|
* enabled. Moved both functions out just for symmetry.
|
|
|
|
*/
|
|
|
|
if (change_snoopers) {
|
|
|
|
if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
|
|
|
|
br_multicast_join_snoopers(br);
|
|
|
|
else
|
|
|
|
br_multicast_leave_snoopers(br);
|
|
|
|
}
|
|
|
|
|
2018-12-17 17:46:23 +08:00
|
|
|
return 0;
|
2010-02-28 03:41:50 +08:00
|
|
|
}
|
2010-02-28 03:41:51 +08:00
|
|
|
|
2017-05-26 14:37:24 +08:00
|
|
|
bool br_multicast_enabled(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_bridge *br = netdev_priv(dev);
|
|
|
|
|
2018-09-26 22:01:03 +08:00
|
|
|
return !!br_opt_get(br, BROPT_MULTICAST_ENABLED);
|
2017-05-26 14:37:24 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(br_multicast_enabled);
|
|
|
|
|
2017-10-09 17:15:32 +08:00
|
|
|
bool br_multicast_router(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct net_bridge *br = netdev_priv(dev);
|
|
|
|
bool is_router;
|
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
|
|
|
is_router = br_multicast_is_router(br);
|
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
|
|
|
return is_router;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(br_multicast_router);
|
|
|
|
|
2012-04-13 10:37:42 +08:00
|
|
|
int br_multicast_set_querier(struct net_bridge *br, unsigned long val)
|
|
|
|
{
|
2013-08-01 07:06:20 +08:00
|
|
|
unsigned long max_delay;
|
|
|
|
|
2012-04-13 10:37:42 +08:00
|
|
|
val = !!val;
|
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
2018-09-26 22:01:04 +08:00
|
|
|
if (br_opt_get(br, BROPT_MULTICAST_QUERIER) == val)
|
2012-04-13 10:37:42 +08:00
|
|
|
goto unlock;
|
|
|
|
|
2018-09-26 22:01:04 +08:00
|
|
|
br_opt_toggle(br, BROPT_MULTICAST_QUERIER, !!val);
|
2013-08-01 07:06:20 +08:00
|
|
|
if (!val)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
max_delay = br->multicast_query_response_interval;
|
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
if (!timer_pending(&br->ip4_other_query.timer))
|
|
|
|
br->ip4_other_query.delay_time = jiffies + max_delay;
|
2013-08-30 23:28:17 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_start_querier(br, &br->ip4_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2014-06-08 00:26:26 +08:00
|
|
|
if (!timer_pending(&br->ip6_other_query.timer))
|
|
|
|
br->ip6_other_query.delay_time = jiffies + max_delay;
|
2013-08-30 23:28:17 +08:00
|
|
|
|
2014-06-08 00:26:26 +08:00
|
|
|
br_multicast_start_querier(br, &br->ip6_own_query);
|
2013-08-30 23:28:17 +08:00
|
|
|
#endif
|
2012-04-13 10:37:42 +08:00
|
|
|
|
|
|
|
unlock:
|
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-21 20:03:24 +08:00
|
|
|
int br_multicast_set_igmp_version(struct net_bridge *br, unsigned long val)
|
|
|
|
{
|
|
|
|
/* Currently we support only version 2 and 3 */
|
|
|
|
switch (val) {
|
|
|
|
case 2:
|
|
|
|
case 3:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
|
|
|
br->multicast_igmp_version = val;
|
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-21 20:03:25 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
int br_multicast_set_mld_version(struct net_bridge *br, unsigned long val)
|
|
|
|
{
|
|
|
|
/* Currently we support version 1 and 2 */
|
|
|
|
switch (val) {
|
|
|
|
case 1:
|
|
|
|
case 2:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_bh(&br->multicast_lock);
|
|
|
|
br->multicast_mld_version = val;
|
|
|
|
spin_unlock_bh(&br->multicast_lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-06-08 00:26:28 +08:00
|
|
|
/**
|
|
|
|
* br_multicast_list_adjacent - Returns snooped multicast addresses
|
|
|
|
* @dev: The bridge port adjacent to which to retrieve addresses
|
|
|
|
* @br_ip_list: The list to store found, snooped multicast IP addresses in
|
|
|
|
*
|
|
|
|
* Creates a list of IP addresses (struct br_ip_list) sensed by the multicast
|
|
|
|
* snooping feature on all bridge ports of dev's bridge device, excluding
|
|
|
|
* the addresses from dev itself.
|
|
|
|
*
|
|
|
|
* Returns the number of items added to br_ip_list.
|
|
|
|
*
|
|
|
|
* Notes:
|
|
|
|
* - br_ip_list needs to be initialized by caller
|
|
|
|
* - br_ip_list might contain duplicates in the end
|
|
|
|
* (needs to be taken care of by caller)
|
|
|
|
* - br_ip_list needs to be freed by caller
|
|
|
|
*/
|
|
|
|
int br_multicast_list_adjacent(struct net_device *dev,
|
|
|
|
struct list_head *br_ip_list)
|
|
|
|
{
|
|
|
|
struct net_bridge *br;
|
|
|
|
struct net_bridge_port *port;
|
|
|
|
struct net_bridge_port_group *group;
|
|
|
|
struct br_ip_list *entry;
|
|
|
|
int count = 0;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2019-03-29 21:38:19 +08:00
|
|
|
if (!br_ip_list || !netif_is_bridge_port(dev))
|
2014-06-08 00:26:28 +08:00
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
port = br_port_get_rcu(dev);
|
|
|
|
if (!port || !port->br)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
br = port->br;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(port, &br->port_list, list) {
|
|
|
|
if (!port->dev || port->dev == dev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
hlist_for_each_entry_rcu(group, &port->mglist, mglist) {
|
|
|
|
entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
|
|
|
|
if (!entry)
|
|
|
|
goto unlock;
|
|
|
|
|
2020-09-22 15:30:22 +08:00
|
|
|
entry->addr = group->key.addr;
|
2014-06-08 00:26:28 +08:00
|
|
|
list_add(&entry->list, br_ip_list);
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(br_multicast_list_adjacent);
|
2014-06-08 00:26:29 +08:00
|
|
|
|
2014-07-07 11:41:17 +08:00
|
|
|
/**
|
|
|
|
* br_multicast_has_querier_anywhere - Checks for a querier on a bridge
|
|
|
|
* @dev: The bridge port providing the bridge on which to check for a querier
|
|
|
|
* @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
|
|
|
|
*
|
|
|
|
* Checks whether the given interface has a bridge on top and if so returns
|
|
|
|
* true if a valid querier exists anywhere on the bridged link layer.
|
|
|
|
* Otherwise returns false.
|
|
|
|
*/
|
|
|
|
bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto)
|
|
|
|
{
|
|
|
|
struct net_bridge *br;
|
|
|
|
struct net_bridge_port *port;
|
|
|
|
struct ethhdr eth;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2019-03-29 21:38:19 +08:00
|
|
|
if (!netif_is_bridge_port(dev))
|
2014-07-07 11:41:17 +08:00
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
port = br_port_get_rcu(dev);
|
|
|
|
if (!port || !port->br)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
br = port->br;
|
|
|
|
|
|
|
|
memset(ð, 0, sizeof(eth));
|
|
|
|
eth.h_proto = htons(proto);
|
|
|
|
|
2020-10-29 07:38:31 +08:00
|
|
|
ret = br_multicast_querier_exists(br, ð, NULL);
|
2014-07-07 11:41:17 +08:00
|
|
|
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere);
|
|
|
|
|
2014-06-08 00:26:29 +08:00
|
|
|
/**
|
|
|
|
* br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
|
|
|
|
* @dev: The bridge port adjacent to which to check for a querier
|
|
|
|
* @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
|
|
|
|
*
|
|
|
|
* Checks whether the given interface has a bridge on top and if so returns
|
|
|
|
* true if a selected querier is behind one of the other ports of this
|
|
|
|
* bridge. Otherwise returns false.
|
|
|
|
*/
|
|
|
|
bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto)
|
|
|
|
{
|
|
|
|
struct net_bridge *br;
|
|
|
|
struct net_bridge_port *port;
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2019-03-29 21:38:19 +08:00
|
|
|
if (!netif_is_bridge_port(dev))
|
2014-06-08 00:26:29 +08:00
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
port = br_port_get_rcu(dev);
|
|
|
|
if (!port || !port->br)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
br = port->br;
|
|
|
|
|
|
|
|
switch (proto) {
|
|
|
|
case ETH_P_IP:
|
|
|
|
if (!timer_pending(&br->ip4_other_query.timer) ||
|
|
|
|
rcu_dereference(br->ip4_querier.port) == port)
|
|
|
|
goto unlock;
|
|
|
|
break;
|
2014-06-12 07:41:24 +08:00
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
2014-06-08 00:26:29 +08:00
|
|
|
case ETH_P_IPV6:
|
|
|
|
if (!timer_pending(&br->ip6_other_query.timer) ||
|
|
|
|
rcu_dereference(br->ip6_querier.port) == port)
|
|
|
|
goto unlock;
|
|
|
|
break;
|
2014-06-12 07:41:24 +08:00
|
|
|
#endif
|
2014-06-08 00:26:29 +08:00
|
|
|
default:
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = true;
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent);
|
2016-06-28 22:57:06 +08:00
|
|
|
|
|
|
|
static void br_mcast_stats_add(struct bridge_mcast_stats __percpu *stats,
|
2016-07-07 03:12:21 +08:00
|
|
|
const struct sk_buff *skb, u8 type, u8 dir)
|
2016-06-28 22:57:06 +08:00
|
|
|
{
|
|
|
|
struct bridge_mcast_stats *pstats = this_cpu_ptr(stats);
|
2016-07-07 03:12:21 +08:00
|
|
|
__be16 proto = skb->protocol;
|
|
|
|
unsigned int t_len;
|
2016-06-28 22:57:06 +08:00
|
|
|
|
|
|
|
u64_stats_update_begin(&pstats->syncp);
|
|
|
|
switch (proto) {
|
|
|
|
case htons(ETH_P_IP):
|
2016-07-07 03:12:21 +08:00
|
|
|
t_len = ntohs(ip_hdr(skb)->tot_len) - ip_hdrlen(skb);
|
2016-06-28 22:57:06 +08:00
|
|
|
switch (type) {
|
|
|
|
case IGMP_HOST_MEMBERSHIP_REPORT:
|
|
|
|
pstats->mstats.igmp_v1reports[dir]++;
|
|
|
|
break;
|
|
|
|
case IGMPV2_HOST_MEMBERSHIP_REPORT:
|
|
|
|
pstats->mstats.igmp_v2reports[dir]++;
|
|
|
|
break;
|
|
|
|
case IGMPV3_HOST_MEMBERSHIP_REPORT:
|
|
|
|
pstats->mstats.igmp_v3reports[dir]++;
|
|
|
|
break;
|
|
|
|
case IGMP_HOST_MEMBERSHIP_QUERY:
|
2016-07-07 03:12:21 +08:00
|
|
|
if (t_len != sizeof(struct igmphdr)) {
|
|
|
|
pstats->mstats.igmp_v3queries[dir]++;
|
|
|
|
} else {
|
|
|
|
unsigned int offset = skb_transport_offset(skb);
|
|
|
|
struct igmphdr *ih, _ihdr;
|
|
|
|
|
|
|
|
ih = skb_header_pointer(skb, offset,
|
|
|
|
sizeof(_ihdr), &_ihdr);
|
|
|
|
if (!ih)
|
|
|
|
break;
|
|
|
|
if (!ih->code)
|
|
|
|
pstats->mstats.igmp_v1queries[dir]++;
|
|
|
|
else
|
|
|
|
pstats->mstats.igmp_v2queries[dir]++;
|
|
|
|
}
|
2016-06-28 22:57:06 +08:00
|
|
|
break;
|
|
|
|
case IGMP_HOST_LEAVE_MESSAGE:
|
|
|
|
pstats->mstats.igmp_leaves[dir]++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#if IS_ENABLED(CONFIG_IPV6)
|
|
|
|
case htons(ETH_P_IPV6):
|
2016-07-07 03:12:21 +08:00
|
|
|
t_len = ntohs(ipv6_hdr(skb)->payload_len) +
|
|
|
|
sizeof(struct ipv6hdr);
|
|
|
|
t_len -= skb_network_header_len(skb);
|
2016-06-28 22:57:06 +08:00
|
|
|
switch (type) {
|
|
|
|
case ICMPV6_MGM_REPORT:
|
|
|
|
pstats->mstats.mld_v1reports[dir]++;
|
|
|
|
break;
|
|
|
|
case ICMPV6_MLD2_REPORT:
|
|
|
|
pstats->mstats.mld_v2reports[dir]++;
|
|
|
|
break;
|
|
|
|
case ICMPV6_MGM_QUERY:
|
2016-07-07 03:12:21 +08:00
|
|
|
if (t_len != sizeof(struct mld_msg))
|
|
|
|
pstats->mstats.mld_v2queries[dir]++;
|
|
|
|
else
|
|
|
|
pstats->mstats.mld_v1queries[dir]++;
|
2016-06-28 22:57:06 +08:00
|
|
|
break;
|
|
|
|
case ICMPV6_MGM_REDUCTION:
|
|
|
|
pstats->mstats.mld_leaves[dir]++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif /* CONFIG_IPV6 */
|
|
|
|
}
|
|
|
|
u64_stats_update_end(&pstats->syncp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_count(struct net_bridge *br, const struct net_bridge_port *p,
|
2016-07-07 03:12:21 +08:00
|
|
|
const struct sk_buff *skb, u8 type, u8 dir)
|
2016-06-28 22:57:06 +08:00
|
|
|
{
|
|
|
|
struct bridge_mcast_stats __percpu *stats;
|
|
|
|
|
|
|
|
/* if multicast_disabled is true then igmp type can't be set */
|
2018-09-26 22:01:04 +08:00
|
|
|
if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
|
2016-06-28 22:57:06 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (p)
|
|
|
|
stats = p->mcast_stats;
|
|
|
|
else
|
|
|
|
stats = br->mcast_stats;
|
|
|
|
if (WARN_ON(!stats))
|
|
|
|
return;
|
|
|
|
|
2016-07-07 03:12:21 +08:00
|
|
|
br_mcast_stats_add(stats, skb, type, dir);
|
2016-06-28 22:57:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int br_multicast_init_stats(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
br->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
|
|
|
|
if (!br->mcast_stats)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-04-10 19:59:27 +08:00
|
|
|
void br_multicast_uninit_stats(struct net_bridge *br)
|
|
|
|
{
|
|
|
|
free_percpu(br->mcast_stats);
|
|
|
|
}
|
|
|
|
|
2020-05-27 21:51:13 +08:00
|
|
|
/* noinline for https://bugs.llvm.org/show_bug.cgi?id=45802#c9 */
|
|
|
|
static noinline_for_stack void mcast_stats_add_dir(u64 *dst, u64 *src)
|
2016-06-28 22:57:06 +08:00
|
|
|
{
|
|
|
|
dst[BR_MCAST_DIR_RX] += src[BR_MCAST_DIR_RX];
|
|
|
|
dst[BR_MCAST_DIR_TX] += src[BR_MCAST_DIR_TX];
|
|
|
|
}
|
|
|
|
|
|
|
|
void br_multicast_get_stats(const struct net_bridge *br,
|
|
|
|
const struct net_bridge_port *p,
|
|
|
|
struct br_mcast_stats *dest)
|
|
|
|
{
|
|
|
|
struct bridge_mcast_stats __percpu *stats;
|
|
|
|
struct br_mcast_stats tdst;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(dest, 0, sizeof(*dest));
|
|
|
|
if (p)
|
|
|
|
stats = p->mcast_stats;
|
|
|
|
else
|
|
|
|
stats = br->mcast_stats;
|
|
|
|
if (WARN_ON(!stats))
|
|
|
|
return;
|
|
|
|
|
|
|
|
memset(&tdst, 0, sizeof(tdst));
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
struct bridge_mcast_stats *cpu_stats = per_cpu_ptr(stats, i);
|
|
|
|
struct br_mcast_stats temp;
|
|
|
|
unsigned int start;
|
|
|
|
|
|
|
|
do {
|
|
|
|
start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
|
|
|
|
memcpy(&temp, &cpu_stats->mstats, sizeof(temp));
|
|
|
|
} while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
|
|
|
|
|
2016-07-07 03:12:21 +08:00
|
|
|
mcast_stats_add_dir(tdst.igmp_v1queries, temp.igmp_v1queries);
|
|
|
|
mcast_stats_add_dir(tdst.igmp_v2queries, temp.igmp_v2queries);
|
|
|
|
mcast_stats_add_dir(tdst.igmp_v3queries, temp.igmp_v3queries);
|
2016-06-28 22:57:06 +08:00
|
|
|
mcast_stats_add_dir(tdst.igmp_leaves, temp.igmp_leaves);
|
|
|
|
mcast_stats_add_dir(tdst.igmp_v1reports, temp.igmp_v1reports);
|
|
|
|
mcast_stats_add_dir(tdst.igmp_v2reports, temp.igmp_v2reports);
|
|
|
|
mcast_stats_add_dir(tdst.igmp_v3reports, temp.igmp_v3reports);
|
|
|
|
tdst.igmp_parse_errors += temp.igmp_parse_errors;
|
|
|
|
|
2016-07-07 03:12:21 +08:00
|
|
|
mcast_stats_add_dir(tdst.mld_v1queries, temp.mld_v1queries);
|
|
|
|
mcast_stats_add_dir(tdst.mld_v2queries, temp.mld_v2queries);
|
2016-06-28 22:57:06 +08:00
|
|
|
mcast_stats_add_dir(tdst.mld_leaves, temp.mld_leaves);
|
|
|
|
mcast_stats_add_dir(tdst.mld_v1reports, temp.mld_v1reports);
|
|
|
|
mcast_stats_add_dir(tdst.mld_v2reports, temp.mld_v2reports);
|
|
|
|
tdst.mld_parse_errors += temp.mld_parse_errors;
|
|
|
|
}
|
|
|
|
memcpy(dest, &tdst, sizeof(*dest));
|
|
|
|
}
|
2018-12-05 21:14:24 +08:00
|
|
|
|
|
|
|
int br_mdb_hash_init(struct net_bridge *br)
|
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = rhashtable_init(&br->sg_port_tbl, &br_sg_port_rht_params);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = rhashtable_init(&br->mdb_hash_tbl, &br_mdb_rht_params);
|
|
|
|
if (err) {
|
|
|
|
rhashtable_destroy(&br->sg_port_tbl);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2018-12-05 21:14:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void br_mdb_hash_fini(struct net_bridge *br)
|
|
|
|
{
|
2020-09-22 15:30:22 +08:00
|
|
|
rhashtable_destroy(&br->sg_port_tbl);
|
2018-12-05 21:14:24 +08:00
|
|
|
rhashtable_destroy(&br->mdb_hash_tbl);
|
|
|
|
}
|