1/* SPDX-License-Identifier: GPL-2.0-or-later */
2/*
3 * Linux ethernet bridge
4 *
5 * Authors:
6 * Lennert Buytenhek <buytenh@gnu.org>
7 */
8
9#ifndef _BR_PRIVATE_H
10#define _BR_PRIVATE_H
11
12#include <linux/netdevice.h>
13#include <linux/if_bridge.h>
14#include <linux/netpoll.h>
15#include <linux/u64_stats_sync.h>
16#include <net/route.h>
17#include <net/ip6_fib.h>
18#include <net/pkt_cls.h>
19#include <linux/if_vlan.h>
20#include <linux/rhashtable.h>
21#include <linux/refcount.h>
22
23#define BR_HASH_BITS 8
24#define BR_HASH_SIZE (1 << BR_HASH_BITS)
25
26#define BR_HOLD_TIME (1*HZ)
27
28#define BR_PORT_BITS 10
29#define BR_MAX_PORTS (1<<BR_PORT_BITS)
30
31#define BR_MULTICAST_DEFAULT_HASH_MAX 4096
32#define BR_MULTICAST_QUERY_INTVL_MIN msecs_to_jiffies(1000)
33#define BR_MULTICAST_STARTUP_QUERY_INTVL_MIN BR_MULTICAST_QUERY_INTVL_MIN
34#define BR_MULTICAST_QUERY_INTVL_MAX msecs_to_jiffies(86400000) /* 24 hours */
35#define BR_MULTICAST_STARTUP_QUERY_INTVL_MAX BR_MULTICAST_QUERY_INTVL_MAX
36
37#define BR_HWDOM_MAX BITS_PER_LONG
38
39#define BR_VERSION "2.3"
40
41/* Control of forwarding link local multicast */
42#define BR_GROUPFWD_DEFAULT 0
43/* Don't allow forwarding of control protocols like STP, MAC PAUSE and LACP */
44enum {
45 BR_GROUPFWD_STP = BIT(0),
46 BR_GROUPFWD_MACPAUSE = BIT(1),
47 BR_GROUPFWD_LACP = BIT(2),
48};
49
50#define BR_GROUPFWD_RESTRICTED (BR_GROUPFWD_STP | BR_GROUPFWD_MACPAUSE | \
51 BR_GROUPFWD_LACP)
52/* The Nearest Customer Bridge Group Address, 01-80-C2-00-00-[00,0B,0C,0D,0F] */
53#define BR_GROUPFWD_8021AD 0xB801u
54
55/* Path to usermode spanning tree program */
56#define BR_STP_PROG "/sbin/bridge-stp"
57
58#define BR_FDB_NOTIFY_SETTABLE_BITS (FDB_NOTIFY_BIT | FDB_NOTIFY_INACTIVE_BIT)
59
60typedef struct bridge_id bridge_id;
61typedef struct mac_addr mac_addr;
62typedef __u16 port_id;
63
64struct bridge_id {
65 unsigned char prio[2];
66 unsigned char addr[ETH_ALEN];
67};
68
69struct mac_addr {
70 unsigned char addr[ETH_ALEN];
71};
72
73#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
74/* our own querier */
75struct bridge_mcast_own_query {
76 struct timer_list timer;
77 u32 startup_sent;
78};
79
80/* other querier */
81struct bridge_mcast_other_query {
82 struct timer_list timer;
83 struct timer_list delay_timer;
84};
85
86/* selected querier */
87struct bridge_mcast_querier {
88 struct br_ip addr;
89 int port_ifidx;
90 seqcount_spinlock_t seq;
91};
92
93/* IGMP/MLD statistics */
94struct bridge_mcast_stats {
95 struct br_mcast_stats mstats;
96 struct u64_stats_sync syncp;
97};
98
99struct br_mdb_src_entry {
100 struct br_ip addr;
101};
102
103struct br_mdb_config {
104 struct net_bridge *br;
105 struct net_bridge_port *p;
106 struct br_mdb_entry *entry;
107 struct br_ip group;
108 bool src_entry;
109 u8 filter_mode;
110 u16 nlflags;
111 struct br_mdb_src_entry *src_entries;
112 int num_src_entries;
113 u8 rt_protocol;
114};
115#endif
116
117/* net_bridge_mcast_port must be always defined due to forwarding stubs */
118struct net_bridge_mcast_port {
119#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
120 struct net_bridge_port *port;
121 struct net_bridge_vlan *vlan;
122
123 struct bridge_mcast_own_query ip4_own_query;
124 struct timer_list ip4_mc_router_timer;
125 struct hlist_node ip4_rlist;
126#if IS_ENABLED(CONFIG_IPV6)
127 struct bridge_mcast_own_query ip6_own_query;
128 struct timer_list ip6_mc_router_timer;
129 struct hlist_node ip6_rlist;
130#endif /* IS_ENABLED(CONFIG_IPV6) */
131 unsigned char multicast_router;
132 u32 mdb_n_entries;
133 u32 mdb_max_entries;
134#endif /* CONFIG_BRIDGE_IGMP_SNOOPING */
135};
136
137/* net_bridge_mcast must be always defined due to forwarding stubs */
138struct net_bridge_mcast {
139#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
140 struct net_bridge *br;
141 struct net_bridge_vlan *vlan;
142
143 u32 multicast_last_member_count;
144 u32 multicast_startup_query_count;
145
146 u8 multicast_querier;
147 u8 multicast_igmp_version;
148 u8 multicast_router;
149#if IS_ENABLED(CONFIG_IPV6)
150 u8 multicast_mld_version;
151#endif
152 unsigned long multicast_last_member_interval;
153 unsigned long multicast_membership_interval;
154 unsigned long multicast_querier_interval;
155 unsigned long multicast_query_interval;
156 unsigned long multicast_query_response_interval;
157 unsigned long multicast_startup_query_interval;
158 struct hlist_head ip4_mc_router_list;
159 struct timer_list ip4_mc_router_timer;
160 struct bridge_mcast_other_query ip4_other_query;
161 struct bridge_mcast_own_query ip4_own_query;
162 struct bridge_mcast_querier ip4_querier;
163#if IS_ENABLED(CONFIG_IPV6)
164 struct hlist_head ip6_mc_router_list;
165 struct timer_list ip6_mc_router_timer;
166 struct bridge_mcast_other_query ip6_other_query;
167 struct bridge_mcast_own_query ip6_own_query;
168 struct bridge_mcast_querier ip6_querier;
169#endif /* IS_ENABLED(CONFIG_IPV6) */
170#endif /* CONFIG_BRIDGE_IGMP_SNOOPING */
171};
172
173struct br_tunnel_info {
174 __be64 tunnel_id;
175 struct metadata_dst __rcu *tunnel_dst;
176};
177
178/* private vlan flags */
179enum {
180 BR_VLFLAG_PER_PORT_STATS = BIT(0),
181 BR_VLFLAG_ADDED_BY_SWITCHDEV = BIT(1),
182 BR_VLFLAG_MCAST_ENABLED = BIT(2),
183 BR_VLFLAG_GLOBAL_MCAST_ENABLED = BIT(3),
184 BR_VLFLAG_NEIGH_SUPPRESS_ENABLED = BIT(4),
185};
186
187/**
188 * struct net_bridge_vlan - per-vlan entry
189 *
190 * @vnode: rhashtable member
191 * @tnode: rhashtable member
192 * @vid: VLAN id
193 * @flags: bridge vlan flags
194 * @priv_flags: private (in-kernel) bridge vlan flags
195 * @state: STP state (e.g. blocking, learning, forwarding)
196 * @stats: per-cpu VLAN statistics
197 * @br: if MASTER flag set, this points to a bridge struct
198 * @port: if MASTER flag unset, this points to a port struct
199 * @refcnt: if MASTER flag set, this is bumped for each port referencing it
200 * @brvlan: if MASTER flag unset, this points to the global per-VLAN context
201 * for this VLAN entry
202 * @tinfo: bridge tunnel info
203 * @br_mcast_ctx: if MASTER flag set, this is the global vlan multicast context
204 * @port_mcast_ctx: if MASTER flag unset, this is the per-port/vlan multicast
205 * context
206 * @msti: if MASTER flag set, this holds the VLANs MST instance
207 * @vlist: sorted list of VLAN entries
208 * @rcu: used for entry destruction
209 *
210 * This structure is shared between the global per-VLAN entries contained in
211 * the bridge rhashtable and the local per-port per-VLAN entries contained in
212 * the port's rhashtable. The union entries should be interpreted depending on
213 * the entry flags that are set.
214 */
215struct net_bridge_vlan {
216 struct rhash_head vnode;
217 struct rhash_head tnode;
218 u16 vid;
219 u16 flags;
220 u16 priv_flags;
221 u8 state;
222 struct pcpu_sw_netstats __percpu *stats;
223 union {
224 struct net_bridge *br;
225 struct net_bridge_port *port;
226 };
227 union {
228 refcount_t refcnt;
229 struct net_bridge_vlan *brvlan;
230 };
231
232 struct br_tunnel_info tinfo;
233
234 union {
235 struct net_bridge_mcast br_mcast_ctx;
236 struct net_bridge_mcast_port port_mcast_ctx;
237 };
238
239 u16 msti;
240
241 struct list_head vlist;
242
243 struct rcu_head rcu;
244};
245
246/**
247 * struct net_bridge_vlan_group
248 *
249 * @vlan_hash: VLAN entry rhashtable
250 * @tunnel_hash: Hash table to map from tunnel key ID (e.g. VXLAN VNI) to VLAN
251 * @vlan_list: sorted VLAN entry list
252 * @num_vlans: number of total VLAN entries
253 * @pvid: PVID VLAN id
254 * @pvid_state: PVID's STP state (e.g. forwarding, learning, blocking)
255 *
256 * IMPORTANT: Be careful when checking if there're VLAN entries using list
257 * primitives because the bridge can have entries in its list which
258 * are just for global context but not for filtering, i.e. they have
259 * the master flag set but not the brentry flag. If you have to check
260 * if there're "real" entries in the bridge please test @num_vlans
261 */
262struct net_bridge_vlan_group {
263 struct rhashtable vlan_hash;
264 struct rhashtable tunnel_hash;
265 struct list_head vlan_list;
266 u16 num_vlans;
267 u16 pvid;
268 u8 pvid_state;
269};
270
271/* bridge fdb flags */
272enum {
273 BR_FDB_LOCAL,
274 BR_FDB_STATIC,
275 BR_FDB_STICKY,
276 BR_FDB_ADDED_BY_USER,
277 BR_FDB_ADDED_BY_EXT_LEARN,
278 BR_FDB_OFFLOADED,
279 BR_FDB_NOTIFY,
280 BR_FDB_NOTIFY_INACTIVE,
281 BR_FDB_LOCKED,
282 BR_FDB_DYNAMIC_LEARNED,
283};
284
285struct net_bridge_fdb_key {
286 mac_addr addr;
287 u16 vlan_id;
288};
289
290struct net_bridge_fdb_entry {
291 struct rhash_head rhnode;
292 struct net_bridge_port *dst;
293
294 struct net_bridge_fdb_key key;
295 struct hlist_node fdb_node;
296 unsigned long flags;
297
298 /* write-heavy members should not affect lookups */
299 unsigned long updated ____cacheline_aligned_in_smp;
300 unsigned long used;
301
302 struct rcu_head rcu;
303};
304
305struct net_bridge_fdb_flush_desc {
306 unsigned long flags;
307 unsigned long flags_mask;
308 int port_ifindex;
309 u16 vlan_id;
310};
311
312#define MDB_PG_FLAGS_PERMANENT BIT(0)
313#define MDB_PG_FLAGS_OFFLOAD BIT(1)
314#define MDB_PG_FLAGS_FAST_LEAVE BIT(2)
315#define MDB_PG_FLAGS_STAR_EXCL BIT(3)
316#define MDB_PG_FLAGS_BLOCKED BIT(4)
317#define MDB_PG_FLAGS_OFFLOAD_FAILED BIT(5)
318
319#define PG_SRC_ENT_LIMIT 32
320
321#define BR_SGRP_F_DELETE BIT(0)
322#define BR_SGRP_F_SEND BIT(1)
323#define BR_SGRP_F_INSTALLED BIT(2)
324#define BR_SGRP_F_USER_ADDED BIT(3)
325
326struct net_bridge_mcast_gc {
327 struct hlist_node gc_node;
328 void (*destroy)(struct net_bridge_mcast_gc *gc);
329};
330
331struct net_bridge_group_src {
332 struct hlist_node node;
333
334 struct br_ip addr;
335 struct net_bridge_port_group *pg;
336 u8 flags;
337 u8 src_query_rexmit_cnt;
338 struct timer_list timer;
339
340 struct net_bridge *br;
341 struct net_bridge_mcast_gc mcast_gc;
342 struct rcu_head rcu;
343};
344
345struct net_bridge_port_group_sg_key {
346 struct net_bridge_port *port;
347 struct br_ip addr;
348};
349
350struct net_bridge_port_group {
351 struct net_bridge_port_group __rcu *next;
352 struct net_bridge_port_group_sg_key key;
353 unsigned char eth_addr[ETH_ALEN] __aligned(2);
354 unsigned char flags;
355 unsigned char filter_mode;
356 unsigned char grp_query_rexmit_cnt;
357 unsigned char rt_protocol;
358
359 struct hlist_head src_list;
360 unsigned int src_ents;
361 struct timer_list timer;
362 struct timer_list rexmit_timer;
363 struct hlist_node mglist;
364 struct rb_root eht_set_tree;
365 struct rb_root eht_host_tree;
366
367 struct rhash_head rhnode;
368 struct net_bridge_mcast_gc mcast_gc;
369 struct rcu_head rcu;
370};
371
372struct net_bridge_mdb_entry {
373 struct rhash_head rhnode;
374 struct net_bridge *br;
375 struct net_bridge_port_group __rcu *ports;
376 struct br_ip addr;
377 bool host_joined;
378
379 struct timer_list timer;
380 struct hlist_node mdb_node;
381
382 struct net_bridge_mcast_gc mcast_gc;
383 struct rcu_head rcu;
384};
385
386struct net_bridge_port {
387 struct net_bridge *br;
388 struct net_device *dev;
389 netdevice_tracker dev_tracker;
390 struct list_head list;
391
392 unsigned long flags;
393#ifdef CONFIG_BRIDGE_VLAN_FILTERING
394 struct net_bridge_vlan_group __rcu *vlgrp;
395#endif
396 struct net_bridge_port __rcu *backup_port;
397 u32 backup_nhid;
398
399 /* STP */
400 u8 priority;
401 u8 state;
402 u16 port_no;
403 unsigned char topology_change_ack;
404 unsigned char config_pending;
405 port_id port_id;
406 port_id designated_port;
407 bridge_id designated_root;
408 bridge_id designated_bridge;
409 u32 path_cost;
410 u32 designated_cost;
411 unsigned long designated_age;
412
413 struct timer_list forward_delay_timer;
414 struct timer_list hold_timer;
415 struct timer_list message_age_timer;
416 struct kobject kobj;
417 struct rcu_head rcu;
418
419 struct net_bridge_mcast_port multicast_ctx;
420
421#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
422 struct bridge_mcast_stats __percpu *mcast_stats;
423
424 u32 multicast_eht_hosts_limit;
425 u32 multicast_eht_hosts_cnt;
426 struct hlist_head mglist;
427#endif
428
429#ifdef CONFIG_SYSFS
430 char sysfs_name[IFNAMSIZ];
431#endif
432
433#ifdef CONFIG_NET_POLL_CONTROLLER
434 struct netpoll *np;
435#endif
436#ifdef CONFIG_NET_SWITCHDEV
437 /* Identifier used to group ports that share the same switchdev
438 * hardware domain.
439 */
440 int hwdom;
441 int offload_count;
442 struct netdev_phys_item_id ppid;
443#endif
444 u16 group_fwd_mask;
445 u16 backup_redirected_cnt;
446
447 struct bridge_stp_xstats stp_xstats;
448};
449
450#define kobj_to_brport(obj) container_of(obj, struct net_bridge_port, kobj)
451
452#define br_auto_port(p) ((p)->flags & BR_AUTO_MASK)
453#define br_promisc_port(p) ((p)->flags & BR_PROMISC)
454
455static inline struct net_bridge_port *br_port_get_rcu(const struct net_device *dev)
456{
457 return rcu_dereference(dev->rx_handler_data);
458}
459
460static inline struct net_bridge_port *br_port_get_rtnl(const struct net_device *dev)
461{
462 return netif_is_bridge_port(dev) ?
463 rtnl_dereference(dev->rx_handler_data) : NULL;
464}
465
466static inline struct net_bridge_port *br_port_get_rtnl_rcu(const struct net_device *dev)
467{
468 return netif_is_bridge_port(dev) ?
469 rcu_dereference_rtnl(dev->rx_handler_data) : NULL;
470}
471
472enum net_bridge_opts {
473 BROPT_VLAN_ENABLED,
474 BROPT_VLAN_STATS_ENABLED,
475 BROPT_NF_CALL_IPTABLES,
476 BROPT_NF_CALL_IP6TABLES,
477 BROPT_NF_CALL_ARPTABLES,
478 BROPT_GROUP_ADDR_SET,
479 BROPT_MULTICAST_ENABLED,
480 BROPT_MULTICAST_QUERY_USE_IFADDR,
481 BROPT_MULTICAST_STATS_ENABLED,
482 BROPT_HAS_IPV6_ADDR,
483 BROPT_NEIGH_SUPPRESS_ENABLED,
484 BROPT_MTU_SET_BY_USER,
485 BROPT_VLAN_STATS_PER_PORT,
486 BROPT_NO_LL_LEARN,
487 BROPT_VLAN_BRIDGE_BINDING,
488 BROPT_MCAST_VLAN_SNOOPING_ENABLED,
489 BROPT_MST_ENABLED,
490 BROPT_MDB_OFFLOAD_FAIL_NOTIFICATION,
491 BROPT_FDB_LOCAL_VLAN_0,
492};
493
494struct net_bridge {
495 spinlock_t lock;
496 spinlock_t hash_lock;
497 struct hlist_head frame_type_list;
498 struct net_device *dev;
499 unsigned long options;
500 /* These fields are accessed on each packet */
501#ifdef CONFIG_BRIDGE_VLAN_FILTERING
502 __be16 vlan_proto;
503 u16 default_pvid;
504 struct net_bridge_vlan_group __rcu *vlgrp;
505#endif
506
507 struct rhashtable fdb_hash_tbl;
508 struct list_head port_list;
509#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
510 union {
511 struct rtable fake_rtable;
512 struct rt6_info fake_rt6_info;
513 };
514 u32 metrics[RTAX_MAX];
515#endif
516 u16 group_fwd_mask;
517 u16 group_fwd_mask_required;
518
519 /* STP */
520 bridge_id designated_root;
521 bridge_id bridge_id;
522 unsigned char topology_change;
523 unsigned char topology_change_detected;
524 u16 root_port;
525 unsigned long max_age;
526 unsigned long hello_time;
527 unsigned long forward_delay;
528 unsigned long ageing_time;
529 unsigned long bridge_max_age;
530 unsigned long bridge_hello_time;
531 unsigned long bridge_forward_delay;
532 unsigned long bridge_ageing_time;
533 u32 root_path_cost;
534
535 u8 group_addr[ETH_ALEN];
536
537 enum {
538 BR_NO_STP, /* no spanning tree */
539 BR_KERNEL_STP, /* old STP in kernel */
540 BR_USER_STP, /* new RSTP in userspace */
541 } stp_enabled;
542
543 struct net_bridge_mcast multicast_ctx;
544
545#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
546 struct bridge_mcast_stats __percpu *mcast_stats;
547
548 u32 hash_max;
549
550 spinlock_t multicast_lock;
551
552 struct rhashtable mdb_hash_tbl;
553 struct rhashtable sg_port_tbl;
554
555 struct hlist_head mcast_gc_list;
556 struct hlist_head mdb_list;
557
558 struct work_struct mcast_gc_work;
559#endif
560
561 struct timer_list hello_timer;
562 struct timer_list tcn_timer;
563 struct timer_list topology_change_timer;
564 struct delayed_work gc_work;
565 struct kobject *ifobj;
566 u32 auto_cnt;
567
568 atomic_t fdb_n_learned;
569 u32 fdb_max_learned;
570
571#ifdef CONFIG_NET_SWITCHDEV
572 /* Counter used to make sure that hardware domains get unique
573 * identifiers in case a bridge spans multiple switchdev instances.
574 */
575 int last_hwdom;
576 /* Bit mask of hardware domain numbers in use */
577 unsigned long busy_hwdoms;
578#endif
579 struct hlist_head fdb_list;
580
581#if IS_ENABLED(CONFIG_BRIDGE_MRP)
582 struct hlist_head mrp_list;
583#endif
584#if IS_ENABLED(CONFIG_BRIDGE_CFM)
585 struct hlist_head mep_list;
586#endif
587};
588
589struct br_input_skb_cb {
590 struct net_device *brdev;
591
592 u16 frag_max_size;
593#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
594 u8 igmp;
595 u8 mrouters_only:1;
596#endif
597 u8 proxyarp_replied:1;
598 u8 src_port_isolated:1;
599 u8 promisc:1;
600#ifdef CONFIG_BRIDGE_VLAN_FILTERING
601 u8 vlan_filtered:1;
602#endif
603#ifdef CONFIG_NETFILTER_FAMILY_BRIDGE
604 u8 br_netfilter_broute:1;
605#endif
606
607#ifdef CONFIG_NET_SWITCHDEV
608 /* Set if TX data plane offloading is used towards at least one
609 * hardware domain.
610 */
611 u8 tx_fwd_offload:1;
612 /* The switchdev hardware domain from which this packet was received.
613 * If skb->offload_fwd_mark was set, then this packet was already
614 * forwarded by hardware to the other ports in the source hardware
615 * domain, otherwise it wasn't.
616 */
617 int src_hwdom;
618 /* Bit mask of hardware domains towards this packet has already been
619 * transmitted using the TX data plane offload.
620 */
621 unsigned long fwd_hwdoms;
622#endif
623
624 u32 backup_nhid;
625};
626
627#define BR_INPUT_SKB_CB(__skb) ((struct br_input_skb_cb *)(__skb)->cb)
628
629#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
630# define BR_INPUT_SKB_CB_MROUTERS_ONLY(__skb) (BR_INPUT_SKB_CB(__skb)->mrouters_only)
631#else
632# define BR_INPUT_SKB_CB_MROUTERS_ONLY(__skb) (0)
633#endif
634
635#define br_printk(level, br, format, args...) \
636 printk(level "%s: " format, (br)->dev->name, ##args)
637
638#define br_err(__br, format, args...) \
639 br_printk(KERN_ERR, __br, format, ##args)
640#define br_warn(__br, format, args...) \
641 br_printk(KERN_WARNING, __br, format, ##args)
642#define br_notice(__br, format, args...) \
643 br_printk(KERN_NOTICE, __br, format, ##args)
644#define br_info(__br, format, args...) \
645 br_printk(KERN_INFO, __br, format, ##args)
646
647#define br_debug(br, format, args...) \
648 pr_debug("%s: " format, (br)->dev->name, ##args)
649
650/* called under bridge lock */
651static inline int br_is_root_bridge(const struct net_bridge *br)
652{
653 return !memcmp(p: &br->bridge_id, q: &br->designated_root, size: 8);
654}
655
656/* check if a VLAN entry is global */
657static inline bool br_vlan_is_master(const struct net_bridge_vlan *v)
658{
659 return v->flags & BRIDGE_VLAN_INFO_MASTER;
660}
661
662/* check if a VLAN entry is used by the bridge */
663static inline bool br_vlan_is_brentry(const struct net_bridge_vlan *v)
664{
665 return v->flags & BRIDGE_VLAN_INFO_BRENTRY;
666}
667
668/* check if we should use the vlan entry, returns false if it's only context */
669static inline bool br_vlan_should_use(const struct net_bridge_vlan *v)
670{
671 if (br_vlan_is_master(v)) {
672 if (br_vlan_is_brentry(v))
673 return true;
674 else
675 return false;
676 }
677
678 return true;
679}
680
681static inline bool nbp_state_should_learn(const struct net_bridge_port *p)
682{
683 return p->state == BR_STATE_LEARNING || p->state == BR_STATE_FORWARDING;
684}
685
686static inline bool br_vlan_valid_id(u16 vid, struct netlink_ext_ack *extack)
687{
688 bool ret = vid > 0 && vid < VLAN_VID_MASK;
689
690 if (!ret)
691 NL_SET_ERR_MSG_MOD(extack, "Vlan id is invalid");
692
693 return ret;
694}
695
696static inline bool br_vlan_valid_range(const struct bridge_vlan_info *cur,
697 const struct bridge_vlan_info *last,
698 struct netlink_ext_ack *extack)
699{
700 /* pvid flag is not allowed in ranges */
701 if (cur->flags & BRIDGE_VLAN_INFO_PVID) {
702 NL_SET_ERR_MSG_MOD(extack, "Pvid isn't allowed in a range");
703 return false;
704 }
705
706 /* when cur is the range end, check if:
707 * - it has range start flag
708 * - range ids are invalid (end is equal to or before start)
709 */
710 if (last) {
711 if (cur->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) {
712 NL_SET_ERR_MSG_MOD(extack, "Found a new vlan range start while processing one");
713 return false;
714 } else if (!(cur->flags & BRIDGE_VLAN_INFO_RANGE_END)) {
715 NL_SET_ERR_MSG_MOD(extack, "Vlan range end flag is missing");
716 return false;
717 } else if (cur->vid <= last->vid) {
718 NL_SET_ERR_MSG_MOD(extack, "End vlan id is less than or equal to start vlan id");
719 return false;
720 }
721 }
722
723 /* check for required range flags */
724 if (!(cur->flags & (BRIDGE_VLAN_INFO_RANGE_BEGIN |
725 BRIDGE_VLAN_INFO_RANGE_END))) {
726 NL_SET_ERR_MSG_MOD(extack, "Both vlan range flags are missing");
727 return false;
728 }
729
730 return true;
731}
732
733static inline u8 br_vlan_multicast_router(const struct net_bridge_vlan *v)
734{
735 u8 mcast_router = MDB_RTR_TYPE_DISABLED;
736
737#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
738 if (!br_vlan_is_master(v))
739 mcast_router = v->port_mcast_ctx.multicast_router;
740 else
741 mcast_router = v->br_mcast_ctx.multicast_router;
742#endif
743
744 return mcast_router;
745}
746
747static inline int br_afspec_cmd_to_rtm(int cmd)
748{
749 switch (cmd) {
750 case RTM_SETLINK:
751 return RTM_NEWVLAN;
752 case RTM_DELLINK:
753 return RTM_DELVLAN;
754 }
755
756 return 0;
757}
758
759static inline int br_opt_get(const struct net_bridge *br,
760 enum net_bridge_opts opt)
761{
762 return test_bit(opt, &br->options);
763}
764
765int br_boolopt_toggle(struct net_bridge *br, enum br_boolopt_id opt, bool on,
766 struct netlink_ext_ack *extack);
767int br_boolopt_get(const struct net_bridge *br, enum br_boolopt_id opt);
768int br_boolopt_multi_toggle(struct net_bridge *br,
769 struct br_boolopt_multi *bm,
770 struct netlink_ext_ack *extack);
771void br_boolopt_multi_get(const struct net_bridge *br,
772 struct br_boolopt_multi *bm);
773void br_opt_toggle(struct net_bridge *br, enum net_bridge_opts opt, bool on);
774
775#if IS_ENABLED(CONFIG_NET_TC_SKB_EXT)
776static inline void br_tc_skb_miss_set(struct sk_buff *skb, bool miss)
777{
778 struct tc_skb_ext *ext;
779
780 if (!tc_skb_ext_tc_enabled())
781 return;
782
783 ext = skb_ext_find(skb, id: TC_SKB_EXT);
784 if (ext) {
785 ext->l2_miss = miss;
786 return;
787 }
788 if (!miss)
789 return;
790 ext = tc_skb_ext_alloc(skb);
791 if (!ext)
792 return;
793 ext->l2_miss = true;
794}
795#else
796static inline void br_tc_skb_miss_set(struct sk_buff *skb, bool miss)
797{
798}
799#endif
800
801/* br_device.c */
802void br_dev_setup(struct net_device *dev);
803void br_dev_delete(struct net_device *dev, struct list_head *list);
804netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev);
805#ifdef CONFIG_NET_POLL_CONTROLLER
806static inline void br_netpoll_send_skb(const struct net_bridge_port *p,
807 struct sk_buff *skb)
808{
809 netpoll_send_skb(np: p->np, skb);
810}
811
812int br_netpoll_enable(struct net_bridge_port *p);
813void br_netpoll_disable(struct net_bridge_port *p);
814#else
815static inline void br_netpoll_send_skb(const struct net_bridge_port *p,
816 struct sk_buff *skb)
817{
818}
819
820static inline int br_netpoll_enable(struct net_bridge_port *p)
821{
822 return 0;
823}
824
825static inline void br_netpoll_disable(struct net_bridge_port *p)
826{
827}
828#endif
829
830/* br_fdb.c */
831#define FDB_FLUSH_IGNORED_NDM_FLAGS (NTF_MASTER | NTF_SELF)
832#define FDB_FLUSH_ALLOWED_NDM_STATES (NUD_PERMANENT | NUD_NOARP)
833#define FDB_FLUSH_ALLOWED_NDM_FLAGS (NTF_USE | NTF_EXT_LEARNED | \
834 NTF_STICKY | NTF_OFFLOADED)
835
836int br_fdb_init(void);
837void br_fdb_fini(void);
838int br_fdb_hash_init(struct net_bridge *br);
839void br_fdb_hash_fini(struct net_bridge *br);
840void br_fdb_flush(struct net_bridge *br,
841 const struct net_bridge_fdb_flush_desc *desc);
842void br_fdb_find_delete_local(struct net_bridge *br,
843 const struct net_bridge_port *p,
844 const unsigned char *addr, u16 vid);
845void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr);
846void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr);
847void br_fdb_cleanup(struct work_struct *work);
848int br_fdb_toggle_local_vlan_0(struct net_bridge *br, bool on,
849 struct netlink_ext_ack *extack);
850void br_fdb_delete_by_port(struct net_bridge *br,
851 const struct net_bridge_port *p, u16 vid, int do_all);
852struct net_bridge_fdb_entry *br_fdb_find_rcu(struct net_bridge *br,
853 const unsigned char *addr,
854 __u16 vid);
855int br_fdb_test_addr(struct net_device *dev, unsigned char *addr);
856int br_fdb_fillbuf(struct net_bridge *br, void *buf, unsigned long count,
857 unsigned long off);
858int br_fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
859 const unsigned char *addr, u16 vid);
860void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
861 const unsigned char *addr, u16 vid, unsigned long flags);
862
863int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
864 struct net_device *dev, const unsigned char *addr, u16 vid,
865 bool *notified, struct netlink_ext_ack *extack);
866int br_fdb_delete_bulk(struct nlmsghdr *nlh, struct net_device *dev,
867 struct netlink_ext_ack *extack);
868int br_fdb_add(struct ndmsg *nlh, struct nlattr *tb[], struct net_device *dev,
869 const unsigned char *addr, u16 vid, u16 nlh_flags,
870 bool *notified, struct netlink_ext_ack *extack);
871int br_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
872 struct net_device *dev, struct net_device *fdev, int *idx);
873int br_fdb_get(struct sk_buff *skb, struct nlattr *tb[], struct net_device *dev,
874 const unsigned char *addr, u16 vid, u32 portid, u32 seq,
875 struct netlink_ext_ack *extack);
876int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p);
877void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p);
878int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
879 const unsigned char *addr, u16 vid,
880 bool locked, bool swdev_notify);
881int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
882 const unsigned char *addr, u16 vid,
883 bool swdev_notify);
884void br_fdb_offloaded_set(struct net_bridge *br, struct net_bridge_port *p,
885 const unsigned char *addr, u16 vid, bool offloaded);
886
887/* br_forward.c */
888enum br_pkt_type {
889 BR_PKT_UNICAST,
890 BR_PKT_MULTICAST,
891 BR_PKT_BROADCAST
892};
893int br_dev_queue_push_xmit(struct net *net, struct sock *sk, struct sk_buff *skb);
894void br_forward(const struct net_bridge_port *to, struct sk_buff *skb,
895 bool local_rcv, bool local_orig);
896int br_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb);
897void br_flood(struct net_bridge *br, struct sk_buff *skb,
898 enum br_pkt_type pkt_type, bool local_rcv, bool local_orig,
899 u16 vid);
900
901/* return true if both source port and dest port are isolated */
902static inline bool br_skb_isolated(const struct net_bridge_port *to,
903 const struct sk_buff *skb)
904{
905 return BR_INPUT_SKB_CB(skb)->src_port_isolated &&
906 (to->flags & BR_ISOLATED);
907}
908
909/* br_if.c */
910void br_port_carrier_check(struct net_bridge_port *p, bool *notified);
911int br_add_bridge(struct net *net, const char *name);
912int br_del_bridge(struct net *net, const char *name);
913int br_add_if(struct net_bridge *br, struct net_device *dev,
914 struct netlink_ext_ack *extack);
915int br_del_if(struct net_bridge *br, struct net_device *dev);
916void br_mtu_auto_adjust(struct net_bridge *br);
917netdev_features_t br_features_recompute(struct net_bridge *br,
918 netdev_features_t features);
919void br_port_flags_change(struct net_bridge_port *port, unsigned long mask);
920void br_manage_promisc(struct net_bridge *br);
921int nbp_backup_change(struct net_bridge_port *p, struct net_device *backup_dev);
922
923/* br_input.c */
924int br_handle_frame_finish(struct net *net, struct sock *sk, struct sk_buff *skb);
925rx_handler_func_t *br_get_rx_handler(const struct net_device *dev);
926
927struct br_frame_type {
928 __be16 type;
929 int (*frame_handler)(struct net_bridge_port *port,
930 struct sk_buff *skb);
931 struct hlist_node list;
932};
933
934void br_add_frame(struct net_bridge *br, struct br_frame_type *ft);
935void br_del_frame(struct net_bridge *br, struct br_frame_type *ft);
936
937static inline bool br_rx_handler_check_rcu(const struct net_device *dev)
938{
939 return rcu_dereference(dev->rx_handler) == br_get_rx_handler(dev);
940}
941
942static inline bool br_rx_handler_check_rtnl(const struct net_device *dev)
943{
944 return rcu_dereference_rtnl(dev->rx_handler) == br_get_rx_handler(dev);
945}
946
947static inline struct net_bridge_port *br_port_get_check_rcu(const struct net_device *dev)
948{
949 return br_rx_handler_check_rcu(dev) ? br_port_get_rcu(dev) : NULL;
950}
951
952static inline struct net_bridge_port *
953br_port_get_check_rtnl(const struct net_device *dev)
954{
955 return br_rx_handler_check_rtnl(dev) ? br_port_get_rtnl_rcu(dev) : NULL;
956}
957
958/* br_ioctl.c */
959int br_dev_siocdevprivate(struct net_device *dev, struct ifreq *rq,
960 void __user *data, int cmd);
961int br_ioctl_stub(struct net *net, unsigned int cmd, void __user *uarg);
962
963/* br_multicast.c */
964#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
965int br_multicast_rcv(struct net_bridge_mcast **brmctx,
966 struct net_bridge_mcast_port **pmctx,
967 struct net_bridge_vlan *vlan,
968 struct sk_buff *skb, u16 vid);
969struct net_bridge_mdb_entry *
970br_mdb_entry_skb_get(struct net_bridge_mcast *brmctx, struct sk_buff *skb,
971 u16 vid);
972int br_multicast_add_port(struct net_bridge_port *port);
973void br_multicast_del_port(struct net_bridge_port *port);
974void br_multicast_enable_port(struct net_bridge_port *port);
975void br_multicast_disable_port(struct net_bridge_port *port);
976void br_multicast_init(struct net_bridge *br);
977void br_multicast_join_snoopers(struct net_bridge *br);
978void br_multicast_leave_snoopers(struct net_bridge *br);
979void br_multicast_open(struct net_bridge *br);
980void br_multicast_stop(struct net_bridge *br);
981void br_multicast_dev_del(struct net_bridge *br);
982void br_multicast_flood(struct net_bridge_mdb_entry *mdst, struct sk_buff *skb,
983 struct net_bridge_mcast *brmctx,
984 bool local_rcv, bool local_orig);
985int br_multicast_set_router(struct net_bridge_mcast *brmctx, unsigned long val);
986int br_multicast_set_port_router(struct net_bridge_mcast_port *pmctx,
987 unsigned long val);
988int br_multicast_set_vlan_router(struct net_bridge_vlan *v, u8 mcast_router);
989int br_multicast_toggle(struct net_bridge *br, unsigned long val,
990 struct netlink_ext_ack *extack);
991int br_multicast_set_querier(struct net_bridge_mcast *brmctx, unsigned long val);
992int br_multicast_set_igmp_version(struct net_bridge_mcast *brmctx,
993 unsigned long val);
994#if IS_ENABLED(CONFIG_IPV6)
995int br_multicast_set_mld_version(struct net_bridge_mcast *brmctx,
996 unsigned long val);
997#endif
998struct net_bridge_mdb_entry *
999br_mdb_ip_get(struct net_bridge *br, struct br_ip *dst);
1000struct net_bridge_mdb_entry *
1001br_multicast_new_group(struct net_bridge *br, struct br_ip *group);
1002struct net_bridge_port_group *
1003br_multicast_new_port_group(struct net_bridge_port *port,
1004 const struct br_ip *group,
1005 struct net_bridge_port_group __rcu *next,
1006 unsigned char flags, const unsigned char *src,
1007 u8 filter_mode, u8 rt_protocol,
1008 struct netlink_ext_ack *extack);
1009void br_multicast_del_port_group(struct net_bridge_port_group *p);
1010int br_mdb_hash_init(struct net_bridge *br);
1011void br_mdb_hash_fini(struct net_bridge *br);
1012void br_mdb_notify(struct net_device *dev, struct net_bridge_mdb_entry *mp,
1013 struct net_bridge_port_group *pg, int type);
1014void br_mdb_flag_change_notify(struct net_device *dev, struct net_bridge_mdb_entry *mp,
1015 struct net_bridge_port_group *pg);
1016void br_rtr_notify(struct net_device *dev, struct net_bridge_mcast_port *pmctx,
1017 int type);
1018void br_multicast_del_pg(struct net_bridge_mdb_entry *mp,
1019 struct net_bridge_port_group *pg,
1020 struct net_bridge_port_group __rcu **pp);
1021void br_multicast_count(struct net_bridge *br,
1022 const struct net_bridge_port *p,
1023 const struct sk_buff *skb, u8 type, u8 dir);
1024int br_multicast_init_stats(struct net_bridge *br);
1025void br_multicast_uninit_stats(struct net_bridge *br);
1026void br_multicast_get_stats(const struct net_bridge *br,
1027 const struct net_bridge_port *p,
1028 struct br_mcast_stats *dest);
1029u32 br_multicast_ngroups_get(const struct net_bridge_mcast_port *pmctx);
1030void br_multicast_ngroups_set_max(struct net_bridge_mcast_port *pmctx, u32 max);
1031u32 br_multicast_ngroups_get_max(const struct net_bridge_mcast_port *pmctx);
1032int br_mdb_add(struct net_device *dev, struct nlattr *tb[], u16 nlmsg_flags,
1033 struct netlink_ext_ack *extack);
1034int br_mdb_del(struct net_device *dev, struct nlattr *tb[],
1035 struct netlink_ext_ack *extack);
1036int br_mdb_del_bulk(struct net_device *dev, struct nlattr *tb[],
1037 struct netlink_ext_ack *extack);
1038int br_mdb_dump(struct net_device *dev, struct sk_buff *skb,
1039 struct netlink_callback *cb);
1040int br_mdb_get(struct net_device *dev, struct nlattr *tb[], u32 portid, u32 seq,
1041 struct netlink_ext_ack *extack);
1042void br_multicast_host_join(const struct net_bridge_mcast *brmctx,
1043 struct net_bridge_mdb_entry *mp, bool notify);
1044void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify);
1045void br_multicast_star_g_handle_mode(struct net_bridge_port_group *pg,
1046 u8 filter_mode);
1047void br_multicast_sg_add_exclude_ports(struct net_bridge_mdb_entry *star_mp,
1048 struct net_bridge_port_group *sg);
1049struct net_bridge_group_src *
1050br_multicast_find_group_src(struct net_bridge_port_group *pg, struct br_ip *ip);
1051struct net_bridge_group_src *
1052br_multicast_new_group_src(struct net_bridge_port_group *pg,
1053 struct br_ip *src_ip);
1054void __br_multicast_del_group_src(struct net_bridge_group_src *src);
1055void br_multicast_del_group_src(struct net_bridge_group_src *src,
1056 bool fastleave);
1057void br_multicast_ctx_init(struct net_bridge *br,
1058 struct net_bridge_vlan *vlan,
1059 struct net_bridge_mcast *brmctx);
1060void br_multicast_ctx_deinit(struct net_bridge_mcast *brmctx);
1061void br_multicast_port_ctx_init(struct net_bridge_port *port,
1062 struct net_bridge_vlan *vlan,
1063 struct net_bridge_mcast_port *pmctx);
1064void br_multicast_port_ctx_deinit(struct net_bridge_mcast_port *pmctx);
1065void br_multicast_update_vlan_mcast_ctx(struct net_bridge_vlan *v, u8 state);
1066void br_multicast_toggle_one_vlan(struct net_bridge_vlan *vlan, bool on);
1067int br_multicast_toggle_vlan_snooping(struct net_bridge *br, bool on,
1068 struct netlink_ext_ack *extack);
1069bool br_multicast_toggle_global_vlan(struct net_bridge_vlan *vlan, bool on);
1070
1071int br_rports_fill_info(struct sk_buff *skb,
1072 const struct net_bridge_mcast *brmctx);
1073int br_multicast_dump_querier_state(struct sk_buff *skb,
1074 const struct net_bridge_mcast *brmctx,
1075 int nest_attr);
1076size_t br_multicast_querier_state_size(void);
1077size_t br_rports_size(const struct net_bridge_mcast *brmctx);
1078void br_multicast_set_query_intvl(struct net_bridge_mcast *brmctx,
1079 unsigned long val);
1080void br_multicast_set_startup_query_intvl(struct net_bridge_mcast *brmctx,
1081 unsigned long val);
1082
1083static inline bool br_group_is_l2(const struct br_ip *group)
1084{
1085 return group->proto == 0;
1086}
1087
1088#define mlock_dereference(X, br) \
1089 rcu_dereference_protected(X, lockdep_is_held(&br->multicast_lock))
1090
1091static inline struct hlist_node *
1092br_multicast_get_first_rport_node(struct net_bridge_mcast *brmctx,
1093 struct sk_buff *skb)
1094{
1095#if IS_ENABLED(CONFIG_IPV6)
1096 if (skb->protocol == htons(ETH_P_IPV6))
1097 return rcu_dereference(hlist_first_rcu(&brmctx->ip6_mc_router_list));
1098#endif
1099 return rcu_dereference(hlist_first_rcu(&brmctx->ip4_mc_router_list));
1100}
1101
1102static inline struct net_bridge_port *
1103br_multicast_rport_from_node_skb(struct hlist_node *rp, struct sk_buff *skb)
1104{
1105 struct net_bridge_mcast_port *mctx;
1106
1107#if IS_ENABLED(CONFIG_IPV6)
1108 if (skb->protocol == htons(ETH_P_IPV6))
1109 mctx = hlist_entry_safe(rp, struct net_bridge_mcast_port,
1110 ip6_rlist);
1111 else
1112#endif
1113 mctx = hlist_entry_safe(rp, struct net_bridge_mcast_port,
1114 ip4_rlist);
1115
1116 if (mctx)
1117 return mctx->port;
1118 else
1119 return NULL;
1120}
1121
1122static inline bool br_ip4_multicast_is_router(struct net_bridge_mcast *brmctx)
1123{
1124 return timer_pending(timer: &brmctx->ip4_mc_router_timer);
1125}
1126
1127static inline bool br_ip6_multicast_is_router(struct net_bridge_mcast *brmctx)
1128{
1129#if IS_ENABLED(CONFIG_IPV6)
1130 return timer_pending(timer: &brmctx->ip6_mc_router_timer);
1131#else
1132 return false;
1133#endif
1134}
1135
1136static inline bool
1137br_multicast_is_router(struct net_bridge_mcast *brmctx, struct sk_buff *skb)
1138{
1139 switch (brmctx->multicast_router) {
1140 case MDB_RTR_TYPE_PERM:
1141 return true;
1142 case MDB_RTR_TYPE_TEMP_QUERY:
1143 if (skb) {
1144 if (skb->protocol == htons(ETH_P_IP))
1145 return br_ip4_multicast_is_router(brmctx);
1146 else if (skb->protocol == htons(ETH_P_IPV6))
1147 return br_ip6_multicast_is_router(brmctx);
1148 } else {
1149 return br_ip4_multicast_is_router(brmctx) ||
1150 br_ip6_multicast_is_router(brmctx);
1151 }
1152 fallthrough;
1153 default:
1154 return false;
1155 }
1156}
1157
1158static inline bool
1159__br_multicast_querier_exists(struct net_bridge_mcast *brmctx,
1160 struct bridge_mcast_other_query *querier,
1161 const bool is_ipv6)
1162{
1163 bool own_querier_enabled;
1164
1165 if (brmctx->multicast_querier) {
1166 if (is_ipv6 && !br_opt_get(br: brmctx->br, opt: BROPT_HAS_IPV6_ADDR))
1167 own_querier_enabled = false;
1168 else
1169 own_querier_enabled = true;
1170 } else {
1171 own_querier_enabled = false;
1172 }
1173
1174 return !timer_pending(timer: &querier->delay_timer) &&
1175 (own_querier_enabled || timer_pending(timer: &querier->timer));
1176}
1177
1178static inline bool br_multicast_querier_exists(struct net_bridge_mcast *brmctx,
1179 struct ethhdr *eth,
1180 const struct net_bridge_mdb_entry *mdb)
1181{
1182 switch (eth->h_proto) {
1183 case (htons(ETH_P_IP)):
1184 return __br_multicast_querier_exists(brmctx,
1185 querier: &brmctx->ip4_other_query, is_ipv6: false);
1186#if IS_ENABLED(CONFIG_IPV6)
1187 case (htons(ETH_P_IPV6)):
1188 return __br_multicast_querier_exists(brmctx,
1189 querier: &brmctx->ip6_other_query, is_ipv6: true);
1190#endif
1191 default:
1192 return !!mdb && br_group_is_l2(group: &mdb->addr);
1193 }
1194}
1195
1196static inline bool br_multicast_is_star_g(const struct br_ip *ip)
1197{
1198 switch (ip->proto) {
1199 case htons(ETH_P_IP):
1200 return ipv4_is_zeronet(addr: ip->src.ip4);
1201#if IS_ENABLED(CONFIG_IPV6)
1202 case htons(ETH_P_IPV6):
1203 return ipv6_addr_any(a: &ip->src.ip6);
1204#endif
1205 default:
1206 return false;
1207 }
1208}
1209
1210static inline bool
1211br_multicast_should_handle_mode(const struct net_bridge_mcast *brmctx,
1212 __be16 proto)
1213{
1214 switch (proto) {
1215 case htons(ETH_P_IP):
1216 return !!(brmctx->multicast_igmp_version == 3);
1217#if IS_ENABLED(CONFIG_IPV6)
1218 case htons(ETH_P_IPV6):
1219 return !!(brmctx->multicast_mld_version == 2);
1220#endif
1221 default:
1222 return false;
1223 }
1224}
1225
1226static inline int br_multicast_igmp_type(const struct sk_buff *skb)
1227{
1228 return BR_INPUT_SKB_CB(skb)->igmp;
1229}
1230
1231static inline unsigned long br_multicast_lmqt(const struct net_bridge_mcast *brmctx)
1232{
1233 return brmctx->multicast_last_member_interval *
1234 brmctx->multicast_last_member_count;
1235}
1236
1237static inline unsigned long br_multicast_gmi(const struct net_bridge_mcast *brmctx)
1238{
1239 return brmctx->multicast_membership_interval;
1240}
1241
1242static inline bool
1243br_multicast_ctx_is_vlan(const struct net_bridge_mcast *brmctx)
1244{
1245 return !!brmctx->vlan;
1246}
1247
1248static inline bool
1249br_multicast_port_ctx_is_vlan(const struct net_bridge_mcast_port *pmctx)
1250{
1251 return !!pmctx->vlan;
1252}
1253
1254static inline struct net_bridge_mcast *
1255br_multicast_port_ctx_get_global(const struct net_bridge_mcast_port *pmctx)
1256{
1257 if (!br_multicast_port_ctx_is_vlan(pmctx))
1258 return &pmctx->port->br->multicast_ctx;
1259 else
1260 return &pmctx->vlan->brvlan->br_mcast_ctx;
1261}
1262
1263static inline bool
1264br_multicast_ctx_vlan_global_disabled(const struct net_bridge_mcast *brmctx)
1265{
1266 return br_multicast_ctx_is_vlan(brmctx) &&
1267 (!br_opt_get(br: brmctx->br, opt: BROPT_MCAST_VLAN_SNOOPING_ENABLED) ||
1268 !(brmctx->vlan->priv_flags & BR_VLFLAG_GLOBAL_MCAST_ENABLED));
1269}
1270
1271static inline bool
1272br_multicast_ctx_vlan_disabled(const struct net_bridge_mcast *brmctx)
1273{
1274 return br_multicast_ctx_is_vlan(brmctx) &&
1275 !(brmctx->vlan->priv_flags & BR_VLFLAG_MCAST_ENABLED);
1276}
1277
1278static inline bool
1279br_multicast_port_ctx_vlan_disabled(const struct net_bridge_mcast_port *pmctx)
1280{
1281 return br_multicast_port_ctx_is_vlan(pmctx) &&
1282 !(pmctx->vlan->priv_flags & BR_VLFLAG_MCAST_ENABLED);
1283}
1284
1285static inline bool
1286br_multicast_port_ctx_state_disabled(const struct net_bridge_mcast_port *pmctx)
1287{
1288 return pmctx->port->state == BR_STATE_DISABLED ||
1289 (br_multicast_port_ctx_is_vlan(pmctx) &&
1290 (br_multicast_port_ctx_vlan_disabled(pmctx) ||
1291 pmctx->vlan->state == BR_STATE_DISABLED));
1292}
1293
1294static inline bool
1295br_multicast_port_ctx_state_stopped(const struct net_bridge_mcast_port *pmctx)
1296{
1297 return br_multicast_port_ctx_state_disabled(pmctx) ||
1298 pmctx->port->state == BR_STATE_BLOCKING ||
1299 (br_multicast_port_ctx_is_vlan(pmctx) &&
1300 pmctx->vlan->state == BR_STATE_BLOCKING);
1301}
1302
1303static inline bool
1304br_rports_have_mc_router(const struct net_bridge_mcast *brmctx)
1305{
1306#if IS_ENABLED(CONFIG_IPV6)
1307 return !hlist_empty(h: &brmctx->ip4_mc_router_list) ||
1308 !hlist_empty(h: &brmctx->ip6_mc_router_list);
1309#else
1310 return !hlist_empty(&brmctx->ip4_mc_router_list);
1311#endif
1312}
1313
1314static inline bool
1315br_multicast_ctx_options_equal(const struct net_bridge_mcast *brmctx1,
1316 const struct net_bridge_mcast *brmctx2)
1317{
1318 return brmctx1->multicast_igmp_version ==
1319 brmctx2->multicast_igmp_version &&
1320 brmctx1->multicast_last_member_count ==
1321 brmctx2->multicast_last_member_count &&
1322 brmctx1->multicast_startup_query_count ==
1323 brmctx2->multicast_startup_query_count &&
1324 brmctx1->multicast_last_member_interval ==
1325 brmctx2->multicast_last_member_interval &&
1326 brmctx1->multicast_membership_interval ==
1327 brmctx2->multicast_membership_interval &&
1328 brmctx1->multicast_querier_interval ==
1329 brmctx2->multicast_querier_interval &&
1330 brmctx1->multicast_query_interval ==
1331 brmctx2->multicast_query_interval &&
1332 brmctx1->multicast_query_response_interval ==
1333 brmctx2->multicast_query_response_interval &&
1334 brmctx1->multicast_startup_query_interval ==
1335 brmctx2->multicast_startup_query_interval &&
1336 brmctx1->multicast_querier == brmctx2->multicast_querier &&
1337 brmctx1->multicast_router == brmctx2->multicast_router &&
1338 !br_rports_have_mc_router(brmctx: brmctx1) &&
1339 !br_rports_have_mc_router(brmctx: brmctx2) &&
1340#if IS_ENABLED(CONFIG_IPV6)
1341 brmctx1->multicast_mld_version ==
1342 brmctx2->multicast_mld_version &&
1343#endif
1344 true;
1345}
1346
1347static inline bool
1348br_multicast_ctx_matches_vlan_snooping(const struct net_bridge_mcast *brmctx)
1349{
1350 bool vlan_snooping_enabled;
1351
1352 vlan_snooping_enabled = !!br_opt_get(br: brmctx->br,
1353 opt: BROPT_MCAST_VLAN_SNOOPING_ENABLED);
1354
1355 return !!(vlan_snooping_enabled == br_multicast_ctx_is_vlan(brmctx));
1356}
1357
1358static inline void
1359br_multicast_set_pg_offload_flags(struct net_bridge_port_group *p,
1360 bool offloaded)
1361{
1362 p->flags &= ~(MDB_PG_FLAGS_OFFLOAD | MDB_PG_FLAGS_OFFLOAD_FAILED);
1363 p->flags |= (offloaded ? MDB_PG_FLAGS_OFFLOAD :
1364 MDB_PG_FLAGS_OFFLOAD_FAILED);
1365}
1366
1367static inline bool
1368br_mdb_should_notify(const struct net_bridge *br, u8 changed_flags)
1369{
1370 return br_opt_get(br, opt: BROPT_MDB_OFFLOAD_FAIL_NOTIFICATION) &&
1371 (changed_flags & MDB_PG_FLAGS_OFFLOAD_FAILED);
1372}
1373#else
1374static inline int br_multicast_rcv(struct net_bridge_mcast **brmctx,
1375 struct net_bridge_mcast_port **pmctx,
1376 struct net_bridge_vlan *vlan,
1377 struct sk_buff *skb,
1378 u16 vid)
1379{
1380 return 0;
1381}
1382
1383static inline struct net_bridge_mdb_entry *
1384br_mdb_entry_skb_get(struct net_bridge_mcast *brmctx, struct sk_buff *skb,
1385 u16 vid)
1386{
1387 return NULL;
1388}
1389
1390static inline int br_multicast_add_port(struct net_bridge_port *port)
1391{
1392 return 0;
1393}
1394
1395static inline void br_multicast_del_port(struct net_bridge_port *port)
1396{
1397}
1398
1399static inline void br_multicast_enable_port(struct net_bridge_port *port)
1400{
1401}
1402
1403static inline void br_multicast_disable_port(struct net_bridge_port *port)
1404{
1405}
1406
1407static inline void br_multicast_init(struct net_bridge *br)
1408{
1409}
1410
1411static inline void br_multicast_join_snoopers(struct net_bridge *br)
1412{
1413}
1414
1415static inline void br_multicast_leave_snoopers(struct net_bridge *br)
1416{
1417}
1418
1419static inline void br_multicast_open(struct net_bridge *br)
1420{
1421}
1422
1423static inline void br_multicast_stop(struct net_bridge *br)
1424{
1425}
1426
1427static inline void br_multicast_dev_del(struct net_bridge *br)
1428{
1429}
1430
1431static inline void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
1432 struct sk_buff *skb,
1433 struct net_bridge_mcast *brmctx,
1434 bool local_rcv, bool local_orig)
1435{
1436}
1437
1438static inline bool br_multicast_is_router(struct net_bridge_mcast *brmctx,
1439 struct sk_buff *skb)
1440{
1441 return false;
1442}
1443
1444static inline bool br_multicast_querier_exists(struct net_bridge_mcast *brmctx,
1445 struct ethhdr *eth,
1446 const struct net_bridge_mdb_entry *mdb)
1447{
1448 return false;
1449}
1450
1451static inline int br_mdb_add(struct net_device *dev, struct nlattr *tb[],
1452 u16 nlmsg_flags, struct netlink_ext_ack *extack)
1453{
1454 return -EOPNOTSUPP;
1455}
1456
1457static inline int br_mdb_del(struct net_device *dev, struct nlattr *tb[],
1458 struct netlink_ext_ack *extack)
1459{
1460 return -EOPNOTSUPP;
1461}
1462
1463static inline int br_mdb_del_bulk(struct net_device *dev, struct nlattr *tb[],
1464 struct netlink_ext_ack *extack)
1465{
1466 return -EOPNOTSUPP;
1467}
1468
1469static inline int br_mdb_dump(struct net_device *dev, struct sk_buff *skb,
1470 struct netlink_callback *cb)
1471{
1472 return 0;
1473}
1474
1475static inline int br_mdb_get(struct net_device *dev, struct nlattr *tb[],
1476 u32 portid, u32 seq,
1477 struct netlink_ext_ack *extack)
1478{
1479 return -EOPNOTSUPP;
1480}
1481
1482static inline int br_mdb_hash_init(struct net_bridge *br)
1483{
1484 return 0;
1485}
1486
1487static inline void br_mdb_hash_fini(struct net_bridge *br)
1488{
1489}
1490
1491static inline void br_multicast_count(struct net_bridge *br,
1492 const struct net_bridge_port *p,
1493 const struct sk_buff *skb,
1494 u8 type, u8 dir)
1495{
1496}
1497
1498static inline int br_multicast_init_stats(struct net_bridge *br)
1499{
1500 return 0;
1501}
1502
1503static inline void br_multicast_uninit_stats(struct net_bridge *br)
1504{
1505}
1506
1507static inline int br_multicast_igmp_type(const struct sk_buff *skb)
1508{
1509 return 0;
1510}
1511
1512static inline void br_multicast_ctx_init(struct net_bridge *br,
1513 struct net_bridge_vlan *vlan,
1514 struct net_bridge_mcast *brmctx)
1515{
1516}
1517
1518static inline void br_multicast_ctx_deinit(struct net_bridge_mcast *brmctx)
1519{
1520}
1521
1522static inline void br_multicast_port_ctx_init(struct net_bridge_port *port,
1523 struct net_bridge_vlan *vlan,
1524 struct net_bridge_mcast_port *pmctx)
1525{
1526}
1527
1528static inline void br_multicast_port_ctx_deinit(struct net_bridge_mcast_port *pmctx)
1529{
1530}
1531
1532static inline void br_multicast_update_vlan_mcast_ctx(struct net_bridge_vlan *v,
1533 u8 state)
1534{
1535}
1536
1537static inline void br_multicast_toggle_one_vlan(struct net_bridge_vlan *vlan,
1538 bool on)
1539{
1540}
1541
1542static inline int br_multicast_toggle_vlan_snooping(struct net_bridge *br,
1543 bool on,
1544 struct netlink_ext_ack *extack)
1545{
1546 return -EOPNOTSUPP;
1547}
1548
1549static inline bool br_multicast_toggle_global_vlan(struct net_bridge_vlan *vlan,
1550 bool on)
1551{
1552 return false;
1553}
1554
1555static inline bool
1556br_multicast_ctx_options_equal(const struct net_bridge_mcast *brmctx1,
1557 const struct net_bridge_mcast *brmctx2)
1558{
1559 return true;
1560}
1561#endif
1562
1563/* br_vlan.c */
1564#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1565bool br_allowed_ingress(const struct net_bridge *br,
1566 struct net_bridge_vlan_group *vg, struct sk_buff *skb,
1567 u16 *vid, u8 *state,
1568 struct net_bridge_vlan **vlan);
1569bool br_allowed_egress(struct net_bridge_vlan_group *vg,
1570 const struct sk_buff *skb);
1571bool br_should_learn(struct net_bridge_port *p, struct sk_buff *skb, u16 *vid);
1572struct sk_buff *br_handle_vlan(struct net_bridge *br,
1573 const struct net_bridge_port *port,
1574 struct net_bridge_vlan_group *vg,
1575 struct sk_buff *skb);
1576int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags,
1577 bool *changed, struct netlink_ext_ack *extack);
1578int br_vlan_delete(struct net_bridge *br, u16 vid);
1579void br_vlan_flush(struct net_bridge *br);
1580struct net_bridge_vlan *br_vlan_find(struct net_bridge_vlan_group *vg, u16 vid);
1581void br_recalculate_fwd_mask(struct net_bridge *br);
1582int br_vlan_filter_toggle(struct net_bridge *br, unsigned long val,
1583 struct netlink_ext_ack *extack);
1584int __br_vlan_set_proto(struct net_bridge *br, __be16 proto,
1585 struct netlink_ext_ack *extack);
1586int br_vlan_set_proto(struct net_bridge *br, unsigned long val,
1587 struct netlink_ext_ack *extack);
1588int br_vlan_set_stats(struct net_bridge *br, unsigned long val);
1589int br_vlan_set_stats_per_port(struct net_bridge *br, unsigned long val);
1590int br_vlan_init(struct net_bridge *br);
1591int br_vlan_set_default_pvid(struct net_bridge *br, unsigned long val,
1592 struct netlink_ext_ack *extack);
1593int __br_vlan_set_default_pvid(struct net_bridge *br, u16 pvid,
1594 struct netlink_ext_ack *extack);
1595int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags,
1596 bool *changed, struct netlink_ext_ack *extack);
1597int nbp_vlan_delete(struct net_bridge_port *port, u16 vid);
1598void nbp_vlan_flush(struct net_bridge_port *port);
1599int nbp_vlan_init(struct net_bridge_port *port, struct netlink_ext_ack *extack);
1600int nbp_get_num_vlan_infos(struct net_bridge_port *p, u32 filter_mask);
1601void br_vlan_get_stats(const struct net_bridge_vlan *v,
1602 struct pcpu_sw_netstats *stats);
1603void br_vlan_port_event(struct net_bridge_port *p, unsigned long event);
1604int br_vlan_bridge_event(struct net_device *dev, unsigned long event,
1605 void *ptr);
1606void br_vlan_vlan_upper_event(struct net_device *br_dev,
1607 struct net_device *vlan_dev,
1608 unsigned long event);
1609int br_vlan_rtnl_init(void);
1610void br_vlan_rtnl_uninit(void);
1611void br_vlan_notify(const struct net_bridge *br,
1612 const struct net_bridge_port *p,
1613 u16 vid, u16 vid_range,
1614 int cmd);
1615bool br_vlan_can_enter_range(const struct net_bridge_vlan *v_curr,
1616 const struct net_bridge_vlan *range_end);
1617
1618void br_vlan_fill_forward_path_pvid(struct net_bridge *br,
1619 struct net_device_path_ctx *ctx,
1620 struct net_device_path *path);
1621int br_vlan_fill_forward_path_mode(struct net_bridge *br,
1622 struct net_bridge_port *dst,
1623 struct net_device_path *path);
1624
1625static inline struct net_bridge_vlan_group *br_vlan_group(
1626 const struct net_bridge *br)
1627{
1628 return rtnl_dereference(br->vlgrp);
1629}
1630
1631static inline struct net_bridge_vlan_group *nbp_vlan_group(
1632 const struct net_bridge_port *p)
1633{
1634 return rtnl_dereference(p->vlgrp);
1635}
1636
1637static inline struct net_bridge_vlan_group *br_vlan_group_rcu(
1638 const struct net_bridge *br)
1639{
1640 return rcu_dereference(br->vlgrp);
1641}
1642
1643static inline struct net_bridge_vlan_group *nbp_vlan_group_rcu(
1644 const struct net_bridge_port *p)
1645{
1646 return rcu_dereference(p->vlgrp);
1647}
1648
1649/* Since bridge now depends on 8021Q module, but the time bridge sees the
1650 * skb, the vlan tag will always be present if the frame was tagged.
1651 */
1652static inline int br_vlan_get_tag(const struct sk_buff *skb, u16 *vid)
1653{
1654 int err = 0;
1655
1656 if (skb_vlan_tag_present(skb)) {
1657 *vid = skb_vlan_tag_get_id(skb);
1658 } else {
1659 *vid = 0;
1660 err = -EINVAL;
1661 }
1662
1663 return err;
1664}
1665
1666static inline u16 br_get_pvid(const struct net_bridge_vlan_group *vg)
1667{
1668 if (!vg)
1669 return 0;
1670
1671 smp_rmb();
1672 return vg->pvid;
1673}
1674
1675static inline u16 br_vlan_flags(const struct net_bridge_vlan *v, u16 pvid)
1676{
1677 return v->vid == pvid ? v->flags | BRIDGE_VLAN_INFO_PVID : v->flags;
1678}
1679#else
1680static inline bool br_allowed_ingress(const struct net_bridge *br,
1681 struct net_bridge_vlan_group *vg,
1682 struct sk_buff *skb,
1683 u16 *vid, u8 *state,
1684 struct net_bridge_vlan **vlan)
1685
1686{
1687 *vlan = NULL;
1688 return true;
1689}
1690
1691static inline bool br_allowed_egress(struct net_bridge_vlan_group *vg,
1692 const struct sk_buff *skb)
1693{
1694 return true;
1695}
1696
1697static inline bool br_should_learn(struct net_bridge_port *p,
1698 struct sk_buff *skb, u16 *vid)
1699{
1700 return true;
1701}
1702
1703static inline struct sk_buff *br_handle_vlan(struct net_bridge *br,
1704 const struct net_bridge_port *port,
1705 struct net_bridge_vlan_group *vg,
1706 struct sk_buff *skb)
1707{
1708 return skb;
1709}
1710
1711static inline int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags,
1712 bool *changed, struct netlink_ext_ack *extack)
1713{
1714 *changed = false;
1715 return -EOPNOTSUPP;
1716}
1717
1718static inline int br_vlan_delete(struct net_bridge *br, u16 vid)
1719{
1720 return -EOPNOTSUPP;
1721}
1722
1723static inline void br_vlan_flush(struct net_bridge *br)
1724{
1725}
1726
1727static inline void br_recalculate_fwd_mask(struct net_bridge *br)
1728{
1729}
1730
1731static inline int br_vlan_init(struct net_bridge *br)
1732{
1733 return 0;
1734}
1735
1736static inline int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags,
1737 bool *changed, struct netlink_ext_ack *extack)
1738{
1739 *changed = false;
1740 return -EOPNOTSUPP;
1741}
1742
1743static inline int nbp_vlan_delete(struct net_bridge_port *port, u16 vid)
1744{
1745 return -EOPNOTSUPP;
1746}
1747
1748static inline void nbp_vlan_flush(struct net_bridge_port *port)
1749{
1750}
1751
1752static inline struct net_bridge_vlan *br_vlan_find(struct net_bridge_vlan_group *vg,
1753 u16 vid)
1754{
1755 return NULL;
1756}
1757
1758static inline int nbp_vlan_init(struct net_bridge_port *port,
1759 struct netlink_ext_ack *extack)
1760{
1761 return 0;
1762}
1763
1764static inline u16 br_vlan_get_tag(const struct sk_buff *skb, u16 *tag)
1765{
1766 return 0;
1767}
1768
1769static inline u16 br_get_pvid(const struct net_bridge_vlan_group *vg)
1770{
1771 return 0;
1772}
1773
1774static inline int br_vlan_filter_toggle(struct net_bridge *br,
1775 unsigned long val,
1776 struct netlink_ext_ack *extack)
1777{
1778 return -EOPNOTSUPP;
1779}
1780
1781static inline int nbp_get_num_vlan_infos(struct net_bridge_port *p,
1782 u32 filter_mask)
1783{
1784 return 0;
1785}
1786
1787static inline void br_vlan_fill_forward_path_pvid(struct net_bridge *br,
1788 struct net_device_path_ctx *ctx,
1789 struct net_device_path *path)
1790{
1791}
1792
1793static inline int br_vlan_fill_forward_path_mode(struct net_bridge *br,
1794 struct net_bridge_port *dst,
1795 struct net_device_path *path)
1796{
1797 return 0;
1798}
1799
1800static inline struct net_bridge_vlan_group *br_vlan_group(
1801 const struct net_bridge *br)
1802{
1803 return NULL;
1804}
1805
1806static inline struct net_bridge_vlan_group *nbp_vlan_group(
1807 const struct net_bridge_port *p)
1808{
1809 return NULL;
1810}
1811
1812static inline struct net_bridge_vlan_group *br_vlan_group_rcu(
1813 const struct net_bridge *br)
1814{
1815 return NULL;
1816}
1817
1818static inline struct net_bridge_vlan_group *nbp_vlan_group_rcu(
1819 const struct net_bridge_port *p)
1820{
1821 return NULL;
1822}
1823
1824static inline void br_vlan_get_stats(const struct net_bridge_vlan *v,
1825 struct pcpu_sw_netstats *stats)
1826{
1827}
1828
1829static inline void br_vlan_port_event(struct net_bridge_port *p,
1830 unsigned long event)
1831{
1832}
1833
1834static inline int br_vlan_bridge_event(struct net_device *dev,
1835 unsigned long event, void *ptr)
1836{
1837 return 0;
1838}
1839
1840static inline void br_vlan_vlan_upper_event(struct net_device *br_dev,
1841 struct net_device *vlan_dev,
1842 unsigned long event)
1843{
1844}
1845
1846static inline int br_vlan_rtnl_init(void)
1847{
1848 return 0;
1849}
1850
1851static inline void br_vlan_rtnl_uninit(void)
1852{
1853}
1854
1855static inline void br_vlan_notify(const struct net_bridge *br,
1856 const struct net_bridge_port *p,
1857 u16 vid, u16 vid_range,
1858 int cmd)
1859{
1860}
1861
1862static inline bool br_vlan_can_enter_range(const struct net_bridge_vlan *v_curr,
1863 const struct net_bridge_vlan *range_end)
1864{
1865 return true;
1866}
1867
1868static inline u16 br_vlan_flags(const struct net_bridge_vlan *v, u16 pvid)
1869{
1870 return 0;
1871}
1872
1873#endif
1874
1875/* br_vlan_options.c */
1876#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1877bool br_vlan_opts_eq_range(const struct net_bridge_vlan *v_curr,
1878 const struct net_bridge_vlan *range_end);
1879bool br_vlan_opts_fill(struct sk_buff *skb, const struct net_bridge_vlan *v,
1880 const struct net_bridge_port *p);
1881size_t br_vlan_opts_nl_size(void);
1882int br_vlan_process_options(const struct net_bridge *br,
1883 const struct net_bridge_port *p,
1884 struct net_bridge_vlan *range_start,
1885 struct net_bridge_vlan *range_end,
1886 struct nlattr **tb,
1887 struct netlink_ext_ack *extack);
1888int br_vlan_rtm_process_global_options(struct net_device *dev,
1889 const struct nlattr *attr,
1890 int cmd,
1891 struct netlink_ext_ack *extack);
1892bool br_vlan_global_opts_can_enter_range(const struct net_bridge_vlan *v_curr,
1893 const struct net_bridge_vlan *r_end);
1894bool br_vlan_global_opts_fill(struct sk_buff *skb, u16 vid, u16 vid_range,
1895 const struct net_bridge_vlan *v_opts);
1896
1897/* vlan state manipulation helpers using *_ONCE to annotate lock-free access,
1898 * while br_vlan_set_state() may access data protected by multicast_lock.
1899 */
1900static inline u8 br_vlan_get_state(const struct net_bridge_vlan *v)
1901{
1902 return READ_ONCE(v->state);
1903}
1904
1905static inline void br_vlan_set_state(struct net_bridge_vlan *v, u8 state)
1906{
1907 WRITE_ONCE(v->state, state);
1908 br_multicast_update_vlan_mcast_ctx(v, state);
1909}
1910
1911static inline u8 br_vlan_get_pvid_state(const struct net_bridge_vlan_group *vg)
1912{
1913 return READ_ONCE(vg->pvid_state);
1914}
1915
1916static inline void br_vlan_set_pvid_state(struct net_bridge_vlan_group *vg,
1917 u8 state)
1918{
1919 WRITE_ONCE(vg->pvid_state, state);
1920}
1921
1922/* learn_allow is true at ingress and false at egress */
1923static inline bool br_vlan_state_allowed(u8 state, bool learn_allow)
1924{
1925 switch (state) {
1926 case BR_STATE_LEARNING:
1927 return learn_allow;
1928 case BR_STATE_FORWARDING:
1929 return true;
1930 default:
1931 return false;
1932 }
1933}
1934#endif
1935
1936/* br_mst.c */
1937#ifdef CONFIG_BRIDGE_VLAN_FILTERING
1938DECLARE_STATIC_KEY_FALSE(br_mst_used);
1939static inline bool br_mst_is_enabled(const struct net_bridge_port *p)
1940{
1941 /* check the port's vlan group to avoid racing with port deletion */
1942 return static_branch_unlikely(&br_mst_used) &&
1943 br_opt_get(br: p->br, opt: BROPT_MST_ENABLED) &&
1944 rcu_access_pointer(p->vlgrp);
1945}
1946
1947int br_mst_set_state(struct net_bridge_port *p, u16 msti, u8 state,
1948 struct netlink_ext_ack *extack);
1949int br_mst_vlan_set_msti(struct net_bridge_vlan *v, u16 msti);
1950void br_mst_vlan_init_state(struct net_bridge_vlan *v);
1951int br_mst_set_enabled(struct net_bridge *br, bool on,
1952 struct netlink_ext_ack *extack);
1953size_t br_mst_info_size(const struct net_bridge_vlan_group *vg);
1954int br_mst_fill_info(struct sk_buff *skb,
1955 const struct net_bridge_vlan_group *vg);
1956int br_mst_process(struct net_bridge_port *p, const struct nlattr *mst_attr,
1957 struct netlink_ext_ack *extack);
1958void br_mst_uninit(struct net_bridge *br);
1959#else
1960static inline bool br_mst_is_enabled(const struct net_bridge_port *p)
1961{
1962 return false;
1963}
1964
1965static inline int br_mst_set_state(struct net_bridge_port *p, u16 msti,
1966 u8 state, struct netlink_ext_ack *extack)
1967{
1968 return -EOPNOTSUPP;
1969}
1970
1971static inline int br_mst_set_enabled(struct net_bridge *br, bool on,
1972 struct netlink_ext_ack *extack)
1973{
1974 return -EOPNOTSUPP;
1975}
1976
1977static inline size_t br_mst_info_size(const struct net_bridge_vlan_group *vg)
1978{
1979 return 0;
1980}
1981
1982static inline int br_mst_fill_info(struct sk_buff *skb,
1983 const struct net_bridge_vlan_group *vg)
1984{
1985 return -EOPNOTSUPP;
1986}
1987
1988static inline int br_mst_process(struct net_bridge_port *p,
1989 const struct nlattr *mst_attr,
1990 struct netlink_ext_ack *extack)
1991{
1992 return -EOPNOTSUPP;
1993}
1994
1995static inline void br_mst_uninit(struct net_bridge *br)
1996{
1997}
1998#endif
1999
2000struct nf_br_ops {
2001 int (*br_dev_xmit_hook)(struct sk_buff *skb);
2002};
2003extern const struct nf_br_ops __rcu *nf_br_ops;
2004
2005/* br_netfilter.c */
2006#if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
2007int br_nf_core_init(void);
2008void br_nf_core_fini(void);
2009void br_netfilter_rtable_init(struct net_bridge *);
2010#else
2011static inline int br_nf_core_init(void) { return 0; }
2012static inline void br_nf_core_fini(void) {}
2013#define br_netfilter_rtable_init(x)
2014#endif
2015
2016/* br_stp.c */
2017void br_set_state(struct net_bridge_port *p, unsigned int state);
2018struct net_bridge_port *br_get_port(struct net_bridge *br, u16 port_no);
2019void br_init_port(struct net_bridge_port *p);
2020void br_become_designated_port(struct net_bridge_port *p);
2021
2022void __br_set_forward_delay(struct net_bridge *br, unsigned long t);
2023int br_set_forward_delay(struct net_bridge *br, unsigned long x);
2024int br_set_hello_time(struct net_bridge *br, unsigned long x);
2025int br_set_max_age(struct net_bridge *br, unsigned long x);
2026int __set_ageing_time(struct net_device *dev, unsigned long t);
2027int br_set_ageing_time(struct net_bridge *br, clock_t ageing_time);
2028
2029
2030/* br_stp_if.c */
2031void br_stp_enable_bridge(struct net_bridge *br);
2032void br_stp_disable_bridge(struct net_bridge *br);
2033int br_stp_set_enabled(struct net_bridge *br, unsigned long val,
2034 struct netlink_ext_ack *extack);
2035void br_stp_enable_port(struct net_bridge_port *p);
2036void br_stp_disable_port(struct net_bridge_port *p);
2037bool br_stp_recalculate_bridge_id(struct net_bridge *br);
2038void br_stp_change_bridge_id(struct net_bridge *br, const unsigned char *a);
2039void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio);
2040int br_stp_set_port_priority(struct net_bridge_port *p, unsigned long newprio);
2041int br_stp_set_path_cost(struct net_bridge_port *p, unsigned long path_cost);
2042ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id);
2043
2044/* br_stp_bpdu.c */
2045struct stp_proto;
2046void br_stp_rcv(const struct stp_proto *proto, struct sk_buff *skb,
2047 struct net_device *dev);
2048
2049/* br_stp_timer.c */
2050void br_stp_timer_init(struct net_bridge *br);
2051void br_stp_port_timer_init(struct net_bridge_port *p);
2052unsigned long br_timer_value(const struct timer_list *timer);
2053
2054/* br.c */
2055#if IS_ENABLED(CONFIG_ATM_LANE)
2056extern int (*br_fdb_test_addr_hook)(struct net_device *dev, unsigned char *addr);
2057#endif
2058
2059/* br_mrp.c */
2060#if IS_ENABLED(CONFIG_BRIDGE_MRP)
2061int br_mrp_parse(struct net_bridge *br, struct net_bridge_port *p,
2062 struct nlattr *attr, int cmd, struct netlink_ext_ack *extack);
2063bool br_mrp_enabled(struct net_bridge *br);
2064void br_mrp_port_del(struct net_bridge *br, struct net_bridge_port *p);
2065int br_mrp_fill_info(struct sk_buff *skb, struct net_bridge *br);
2066#else
2067static inline int br_mrp_parse(struct net_bridge *br, struct net_bridge_port *p,
2068 struct nlattr *attr, int cmd,
2069 struct netlink_ext_ack *extack)
2070{
2071 return -EOPNOTSUPP;
2072}
2073
2074static inline bool br_mrp_enabled(struct net_bridge *br)
2075{
2076 return false;
2077}
2078
2079static inline void br_mrp_port_del(struct net_bridge *br,
2080 struct net_bridge_port *p)
2081{
2082}
2083
2084static inline int br_mrp_fill_info(struct sk_buff *skb, struct net_bridge *br)
2085{
2086 return 0;
2087}
2088
2089#endif
2090
2091/* br_cfm.c */
2092#if IS_ENABLED(CONFIG_BRIDGE_CFM)
2093int br_cfm_parse(struct net_bridge *br, struct net_bridge_port *p,
2094 struct nlattr *attr, int cmd, struct netlink_ext_ack *extack);
2095bool br_cfm_created(struct net_bridge *br);
2096void br_cfm_port_del(struct net_bridge *br, struct net_bridge_port *p);
2097int br_cfm_config_fill_info(struct sk_buff *skb, struct net_bridge *br);
2098int br_cfm_status_fill_info(struct sk_buff *skb,
2099 struct net_bridge *br,
2100 bool getlink);
2101int br_cfm_mep_count(struct net_bridge *br, u32 *count);
2102int br_cfm_peer_mep_count(struct net_bridge *br, u32 *count);
2103#else
2104static inline int br_cfm_parse(struct net_bridge *br, struct net_bridge_port *p,
2105 struct nlattr *attr, int cmd,
2106 struct netlink_ext_ack *extack)
2107{
2108 return -EOPNOTSUPP;
2109}
2110
2111static inline bool br_cfm_created(struct net_bridge *br)
2112{
2113 return false;
2114}
2115
2116static inline void br_cfm_port_del(struct net_bridge *br,
2117 struct net_bridge_port *p)
2118{
2119}
2120
2121static inline int br_cfm_config_fill_info(struct sk_buff *skb, struct net_bridge *br)
2122{
2123 return -EOPNOTSUPP;
2124}
2125
2126static inline int br_cfm_status_fill_info(struct sk_buff *skb,
2127 struct net_bridge *br,
2128 bool getlink)
2129{
2130 return -EOPNOTSUPP;
2131}
2132
2133static inline int br_cfm_mep_count(struct net_bridge *br, u32 *count)
2134{
2135 *count = 0;
2136 return -EOPNOTSUPP;
2137}
2138
2139static inline int br_cfm_peer_mep_count(struct net_bridge *br, u32 *count)
2140{
2141 *count = 0;
2142 return -EOPNOTSUPP;
2143}
2144#endif
2145
2146/* br_netlink.c */
2147extern struct rtnl_link_ops br_link_ops;
2148int br_netlink_init(void);
2149void br_netlink_fini(void);
2150void br_ifinfo_notify(int event, const struct net_bridge *br,
2151 const struct net_bridge_port *port);
2152void br_info_notify(int event, const struct net_bridge *br,
2153 const struct net_bridge_port *port, u32 filter);
2154int br_setlink(struct net_device *dev, struct nlmsghdr *nlmsg, u16 flags,
2155 struct netlink_ext_ack *extack);
2156int br_dellink(struct net_device *dev, struct nlmsghdr *nlmsg, u16 flags);
2157int br_getlink(struct sk_buff *skb, u32 pid, u32 seq, struct net_device *dev,
2158 u32 filter_mask, int nlflags);
2159int br_process_vlan_info(struct net_bridge *br,
2160 struct net_bridge_port *p, int cmd,
2161 struct bridge_vlan_info *vinfo_curr,
2162 struct bridge_vlan_info **vinfo_last,
2163 bool *changed,
2164 struct netlink_ext_ack *extack);
2165
2166#ifdef CONFIG_SYSFS
2167/* br_sysfs_if.c */
2168extern const struct sysfs_ops brport_sysfs_ops;
2169int br_sysfs_addif(struct net_bridge_port *p);
2170int br_sysfs_renameif(struct net_bridge_port *p);
2171
2172/* br_sysfs_br.c */
2173int br_sysfs_addbr(struct net_device *dev);
2174void br_sysfs_delbr(struct net_device *dev);
2175
2176#else
2177
2178static inline int br_sysfs_addif(struct net_bridge_port *p) { return 0; }
2179static inline int br_sysfs_renameif(struct net_bridge_port *p) { return 0; }
2180static inline int br_sysfs_addbr(struct net_device *dev) { return 0; }
2181static inline void br_sysfs_delbr(struct net_device *dev) { return; }
2182#endif /* CONFIG_SYSFS */
2183
2184/* br_switchdev.c */
2185#ifdef CONFIG_NET_SWITCHDEV
2186int br_switchdev_port_offload(struct net_bridge_port *p,
2187 struct net_device *dev, const void *ctx,
2188 struct notifier_block *atomic_nb,
2189 struct notifier_block *blocking_nb,
2190 bool tx_fwd_offload,
2191 struct netlink_ext_ack *extack);
2192
2193void br_switchdev_port_unoffload(struct net_bridge_port *p, const void *ctx,
2194 struct notifier_block *atomic_nb,
2195 struct notifier_block *blocking_nb);
2196
2197int br_switchdev_port_replay(struct net_bridge_port *p,
2198 struct net_device *dev, const void *ctx,
2199 struct notifier_block *atomic_nb,
2200 struct notifier_block *blocking_nb,
2201 struct netlink_ext_ack *extack);
2202
2203bool br_switchdev_frame_uses_tx_fwd_offload(struct sk_buff *skb);
2204
2205void br_switchdev_frame_set_offload_fwd_mark(struct sk_buff *skb);
2206
2207void nbp_switchdev_frame_mark_tx_fwd_offload(const struct net_bridge_port *p,
2208 struct sk_buff *skb);
2209void nbp_switchdev_frame_mark_tx_fwd_to_hwdom(const struct net_bridge_port *p,
2210 struct sk_buff *skb);
2211void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
2212 struct sk_buff *skb);
2213bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
2214 const struct sk_buff *skb);
2215int br_switchdev_set_port_flag(struct net_bridge_port *p,
2216 unsigned long flags,
2217 unsigned long mask,
2218 struct netlink_ext_ack *extack);
2219void br_switchdev_fdb_notify(struct net_bridge *br,
2220 const struct net_bridge_fdb_entry *fdb, int type);
2221void br_switchdev_mdb_notify(struct net_device *dev,
2222 struct net_bridge_mdb_entry *mp,
2223 struct net_bridge_port_group *pg,
2224 int type);
2225int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid, u16 flags,
2226 bool changed, struct netlink_ext_ack *extack);
2227int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid);
2228void br_switchdev_init(struct net_bridge *br);
2229
2230static inline void br_switchdev_frame_unmark(struct sk_buff *skb)
2231{
2232 skb->offload_fwd_mark = 0;
2233}
2234#else
2235static inline int
2236br_switchdev_port_offload(struct net_bridge_port *p,
2237 struct net_device *dev, const void *ctx,
2238 struct notifier_block *atomic_nb,
2239 struct notifier_block *blocking_nb,
2240 bool tx_fwd_offload,
2241 struct netlink_ext_ack *extack)
2242{
2243 return -EOPNOTSUPP;
2244}
2245
2246static inline void
2247br_switchdev_port_unoffload(struct net_bridge_port *p, const void *ctx,
2248 struct notifier_block *atomic_nb,
2249 struct notifier_block *blocking_nb)
2250{
2251}
2252
2253static inline int
2254br_switchdev_port_replay(struct net_bridge_port *p,
2255 struct net_device *dev, const void *ctx,
2256 struct notifier_block *atomic_nb,
2257 struct notifier_block *blocking_nb,
2258 struct netlink_ext_ack *extack)
2259{
2260 return -EOPNOTSUPP;
2261}
2262
2263static inline bool br_switchdev_frame_uses_tx_fwd_offload(struct sk_buff *skb)
2264{
2265 return false;
2266}
2267
2268static inline void br_switchdev_frame_set_offload_fwd_mark(struct sk_buff *skb)
2269{
2270}
2271
2272static inline void
2273nbp_switchdev_frame_mark_tx_fwd_offload(const struct net_bridge_port *p,
2274 struct sk_buff *skb)
2275{
2276}
2277
2278static inline void
2279nbp_switchdev_frame_mark_tx_fwd_to_hwdom(const struct net_bridge_port *p,
2280 struct sk_buff *skb)
2281{
2282}
2283
2284static inline void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
2285 struct sk_buff *skb)
2286{
2287}
2288
2289static inline bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
2290 const struct sk_buff *skb)
2291{
2292 return true;
2293}
2294
2295static inline int br_switchdev_set_port_flag(struct net_bridge_port *p,
2296 unsigned long flags,
2297 unsigned long mask,
2298 struct netlink_ext_ack *extack)
2299{
2300 return 0;
2301}
2302
2303static inline int br_switchdev_port_vlan_add(struct net_device *dev, u16 vid,
2304 u16 flags, bool changed,
2305 struct netlink_ext_ack *extack)
2306{
2307 return -EOPNOTSUPP;
2308}
2309
2310static inline int br_switchdev_port_vlan_del(struct net_device *dev, u16 vid)
2311{
2312 return -EOPNOTSUPP;
2313}
2314
2315static inline void
2316br_switchdev_fdb_notify(struct net_bridge *br,
2317 const struct net_bridge_fdb_entry *fdb, int type)
2318{
2319}
2320
2321static inline void br_switchdev_mdb_notify(struct net_device *dev,
2322 struct net_bridge_mdb_entry *mp,
2323 struct net_bridge_port_group *pg,
2324 int type)
2325{
2326}
2327
2328static inline void br_switchdev_frame_unmark(struct sk_buff *skb)
2329{
2330}
2331
2332static inline void br_switchdev_init(struct net_bridge *br)
2333{
2334}
2335
2336#endif /* CONFIG_NET_SWITCHDEV */
2337
2338/* br_arp_nd_proxy.c */
2339void br_recalculate_neigh_suppress_enabled(struct net_bridge *br);
2340void br_do_proxy_suppress_arp(struct sk_buff *skb, struct net_bridge *br,
2341 u16 vid, struct net_bridge_port *p);
2342void br_do_suppress_nd(struct sk_buff *skb, struct net_bridge *br,
2343 u16 vid, struct net_bridge_port *p, struct nd_msg *msg);
2344struct nd_msg *br_is_nd_neigh_msg(const struct sk_buff *skb, struct nd_msg *m);
2345bool br_is_neigh_suppress_enabled(const struct net_bridge_port *p, u16 vid);
2346#endif
2347

source code of linux/net/bridge/br_private.h