net/bridge/br_private.h

   1 /*
   2  *      Linux ethernet bridge
   3  *
   4  *      Authors:
   5  *      Lennert Buytenhek               <buytenh@gnu.org>
   6  *
   7  *      This program is free software; you can redistribute it and/or
   8  *      modify it under the terms of the GNU General Public License
   9  *      as published by the Free Software Foundation; either version
  10  *      2 of the License, or (at your option) any later version.
  11  */
  12
  13 #ifndef _BR_PRIVATE_H
  14 #define _BR_PRIVATE_H
  15
  16 #include <linux/netdevice.h>
  17 #include <linux/if_bridge.h>
  18 #include <linux/netpoll.h>
  19 #include <linux/u64_stats_sync.h>
  20 #include <net/route.h>
  21 #include <net/ip6_fib.h>
  22 #include <linux/if_vlan.h>
  23 #include <linux/rhashtable.h>
  24 #include <linux/refcount.h>
  25
  26 #define BR_HASH_BITS 8
  27 #define BR_HASH_SIZE (1 << BR_HASH_BITS)
  28
  29 #define BR_HOLD_TIME (1*HZ)
  30
  31 #define BR_PORT_BITS    10
  32 #define BR_MAX_PORTS    (1<<BR_PORT_BITS)
  33
  34 #define BR_VERSION      "2.3"
  35
  36 /* Control of forwarding link local multicast */
  37 #define BR_GROUPFWD_DEFAULT     0
  38 /* Don't allow forwarding of control protocols like STP, MAC PAUSE and LACP */
  39 #define BR_GROUPFWD_RESTRICTED  0x0007u
  40 /* The Nearest Customer Bridge Group Address, 01-80-C2-00-00-[00,0B,0C,0D,0F] */
  41 #define BR_GROUPFWD_8021AD      0xB801u
  42
  43 /* Path to usermode spanning tree program */
  44 #define BR_STP_PROG     "/sbin/bridge-stp"
  45
  46 typedef struct bridge_id bridge_id;
  47 typedef struct mac_addr mac_addr;
  48 typedef __u16 port_id;
  49
  50 struct bridge_id
  51 {
  52         unsigned char   prio[2];
  53         unsigned char   addr[ETH_ALEN];
  54 };
  55
  56 struct mac_addr
  57 {
  58         unsigned char   addr[ETH_ALEN];
  59 };
  60
  61 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
  62 /* our own querier */
  63 struct bridge_mcast_own_query {
  64         struct timer_list       timer;
  65         u32                     startup_sent;
  66 };
  67
  68 /* other querier */
  69 struct bridge_mcast_other_query {
  70         struct timer_list               timer;
  71         unsigned long                   delay_time;
  72 };
  73
  74 /* selected querier */
  75 struct bridge_mcast_querier {
  76         struct br_ip addr;
  77         struct net_bridge_port __rcu    *port;
  78 };
  79
  80 /* IGMP/MLD statistics */
  81 struct bridge_mcast_stats {
  82         struct br_mcast_stats mstats;
  83         struct u64_stats_sync syncp;
  84 };
  85 #endif
  86
  87 struct br_vlan_stats {
  88         u64 rx_bytes;
  89         u64 rx_packets;
  90         u64 tx_bytes;
  91         u64 tx_packets;
  92         struct u64_stats_sync syncp;
  93 };
  94
  95 struct br_tunnel_info {
  96         __be64                  tunnel_id;
  97         struct metadata_dst     *tunnel_dst;
  98 };
  99
 100 /**
 101  * struct net_bridge_vlan - per-vlan entry
 102  *
 103  * @vnode: rhashtable member
 104  * @vid: VLAN id
 105  * @flags: bridge vlan flags
 106  * @stats: per-cpu VLAN statistics
 107  * @br: if MASTER flag set, this points to a bridge struct
 108  * @port: if MASTER flag unset, this points to a port struct
 109  * @refcnt: if MASTER flag set, this is bumped for each port referencing it
 110  * @brvlan: if MASTER flag unset, this points to the global per-VLAN context
 111  *          for this VLAN entry
 112  * @vlist: sorted list of VLAN entries
 113  * @rcu: used for entry destruction
 114  *
 115  * This structure is shared between the global per-VLAN entries contained in
 116  * the bridge rhashtable and the local per-port per-VLAN entries contained in
 117  * the port's rhashtable. The union entries should be interpreted depending on
 118  * the entry flags that are set.
 119  */
 120 struct net_bridge_vlan {
 121         struct rhash_head               vnode;
 122         struct rhash_head               tnode;
 123         u16                             vid;
 124         u16                             flags;
 125         struct br_vlan_stats __percpu   *stats;
 126         union {
 127                 struct net_bridge       *br;
 128                 struct net_bridge_port  *port;
 129         };
 130         union {
 131                 refcount_t              refcnt;
 132                 struct net_bridge_vlan  *brvlan;
 133         };
 134
 135         struct br_tunnel_info           tinfo;
 136
 137         struct list_head                vlist;
 138
 139         struct rcu_head                 rcu;
 140 };
 141
 142 /**
 143  * struct net_bridge_vlan_group
 144  *
 145  * @vlan_hash: VLAN entry rhashtable
 146  * @vlan_list: sorted VLAN entry list
 147  * @num_vlans: number of total VLAN entries
 148  * @pvid: PVID VLAN id
 149  *
 150  * IMPORTANT: Be careful when checking if there're VLAN entries using list
 151  *            primitives because the bridge can have entries in its list which
 152  *            are just for global context but not for filtering, i.e. they have
 153  *            the master flag set but not the brentry flag. If you have to check
 154  *            if there're "real" entries in the bridge please test @num_vlans
 155  */
 156 struct net_bridge_vlan_group {
 157         struct rhashtable               vlan_hash;
 158         struct rhashtable               tunnel_hash;
 159         struct list_head                vlan_list;
 160         u16                             num_vlans;
 161         u16                             pvid;
 162 };
 163
 164 struct net_bridge_fdb_entry {
 165         struct hlist_node               hlist;
 166         struct net_bridge_port          *dst;
 167
 168         mac_addr                        addr;
 169         __u16                           vlan_id;
 170         unsigned char                   is_local:1,
 171                                         is_static:1,
 172                                         added_by_user:1,
 173                                         added_by_external_learn:1,
 174                                         offloaded:1;
 175
 176         /* write-heavy members should not affect lookups */
 177         unsigned long                   updated ____cacheline_aligned_in_smp;
 178         unsigned long                   used;
 179
 180         struct rcu_head                 rcu;
 181 };
 182
 183 #define MDB_PG_FLAGS_PERMANENT  BIT(0)
 184 #define MDB_PG_FLAGS_OFFLOAD    BIT(1)
 185
 186 struct net_bridge_port_group {
 187         struct net_bridge_port          *port;
 188         struct net_bridge_port_group __rcu *next;
 189         struct hlist_node               mglist;
 190         struct rcu_head                 rcu;
 191         struct timer_list               timer;
 192         struct br_ip                    addr;
 193         unsigned char                   flags;
 194         unsigned char                   eth_addr[ETH_ALEN];
 195 };
 196
 197 struct net_bridge_mdb_entry
 198 {
 199         struct hlist_node               hlist[2];
 200         struct net_bridge               *br;
 201         struct net_bridge_port_group __rcu *ports;
 202         struct rcu_head                 rcu;
 203         struct timer_list               timer;
 204         struct br_ip                    addr;
 205         bool                            mglist;
 206 };
 207
 208 struct net_bridge_mdb_htable
 209 {
 210         struct hlist_head               *mhash;
 211         struct rcu_head                 rcu;
 212         struct net_bridge_mdb_htable    *old;
 213         u32                             size;
 214         u32                             max;
 215         u32                             secret;
 216         u32                             ver;
 217 };
 218
 219 struct net_bridge_port {
 220         struct net_bridge               *br;
 221         struct net_device               *dev;
 222         struct list_head                list;
 223
 224         unsigned long                   flags;
 225 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
 226         struct net_bridge_vlan_group    __rcu *vlgrp;
 227 #endif
 228
 229         /* STP */
 230         u8                              priority;
 231         u8                              state;
 232         u16                             port_no;
 233         unsigned char                   topology_change_ack;
 234         unsigned char                   config_pending;
 235         port_id                         port_id;
 236         port_id                         designated_port;
 237         bridge_id                       designated_root;
 238         bridge_id                       designated_bridge;
 239         u32                             path_cost;
 240         u32                             designated_cost;
 241         unsigned long                   designated_age;
 242
 243         struct timer_list               forward_delay_timer;
 244         struct timer_list               hold_timer;
 245         struct timer_list               message_age_timer;
 246         struct kobject                  kobj;
 247         struct rcu_head                 rcu;
 248
 249 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 250         struct bridge_mcast_own_query   ip4_own_query;
 251 #if IS_ENABLED(CONFIG_IPV6)
 252         struct bridge_mcast_own_query   ip6_own_query;
 253 #endif /* IS_ENABLED(CONFIG_IPV6) */
 254         unsigned char                   multicast_router;
 255         struct bridge_mcast_stats       __percpu *mcast_stats;
 256         struct timer_list               multicast_router_timer;
 257         struct hlist_head               mglist;
 258         struct hlist_node               rlist;
 259 #endif
 260
 261 #ifdef CONFIG_SYSFS
 262         char                            sysfs_name[IFNAMSIZ];
 263 #endif
 264
 265 #ifdef CONFIG_NET_POLL_CONTROLLER
 266         struct netpoll                  *np;
 267 #endif
 268 #ifdef CONFIG_NET_SWITCHDEV
 269         int                             offload_fwd_mark;
 270 #endif
 271 };
 272
 273 #define br_auto_port(p) ((p)->flags & BR_AUTO_MASK)
 274 #define br_promisc_port(p) ((p)->flags & BR_PROMISC)
 275
 276 #define br_port_exists(dev) (dev->priv_flags & IFF_BRIDGE_PORT)
 277
 278 static inline struct net_bridge_port *br_port_get_rcu(const struct net_device *dev)
 279 {
 280         return rcu_dereference(dev->rx_handler_data);
 281 }
 282
 283 static inline struct net_bridge_port *br_port_get_rtnl(const struct net_device *dev)
 284 {
 285         return br_port_exists(dev) ?
 286                 rtnl_dereference(dev->rx_handler_data) : NULL;
 287 }
 288
 289 static inline struct net_bridge_port *br_port_get_rtnl_rcu(const struct net_device *dev)
 290 {
 291         return br_port_exists(dev) ?
 292                 rcu_dereference_rtnl(dev->rx_handler_data) : NULL;
 293 }
 294
 295 struct net_bridge {
 296         spinlock_t                      lock;
 297         spinlock_t                      hash_lock;
 298         struct list_head                port_list;
 299         struct net_device               *dev;
 300         struct pcpu_sw_netstats         __percpu *stats;
 301         /* These fields are accessed on each packet */
 302 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
 303         u8                              vlan_enabled;
 304         u8                              vlan_stats_enabled;
 305         __be16                          vlan_proto;
 306         u16                             default_pvid;
 307         struct net_bridge_vlan_group    __rcu *vlgrp;
 308 #endif
 309
 310         struct hlist_head               hash[BR_HASH_SIZE];
 311 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
 312         union {
 313                 struct rtable           fake_rtable;
 314                 struct rt6_info         fake_rt6_info;
 315         };
 316         bool                            nf_call_iptables;
 317         bool                            nf_call_ip6tables;
 318         bool                            nf_call_arptables;
 319 #endif
 320         u16                             group_fwd_mask;
 321         u16                             group_fwd_mask_required;
 322
 323         /* STP */
 324         bridge_id                       designated_root;
 325         bridge_id                       bridge_id;
 326         u32                             root_path_cost;
 327         unsigned char                   topology_change;
 328         unsigned char                   topology_change_detected;
 329         u16                             root_port;
 330         unsigned long                   max_age;
 331         unsigned long                   hello_time;
 332         unsigned long                   forward_delay;
 333         unsigned long                   ageing_time;
 334         unsigned long                   bridge_max_age;
 335         unsigned long                   bridge_hello_time;
 336         unsigned long                   bridge_forward_delay;
 337         unsigned long                   bridge_ageing_time;
 338
 339         u8                              group_addr[ETH_ALEN];
 340         bool                            group_addr_set;
 341
 342         enum {
 343                 BR_NO_STP,              /* no spanning tree */
 344                 BR_KERNEL_STP,          /* old STP in kernel */
 345                 BR_USER_STP,            /* new RSTP in userspace */
 346         } stp_enabled;
 347
 348 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 349         unsigned char                   multicast_router;
 350
 351         u8                              multicast_disabled:1;
 352         u8                              multicast_querier:1;
 353         u8                              multicast_query_use_ifaddr:1;
 354         u8                              has_ipv6_addr:1;
 355         u8                              multicast_stats_enabled:1;
 356
 357         u32                             hash_elasticity;
 358         u32                             hash_max;
 359
 360         u32                             multicast_last_member_count;
 361         u32                             multicast_startup_query_count;
 362
 363         u8                              multicast_igmp_version;
 364
 365         unsigned long                   multicast_last_member_interval;
 366         unsigned long                   multicast_membership_interval;
 367         unsigned long                   multicast_querier_interval;
 368         unsigned long                   multicast_query_interval;
 369         unsigned long                   multicast_query_response_interval;
 370         unsigned long                   multicast_startup_query_interval;
 371
 372         spinlock_t                      multicast_lock;
 373         struct net_bridge_mdb_htable __rcu *mdb;
 374         struct hlist_head               router_list;
 375
 376         struct timer_list               multicast_router_timer;
 377         struct bridge_mcast_other_query ip4_other_query;
 378         struct bridge_mcast_own_query   ip4_own_query;
 379         struct bridge_mcast_querier     ip4_querier;
 380         struct bridge_mcast_stats       __percpu *mcast_stats;
 381 #if IS_ENABLED(CONFIG_IPV6)
 382         struct bridge_mcast_other_query ip6_other_query;
 383         struct bridge_mcast_own_query   ip6_own_query;
 384         struct bridge_mcast_querier     ip6_querier;
 385         u8                              multicast_mld_version;
 386 #endif /* IS_ENABLED(CONFIG_IPV6) */
 387 #endif
 388
 389         struct timer_list               hello_timer;
 390         struct timer_list               tcn_timer;
 391         struct timer_list               topology_change_timer;
 392         struct delayed_work             gc_work;
 393         struct kobject                  *ifobj;
 394         u32                             auto_cnt;
 395
 396 #ifdef CONFIG_NET_SWITCHDEV
 397         int offload_fwd_mark;
 398 #endif
 399 };
 400
 401 struct br_input_skb_cb {
 402         struct net_device *brdev;
 403
 404 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 405         int igmp;
 406         int mrouters_only;
 407 #endif
 408
 409         bool proxyarp_replied;
 410
 411 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
 412         bool vlan_filtered;
 413 #endif
 414
 415 #ifdef CONFIG_NET_SWITCHDEV
 416         int offload_fwd_mark;
 417 #endif
 418 };
 419
 420 #define BR_INPUT_SKB_CB(__skb)  ((struct br_input_skb_cb *)(__skb)->cb)
 421
 422 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 423 # define BR_INPUT_SKB_CB_MROUTERS_ONLY(__skb)   (BR_INPUT_SKB_CB(__skb)->mrouters_only)
 424 #else
 425 # define BR_INPUT_SKB_CB_MROUTERS_ONLY(__skb)   (0)
 426 #endif
 427
 428 #define br_printk(level, br, format, args...)   \
 429         printk(level "%s: " format, (br)->dev->name, ##args)
 430
 431 #define br_err(__br, format, args...)                   \
 432         br_printk(KERN_ERR, __br, format, ##args)
 433 #define br_warn(__br, format, args...)                  \
 434         br_printk(KERN_WARNING, __br, format, ##args)
 435 #define br_notice(__br, format, args...)                \
 436         br_printk(KERN_NOTICE, __br, format, ##args)
 437 #define br_info(__br, format, args...)                  \
 438         br_printk(KERN_INFO, __br, format, ##args)
 439
 440 #define br_debug(br, format, args...)                   \
 441         pr_debug("%s: " format,  (br)->dev->name, ##args)
 442
 443 /* called under bridge lock */
 444 static inline int br_is_root_bridge(const struct net_bridge *br)
 445 {
 446         return !memcmp(&br->bridge_id, &br->designated_root, 8);
 447 }
 448
 449 /* check if a VLAN entry is global */
 450 static inline bool br_vlan_is_master(const struct net_bridge_vlan *v)
 451 {
 452         return v->flags & BRIDGE_VLAN_INFO_MASTER;
 453 }
 454
 455 /* check if a VLAN entry is used by the bridge */
 456 static inline bool br_vlan_is_brentry(const struct net_bridge_vlan *v)
 457 {
 458         return v->flags & BRIDGE_VLAN_INFO_BRENTRY;
 459 }
 460
 461 /* check if we should use the vlan entry, returns false if it's only context */
 462 static inline bool br_vlan_should_use(const struct net_bridge_vlan *v)
 463 {
 464         if (br_vlan_is_master(v)) {
 465                 if (br_vlan_is_brentry(v))
 466                         return true;
 467                 else
 468                         return false;
 469         }
 470
 471         return true;
 472 }
 473
 474 /* br_device.c */
 475 void br_dev_setup(struct net_device *dev);
 476 void br_dev_delete(struct net_device *dev, struct list_head *list);
 477 netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev);
 478 #ifdef CONFIG_NET_POLL_CONTROLLER
 479 static inline void br_netpoll_send_skb(const struct net_bridge_port *p,
 480                                        struct sk_buff *skb)
 481 {
 482         struct netpoll *np = p->np;
 483
 484         if (np)
 485                 netpoll_send_skb(np, skb);
 486 }
 487
 488 int br_netpoll_enable(struct net_bridge_port *p);
 489 void br_netpoll_disable(struct net_bridge_port *p);
 490 #else
 491 static inline void br_netpoll_send_skb(const struct net_bridge_port *p,
 492                                        struct sk_buff *skb)
 493 {
 494 }
 495
 496 static inline int br_netpoll_enable(struct net_bridge_port *p)
 497 {
 498         return 0;
 499 }
 500
 501 static inline void br_netpoll_disable(struct net_bridge_port *p)
 502 {
 503 }
 504 #endif
 505
 506 /* br_fdb.c */
 507 int br_fdb_init(void);
 508 void br_fdb_fini(void);
 509 void br_fdb_flush(struct net_bridge *br);
 510 void br_fdb_find_delete_local(struct net_bridge *br,
 511                               const struct net_bridge_port *p,
 512                               const unsigned char *addr, u16 vid);
 513 void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr);
 514 void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr);
 515 void br_fdb_cleanup(struct work_struct *work);
 516 void br_fdb_delete_by_port(struct net_bridge *br,
 517                            const struct net_bridge_port *p, u16 vid, int do_all);
 518 struct net_bridge_fdb_entry *br_fdb_find_rcu(struct net_bridge *br,
 519                                              const unsigned char *addr,
 520                                              __u16 vid);
 521 int br_fdb_test_addr(struct net_device *dev, unsigned char *addr);
 522 int br_fdb_fillbuf(struct net_bridge *br, void *buf, unsigned long count,
 523                    unsigned long off);
 524 int br_fdb_insert(struct net_bridge *br, struct net_bridge_port *source,
 525                   const unsigned char *addr, u16 vid);
 526 void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
 527                    const unsigned char *addr, u16 vid, bool added_by_user);
 528
 529 int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
 530                   struct net_device *dev, const unsigned char *addr, u16 vid);
 531 int br_fdb_add(struct ndmsg *nlh, struct nlattr *tb[], struct net_device *dev,
 532                const unsigned char *addr, u16 vid, u16 nlh_flags);
 533 int br_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb,
 534                 struct net_device *dev, struct net_device *fdev, int *idx);
 535 int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p);
 536 void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p);
 537 int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
 538                               const unsigned char *addr, u16 vid);
 539 int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
 540                               const unsigned char *addr, u16 vid);
 541 void br_fdb_offloaded_set(struct net_bridge *br, struct net_bridge_port *p,
 542                           const unsigned char *addr, u16 vid);
 543
 544 /* br_forward.c */
 545 enum br_pkt_type {
 546         BR_PKT_UNICAST,
 547         BR_PKT_MULTICAST,
 548         BR_PKT_BROADCAST
 549 };
 550 int br_dev_queue_push_xmit(struct net *net, struct sock *sk, struct sk_buff *skb);
 551 void br_forward(const struct net_bridge_port *to, struct sk_buff *skb,
 552                 bool local_rcv, bool local_orig);
 553 int br_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb);
 554 void br_flood(struct net_bridge *br, struct sk_buff *skb,
 555               enum br_pkt_type pkt_type, bool local_rcv, bool local_orig);
 556
 557 /* br_if.c */
 558 void br_port_carrier_check(struct net_bridge_port *p);
 559 int br_add_bridge(struct net *net, const char *name);
 560 int br_del_bridge(struct net *net, const char *name);
 561 int br_add_if(struct net_bridge *br, struct net_device *dev);
 562 int br_del_if(struct net_bridge *br, struct net_device *dev);
 563 int br_min_mtu(const struct net_bridge *br);
 564 netdev_features_t br_features_recompute(struct net_bridge *br,
 565                                         netdev_features_t features);
 566 void br_port_flags_change(struct net_bridge_port *port, unsigned long mask);
 567 void br_manage_promisc(struct net_bridge *br);
 568
 569 /* br_input.c */
 570 int br_handle_frame_finish(struct net *net, struct sock *sk, struct sk_buff *skb);
 571 rx_handler_result_t br_handle_frame(struct sk_buff **pskb);
 572
 573 static inline bool br_rx_handler_check_rcu(const struct net_device *dev)
 574 {
 575         return rcu_dereference(dev->rx_handler) == br_handle_frame;
 576 }
 577
 578 static inline struct net_bridge_port *br_port_get_check_rcu(const struct net_device *dev)
 579 {
 580         return br_rx_handler_check_rcu(dev) ? br_port_get_rcu(dev) : NULL;
 581 }
 582
 583 /* br_ioctl.c */
 584 int br_dev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 585 int br_ioctl_deviceless_stub(struct net *net, unsigned int cmd,
 586                              void __user *arg);
 587
 588 /* br_multicast.c */
 589 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
 590 extern unsigned int br_mdb_rehash_seq;
 591 int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
 592                      struct sk_buff *skb, u16 vid);
 593 struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
 594                                         struct sk_buff *skb, u16 vid);
 595 int br_multicast_add_port(struct net_bridge_port *port);
 596 void br_multicast_del_port(struct net_bridge_port *port);
 597 void br_multicast_enable_port(struct net_bridge_port *port);
 598 void br_multicast_disable_port(struct net_bridge_port *port);
 599 void br_multicast_init(struct net_bridge *br);
 600 void br_multicast_open(struct net_bridge *br);
 601 void br_multicast_stop(struct net_bridge *br);
 602 void br_multicast_dev_del(struct net_bridge *br);
 603 void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
 604                         struct sk_buff *skb, bool local_rcv, bool local_orig);
 605 int br_multicast_set_router(struct net_bridge *br, unsigned long val);
 606 int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val);
 607 int br_multicast_toggle(struct net_bridge *br, unsigned long val);
 608 int br_multicast_set_querier(struct net_bridge *br, unsigned long val);
 609 int br_multicast_set_hash_max(struct net_bridge *br, unsigned long val);
 610 int br_multicast_set_igmp_version(struct net_bridge *br, unsigned long val);
 611 #if IS_ENABLED(CONFIG_IPV6)
 612 int br_multicast_set_mld_version(struct net_bridge *br, unsigned long val);
 613 #endif
 614 struct net_bridge_mdb_entry *
 615 br_mdb_ip_get(struct net_bridge_mdb_htable *mdb, struct br_ip *dst);
 616 struct net_bridge_mdb_entry *
 617 br_multicast_new_group(struct net_bridge *br, struct net_bridge_port *port,
 618                        struct br_ip *group);
 619 void br_multicast_free_pg(struct rcu_head *head);
 620 struct net_bridge_port_group *
 621 br_multicast_new_port_group(struct net_bridge_port *port, struct br_ip *group,
 622                             struct net_bridge_port_group __rcu *next,
 623                             unsigned char flags, const unsigned char *src);
 624 void br_mdb_init(void);
 625 void br_mdb_uninit(void);
 626 void br_mdb_notify(struct net_device *dev, struct net_bridge_port *port,
 627                    struct br_ip *group, int type, u8 flags);
 628 void br_rtr_notify(struct net_device *dev, struct net_bridge_port *port,
 629                    int type);
 630 void br_multicast_count(struct net_bridge *br, const struct net_bridge_port *p,
 631                         const struct sk_buff *skb, u8 type, u8 dir);
 632 int br_multicast_init_stats(struct net_bridge *br);
 633 void br_multicast_uninit_stats(struct net_bridge *br);
 634 void br_multicast_get_stats(const struct net_bridge *br,
 635                             const struct net_bridge_port *p,
 636                             struct br_mcast_stats *dest);
 637
 638 #define mlock_dereference(X, br) \
 639         rcu_dereference_protected(X, lockdep_is_held(&br->multicast_lock))
 640
 641 static inline bool br_multicast_is_router(struct net_bridge *br)
 642 {
 643         return br->multicast_router == 2 ||
 644                (br->multicast_router == 1 &&
 645                 timer_pending(&br->multicast_router_timer));
 646 }
 647
 648 static inline bool
 649 __br_multicast_querier_exists(struct net_bridge *br,
 650                                 struct bridge_mcast_other_query *querier,
 651                                 const bool is_ipv6)
 652 {
 653         bool own_querier_enabled;
 654
 655         if (br->multicast_querier) {
 656                 if (is_ipv6 && !br->has_ipv6_addr)
 657                         own_querier_enabled = false;
 658                 else
 659                         own_querier_enabled = true;
 660         } else {
 661                 own_querier_enabled = false;
 662         }
 663
 664         return time_is_before_jiffies(querier->delay_time) &&
 665                (own_querier_enabled || timer_pending(&querier->timer));
 666 }
 667
 668 static inline bool br_multicast_querier_exists(struct net_bridge *br,
 669                                                struct ethhdr *eth)
 670 {
 671         switch (eth->h_proto) {
 672         case (htons(ETH_P_IP)):
 673                 return __br_multicast_querier_exists(br,
 674                         &br->ip4_other_query, false);
 675 #if IS_ENABLED(CONFIG_IPV6)
 676         case (htons(ETH_P_IPV6)):
 677                 return __br_multicast_querier_exists(br,
 678                         &br->ip6_other_query, true);
 679 #endif
 680         default:
 681                 return false;
 682         }
 683 }
 684
 685 static inline int br_multicast_igmp_type(const struct sk_buff *skb)
 686 {
 687         return BR_INPUT_SKB_CB(skb)->igmp;
 688 }
 689 #else
 690 static inline int br_multicast_rcv(struct net_bridge *br,
 691                                    struct net_bridge_port *port,
 692                                    struct sk_buff *skb,
 693                                    u16 vid)
 694 {
 695         return 0;
 696 }
 697
 698 static inline struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
 699                                                       struct sk_buff *skb, u16 vid)
 700 {
 701         return NULL;
 702 }
 703
 704 static inline int br_multicast_add_port(struct net_bridge_port *port)
 705 {
 706         return 0;
 707 }
 708
 709 static inline void br_multicast_del_port(struct net_bridge_port *port)
 710 {
 711 }
 712
 713 static inline void br_multicast_enable_port(struct net_bridge_port *port)
 714 {
 715 }
 716
 717 static inline void br_multicast_disable_port(struct net_bridge_port *port)
 718 {
 719 }
 720
 721 static inline void br_multicast_init(struct net_bridge *br)
 722 {
 723 }
 724
 725 static inline void br_multicast_open(struct net_bridge *br)
 726 {
 727 }
 728
 729 static inline void br_multicast_stop(struct net_bridge *br)
 730 {
 731 }
 732
 733 static inline void br_multicast_dev_del(struct net_bridge *br)
 734 {
 735 }
 736
 737 static inline void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
 738                                       struct sk_buff *skb,
 739                                       bool local_rcv, bool local_orig)
 740 {
 741 }
 742
 743 static inline bool br_multicast_is_router(struct net_bridge *br)
 744 {
 745         return 0;
 746 }
 747
 748 static inline bool br_multicast_querier_exists(struct net_bridge *br,
 749                                                struct ethhdr *eth)
 750 {
 751         return false;
 752 }
 753
 754 static inline void br_mdb_init(void)
 755 {
 756 }
 757
 758 static inline void br_mdb_uninit(void)
 759 {
 760 }
 761
 762 static inline void br_multicast_count(struct net_bridge *br,
 763                                       const struct net_bridge_port *p,
 764                                       const struct sk_buff *skb,
 765                                       u8 type, u8 dir)
 766 {
 767 }
 768
 769 static inline int br_multicast_init_stats(struct net_bridge *br)
 770 {
 771         return 0;
 772 }
 773
 774 static inline void br_multicast_uninit_stats(struct net_bridge *br)
 775 {
 776 }
 777
 778 static inline int br_multicast_igmp_type(const struct sk_buff *skb)
 779 {
 780         return 0;
 781 }
 782 #endif
 783
 784 /* br_vlan.c */
 785 #ifdef CONFIG_BRIDGE_VLAN_FILTERING
 786 bool br_allowed_ingress(const struct net_bridge *br,
 787                         struct net_bridge_vlan_group *vg, struct sk_buff *skb,
 788                         u16 *vid);
 789 bool br_allowed_egress(struct net_bridge_vlan_group *vg,
 790                        const struct sk_buff *skb);
 791 bool br_should_learn(struct net_bridge_port *p, struct sk_buff *skb, u16 *vid);
 792 struct sk_buff *br_handle_vlan(struct net_bridge *br,
 793                                const struct net_bridge_port *port,
 794                                struct net_bridge_vlan_group *vg,
 795                                struct sk_buff *skb);
 796 int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags);
 797 int br_vlan_delete(struct net_bridge *br, u16 vid);
 798 void br_vlan_flush(struct net_bridge *br);
 799 struct net_bridge_vlan *br_vlan_find(struct net_bridge_vlan_group *vg, u16 vid);
 800 void br_recalculate_fwd_mask(struct net_bridge *br);
 801 int __br_vlan_filter_toggle(struct net_bridge *br, unsigned long val);
 802 int br_vlan_filter_toggle(struct net_bridge *br, unsigned long val);
 803 int __br_vlan_set_proto(struct net_bridge *br, __be16 proto);
 804 int br_vlan_set_proto(struct net_bridge *br, unsigned long val);
 805 int br_vlan_set_stats(struct net_bridge *br, unsigned long val);
 806 int br_vlan_init(struct net_bridge *br);
 807 int br_vlan_set_default_pvid(struct net_bridge *br, unsigned long val);
 808 int __br_vlan_set_default_pvid(struct net_bridge *br, u16 pvid);
 809 int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags);
 810 int nbp_vlan_delete(struct net_bridge_port *port, u16 vid);
 811 void nbp_vlan_flush(struct net_bridge_port *port);
 812 int nbp_vlan_init(struct net_bridge_port *port);
 813 int nbp_get_num_vlan_infos(struct net_bridge_port *p, u32 filter_mask);
 814 void br_vlan_get_stats(const struct net_bridge_vlan *v,
 815                        struct br_vlan_stats *stats);
 816
 817 static inline struct net_bridge_vlan_group *br_vlan_group(
 818                                         const struct net_bridge *br)
 819 {
 820         return rtnl_dereference(br->vlgrp);
 821 }
 822
 823 static inline struct net_bridge_vlan_group *nbp_vlan_group(
 824                                         const struct net_bridge_port *p)
 825 {
 826         return rtnl_dereference(p->vlgrp);
 827 }
 828
 829 static inline struct net_bridge_vlan_group *br_vlan_group_rcu(
 830                                         const struct net_bridge *br)
 831 {
 832         return rcu_dereference(br->vlgrp);
 833 }
 834
 835 static inline struct net_bridge_vlan_group *nbp_vlan_group_rcu(
 836                                         const struct net_bridge_port *p)
 837 {
 838         return rcu_dereference(p->vlgrp);
 839 }
 840
 841 /* Since bridge now depends on 8021Q module, but the time bridge sees the
 842  * skb, the vlan tag will always be present if the frame was tagged.
 843  */
 844 static inline int br_vlan_get_tag(const struct sk_buff *skb, u16 *vid)
 845 {
 846         int err = 0;
 847
 848         if (skb_vlan_tag_present(skb)) {
 849                 *vid = skb_vlan_tag_get(skb) & VLAN_VID_MASK;
 850         } else {
 851                 *vid = 0;
 852                 err = -EINVAL;
 853         }
 854
 855         return err;
 856 }
 857
 858 static inline u16 br_get_pvid(const struct net_bridge_vlan_group *vg)
 859 {
 860         if (!vg)
 861                 return 0;
 862
 863         smp_rmb();
 864         return vg->pvid;
 865 }
 866
 867 #else
 868 static inline bool br_allowed_ingress(const struct net_bridge *br,
 869                                       struct net_bridge_vlan_group *vg,
 870                                       struct sk_buff *skb,
 871                                       u16 *vid)
 872 {
 873         return true;
 874 }
 875
 876 static inline bool br_allowed_egress(struct net_bridge_vlan_group *vg,
 877                                      const struct sk_buff *skb)
 878 {
 879         return true;
 880 }
 881
 882 static inline bool br_should_learn(struct net_bridge_port *p,
 883                                    struct sk_buff *skb, u16 *vid)
 884 {
 885         return true;
 886 }
 887
 888 static inline struct sk_buff *br_handle_vlan(struct net_bridge *br,
 889                                              const struct net_bridge_port *port,
 890                                              struct net_bridge_vlan_group *vg,
 891                                              struct sk_buff *skb)
 892 {
 893         return skb;
 894 }
 895
 896 static inline int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags)
 897 {
 898         return -EOPNOTSUPP;
 899 }
 900
 901 static inline int br_vlan_delete(struct net_bridge *br, u16 vid)
 902 {
 903         return -EOPNOTSUPP;
 904 }
 905
 906 static inline void br_vlan_flush(struct net_bridge *br)
 907 {
 908 }
 909
 910 static inline void br_recalculate_fwd_mask(struct net_bridge *br)
 911 {
 912 }
 913
 914 static inline int br_vlan_init(struct net_bridge *br)
 915 {
 916         return 0;
 917 }
 918
 919 static inline int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags)
 920 {
 921         return -EOPNOTSUPP;
 922 }
 923
 924 static inline int nbp_vlan_delete(struct net_bridge_port *port, u16 vid)
 925 {
 926         return -EOPNOTSUPP;
 927 }
 928
 929 static inline void nbp_vlan_flush(struct net_bridge_port *port)
 930 {
 931 }
 932
 933 static inline struct net_bridge_vlan *br_vlan_find(struct net_bridge_vlan_group *vg,
 934                                                    u16 vid)
 935 {
 936         return NULL;
 937 }
 938
 939 static inline int nbp_vlan_init(struct net_bridge_port *port)
 940 {
 941         return 0;
 942 }
 943
 944 static inline u16 br_vlan_get_tag(const struct sk_buff *skb, u16 *tag)
 945 {
 946         return 0;
 947 }
 948
 949 static inline u16 br_get_pvid(const struct net_bridge_vlan_group *vg)
 950 {
 951         return 0;
 952 }
 953
 954 static inline int __br_vlan_filter_toggle(struct net_bridge *br,
 955                                           unsigned long val)
 956 {
 957         return -EOPNOTSUPP;
 958 }
 959
 960 static inline int nbp_get_num_vlan_infos(struct net_bridge_port *p,
 961                                          u32 filter_mask)
 962 {
 963         return 0;
 964 }
 965
 966 static inline struct net_bridge_vlan_group *br_vlan_group(
 967                                         const struct net_bridge *br)
 968 {
 969         return NULL;
 970 }
 971
 972 static inline struct net_bridge_vlan_group *nbp_vlan_group(
 973                                         const struct net_bridge_port *p)
 974 {
 975         return NULL;
 976 }
 977
 978 static inline struct net_bridge_vlan_group *br_vlan_group_rcu(
 979                                         const struct net_bridge *br)
 980 {
 981         return NULL;
 982 }
 983
 984 static inline struct net_bridge_vlan_group *nbp_vlan_group_rcu(
 985                                         const struct net_bridge_port *p)
 986 {
 987         return NULL;
 988 }
 989
 990 static inline void br_vlan_get_stats(const struct net_bridge_vlan *v,
 991                                      struct br_vlan_stats *stats)
 992 {
 993 }
 994 #endif
 995
 996 struct nf_br_ops {
 997         int (*br_dev_xmit_hook)(struct sk_buff *skb);
 998 };
 999 extern const struct nf_br_ops __rcu *nf_br_ops;
1000
1001 /* br_netfilter.c */
1002 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
1003 int br_nf_core_init(void);
1004 void br_nf_core_fini(void);
1005 void br_netfilter_rtable_init(struct net_bridge *);
1006 #else
1007 static inline int br_nf_core_init(void) { return 0; }
1008 static inline void br_nf_core_fini(void) {}
1009 #define br_netfilter_rtable_init(x)
1010 #endif
1011
1012 /* br_stp.c */
1013 void br_set_state(struct net_bridge_port *p, unsigned int state);
1014 struct net_bridge_port *br_get_port(struct net_bridge *br, u16 port_no);
1015 void br_init_port(struct net_bridge_port *p);
1016 void br_become_designated_port(struct net_bridge_port *p);
1017
1018 void __br_set_forward_delay(struct net_bridge *br, unsigned long t);
1019 int br_set_forward_delay(struct net_bridge *br, unsigned long x);
1020 int br_set_hello_time(struct net_bridge *br, unsigned long x);
1021 int br_set_max_age(struct net_bridge *br, unsigned long x);
1022 int __set_ageing_time(struct net_device *dev, unsigned long t);
1023 int br_set_ageing_time(struct net_bridge *br, clock_t ageing_time);
1024
1025
1026 /* br_stp_if.c */
1027 void br_stp_enable_bridge(struct net_bridge *br);
1028 void br_stp_disable_bridge(struct net_bridge *br);
1029 void br_stp_set_enabled(struct net_bridge *br, unsigned long val);
1030 void br_stp_enable_port(struct net_bridge_port *p);
1031 void br_stp_disable_port(struct net_bridge_port *p);
1032 bool br_stp_recalculate_bridge_id(struct net_bridge *br);
1033 void br_stp_change_bridge_id(struct net_bridge *br, const unsigned char *a);
1034 void br_stp_set_bridge_priority(struct net_bridge *br, u16 newprio);
1035 int br_stp_set_port_priority(struct net_bridge_port *p, unsigned long newprio);
1036 int br_stp_set_path_cost(struct net_bridge_port *p, unsigned long path_cost);
1037 ssize_t br_show_bridge_id(char *buf, const struct bridge_id *id);
1038
1039 /* br_stp_bpdu.c */
1040 struct stp_proto;
1041 void br_stp_rcv(const struct stp_proto *proto, struct sk_buff *skb,
1042                 struct net_device *dev);
1043
1044 /* br_stp_timer.c */
1045 void br_stp_timer_init(struct net_bridge *br);
1046 void br_stp_port_timer_init(struct net_bridge_port *p);
1047 unsigned long br_timer_value(const struct timer_list *timer);
1048
1049 /* br.c */
1050 #if IS_ENABLED(CONFIG_ATM_LANE)
1051 extern int (*br_fdb_test_addr_hook)(struct net_device *dev, unsigned char *addr);
1052 #endif
1053
1054 /* br_netlink.c */
1055 extern struct rtnl_link_ops br_link_ops;
1056 int br_netlink_init(void);
1057 void br_netlink_fini(void);
1058 void br_ifinfo_notify(int event, struct net_bridge_port *port);
1059 int br_setlink(struct net_device *dev, struct nlmsghdr *nlmsg, u16 flags);
1060 int br_dellink(struct net_device *dev, struct nlmsghdr *nlmsg, u16 flags);
1061 int br_getlink(struct sk_buff *skb, u32 pid, u32 seq, struct net_device *dev,
1062                u32 filter_mask, int nlflags);
1063
1064 #ifdef CONFIG_SYSFS
1065 /* br_sysfs_if.c */
1066 extern const struct sysfs_ops brport_sysfs_ops;
1067 int br_sysfs_addif(struct net_bridge_port *p);
1068 int br_sysfs_renameif(struct net_bridge_port *p);
1069
1070 /* br_sysfs_br.c */
1071 int br_sysfs_addbr(struct net_device *dev);
1072 void br_sysfs_delbr(struct net_device *dev);
1073
1074 #else
1075
1076 static inline int br_sysfs_addif(struct net_bridge_port *p) { return 0; }
1077 static inline int br_sysfs_renameif(struct net_bridge_port *p) { return 0; }
1078 static inline int br_sysfs_addbr(struct net_device *dev) { return 0; }
1079 static inline void br_sysfs_delbr(struct net_device *dev) { return; }
1080 #endif /* CONFIG_SYSFS */
1081
1082 /* br_switchdev.c */
1083 #ifdef CONFIG_NET_SWITCHDEV
1084 int nbp_switchdev_mark_set(struct net_bridge_port *p);
1085 void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
1086                               struct sk_buff *skb);
1087 bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
1088                                   const struct sk_buff *skb);
1089 int br_switchdev_set_port_flag(struct net_bridge_port *p,
1090                                unsigned long flags,
1091                                unsigned long mask);
1092 void br_switchdev_fdb_notify(const struct net_bridge_fdb_entry *fdb,
1093                              int type);
1094 #else
1095 static inline int nbp_switchdev_mark_set(struct net_bridge_port *p)
1096 {
1097         return 0;
1098 }
1099
1100 static inline void nbp_switchdev_frame_mark(const struct net_bridge_port *p,
1101                                             struct sk_buff *skb)
1102 {
1103 }
1104
1105 static inline bool nbp_switchdev_allowed_egress(const struct net_bridge_port *p,
1106                                                 const struct sk_buff *skb)
1107 {
1108         return true;
1109 }
1110
1111 static inline int br_switchdev_set_port_flag(struct net_bridge_port *p,
1112                                              unsigned long flags,
1113                                              unsigned long mask)
1114 {
1115         return 0;
1116 }
1117
1118 static inline void
1119 br_switchdev_fdb_notify(const struct net_bridge_fdb_entry *fdb, int type)
1120 {
1121 }
1122 #endif /* CONFIG_NET_SWITCHDEV */
1123
1124 #endif