1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Generic parts 4 * Linux ethernet bridge 5 * 6 * Authors: 7 * Lennert Buytenhek <buytenh@gnu.org> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/kernel.h> 12 #include <linux/netdevice.h> 13 #include <linux/etherdevice.h> 14 #include <linux/init.h> 15 #include <linux/llc.h> 16 #include <net/llc.h> 17 #include <net/stp.h> 18 #include <net/switchdev.h> 19 20 #include "br_private.h" 21 22 /* 23 * Handle changes in state of network devices enslaved to a bridge. 24 * 25 * Note: don't care about up/down if bridge itself is down, because 26 * port state is checked when bridge is brought up. 27 */ 28 static int br_device_event(struct notifier_block *unused, unsigned long event, void *ptr) 29 { 30 struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(ptr); 31 struct netdev_notifier_pre_changeaddr_info *prechaddr_info; 32 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 33 struct net_bridge_port *p; 34 struct net_bridge *br; 35 bool notified = false; 36 bool changed_addr; 37 int err; 38 39 if (dev->priv_flags & IFF_EBRIDGE) { 40 if (event == NETDEV_REGISTER) { 41 /* register of bridge completed, add sysfs entries */ 42 br_sysfs_addbr(dev); 43 return NOTIFY_DONE; 44 } 45 br_vlan_bridge_event(dev, event, ptr); 46 } 47 48 /* not a port of a bridge */ 49 p = br_port_get_rtnl(dev); 50 if (!p) 51 return NOTIFY_DONE; 52 53 br = p->br; 54 55 switch (event) { 56 case NETDEV_CHANGEMTU: 57 br_mtu_auto_adjust(br); 58 break; 59 60 case NETDEV_PRE_CHANGEADDR: 61 if (br->dev->addr_assign_type == NET_ADDR_SET) 62 break; 63 prechaddr_info = ptr; 64 err = dev_pre_changeaddr_notify(br->dev, 65 prechaddr_info->dev_addr, 66 extack); 67 if (err) 68 return notifier_from_errno(err); 69 break; 70 71 case NETDEV_CHANGEADDR: 72 spin_lock_bh(&br->lock); 73 br_fdb_changeaddr(p, dev->dev_addr); 74 changed_addr = br_stp_recalculate_bridge_id(br); 75 spin_unlock_bh(&br->lock); 76 77 if (changed_addr) 78 call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev); 79 80 break; 81 82 case NETDEV_CHANGE: 83 br_port_carrier_check(p, ¬ified); 84 break; 85 86 case NETDEV_FEAT_CHANGE: 87 netdev_update_features(br->dev); 88 break; 89 90 case NETDEV_DOWN: 91 spin_lock_bh(&br->lock); 92 if (br->dev->flags & IFF_UP) { 93 br_stp_disable_port(p); 94 notified = true; 95 } 96 spin_unlock_bh(&br->lock); 97 break; 98 99 case NETDEV_UP: 100 if (netif_running(br->dev) && netif_oper_up(dev)) { 101 spin_lock_bh(&br->lock); 102 br_stp_enable_port(p); 103 notified = true; 104 spin_unlock_bh(&br->lock); 105 } 106 break; 107 108 case NETDEV_UNREGISTER: 109 br_del_if(br, dev); 110 break; 111 112 case NETDEV_CHANGENAME: 113 err = br_sysfs_renameif(p); 114 if (err) 115 return notifier_from_errno(err); 116 break; 117 118 case NETDEV_PRE_TYPE_CHANGE: 119 /* Forbid underlaying device to change its type. */ 120 return NOTIFY_BAD; 121 122 case NETDEV_RESEND_IGMP: 123 /* Propagate to master device */ 124 call_netdevice_notifiers(event, br->dev); 125 break; 126 } 127 128 if (event != NETDEV_UNREGISTER) 129 br_vlan_port_event(p, event); 130 131 /* Events that may cause spanning tree to refresh */ 132 if (!notified && (event == NETDEV_CHANGEADDR || event == NETDEV_UP || 133 event == NETDEV_CHANGE || event == NETDEV_DOWN)) 134 br_ifinfo_notify(RTM_NEWLINK, NULL, p); 135 136 return NOTIFY_DONE; 137 } 138 139 static struct notifier_block br_device_notifier = { 140 .notifier_call = br_device_event 141 }; 142 143 /* called with RTNL or RCU */ 144 static int br_switchdev_event(struct notifier_block *unused, 145 unsigned long event, void *ptr) 146 { 147 struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 148 struct net_bridge_port *p; 149 struct net_bridge *br; 150 struct switchdev_notifier_fdb_info *fdb_info; 151 int err = NOTIFY_DONE; 152 153 p = br_port_get_rtnl_rcu(dev); 154 if (!p) 155 goto out; 156 157 br = p->br; 158 159 switch (event) { 160 case SWITCHDEV_FDB_ADD_TO_BRIDGE: 161 fdb_info = ptr; 162 err = br_fdb_external_learn_add(br, p, fdb_info->addr, 163 fdb_info->vid, false); 164 if (err) { 165 err = notifier_from_errno(err); 166 break; 167 } 168 br_fdb_offloaded_set(br, p, fdb_info->addr, 169 fdb_info->vid, true); 170 break; 171 case SWITCHDEV_FDB_DEL_TO_BRIDGE: 172 fdb_info = ptr; 173 err = br_fdb_external_learn_del(br, p, fdb_info->addr, 174 fdb_info->vid, false); 175 if (err) 176 err = notifier_from_errno(err); 177 break; 178 case SWITCHDEV_FDB_OFFLOADED: 179 fdb_info = ptr; 180 br_fdb_offloaded_set(br, p, fdb_info->addr, 181 fdb_info->vid, fdb_info->offloaded); 182 break; 183 } 184 185 out: 186 return err; 187 } 188 189 static struct notifier_block br_switchdev_notifier = { 190 .notifier_call = br_switchdev_event, 191 }; 192 193 /* br_boolopt_toggle - change user-controlled boolean option 194 * 195 * @br: bridge device 196 * @opt: id of the option to change 197 * @on: new option value 198 * @extack: extack for error messages 199 * 200 * Changes the value of the respective boolean option to @on taking care of 201 * any internal option value mapping and configuration. 202 */ 203 int br_boolopt_toggle(struct net_bridge *br, enum br_boolopt_id opt, bool on, 204 struct netlink_ext_ack *extack) 205 { 206 switch (opt) { 207 case BR_BOOLOPT_NO_LL_LEARN: 208 br_opt_toggle(br, BROPT_NO_LL_LEARN, on); 209 break; 210 default: 211 /* shouldn't be called with unsupported options */ 212 WARN_ON(1); 213 break; 214 } 215 216 return 0; 217 } 218 219 int br_boolopt_get(const struct net_bridge *br, enum br_boolopt_id opt) 220 { 221 switch (opt) { 222 case BR_BOOLOPT_NO_LL_LEARN: 223 return br_opt_get(br, BROPT_NO_LL_LEARN); 224 default: 225 /* shouldn't be called with unsupported options */ 226 WARN_ON(1); 227 break; 228 } 229 230 return 0; 231 } 232 233 int br_boolopt_multi_toggle(struct net_bridge *br, 234 struct br_boolopt_multi *bm, 235 struct netlink_ext_ack *extack) 236 { 237 unsigned long bitmap = bm->optmask; 238 int err = 0; 239 int opt_id; 240 241 for_each_set_bit(opt_id, &bitmap, BR_BOOLOPT_MAX) { 242 bool on = !!(bm->optval & BIT(opt_id)); 243 244 err = br_boolopt_toggle(br, opt_id, on, extack); 245 if (err) { 246 br_debug(br, "boolopt multi-toggle error: option: %d current: %d new: %d error: %d\n", 247 opt_id, br_boolopt_get(br, opt_id), on, err); 248 break; 249 } 250 } 251 252 return err; 253 } 254 255 void br_boolopt_multi_get(const struct net_bridge *br, 256 struct br_boolopt_multi *bm) 257 { 258 u32 optval = 0; 259 int opt_id; 260 261 for (opt_id = 0; opt_id < BR_BOOLOPT_MAX; opt_id++) 262 optval |= (br_boolopt_get(br, opt_id) << opt_id); 263 264 bm->optval = optval; 265 bm->optmask = GENMASK((BR_BOOLOPT_MAX - 1), 0); 266 } 267 268 /* private bridge options, controlled by the kernel */ 269 void br_opt_toggle(struct net_bridge *br, enum net_bridge_opts opt, bool on) 270 { 271 bool cur = !!br_opt_get(br, opt); 272 273 br_debug(br, "toggle option: %d state: %d -> %d\n", 274 opt, cur, on); 275 276 if (cur == on) 277 return; 278 279 if (on) 280 set_bit(opt, &br->options); 281 else 282 clear_bit(opt, &br->options); 283 } 284 285 static void __net_exit br_net_exit(struct net *net) 286 { 287 struct net_device *dev; 288 LIST_HEAD(list); 289 290 rtnl_lock(); 291 for_each_netdev(net, dev) 292 if (dev->priv_flags & IFF_EBRIDGE) 293 br_dev_delete(dev, &list); 294 295 unregister_netdevice_many(&list); 296 rtnl_unlock(); 297 298 } 299 300 static struct pernet_operations br_net_ops = { 301 .exit = br_net_exit, 302 }; 303 304 static const struct stp_proto br_stp_proto = { 305 .rcv = br_stp_rcv, 306 }; 307 308 static int __init br_init(void) 309 { 310 int err; 311 312 BUILD_BUG_ON(sizeof(struct br_input_skb_cb) > FIELD_SIZEOF(struct sk_buff, cb)); 313 314 err = stp_proto_register(&br_stp_proto); 315 if (err < 0) { 316 pr_err("bridge: can't register sap for STP\n"); 317 return err; 318 } 319 320 err = br_fdb_init(); 321 if (err) 322 goto err_out; 323 324 err = register_pernet_subsys(&br_net_ops); 325 if (err) 326 goto err_out1; 327 328 err = br_nf_core_init(); 329 if (err) 330 goto err_out2; 331 332 err = register_netdevice_notifier(&br_device_notifier); 333 if (err) 334 goto err_out3; 335 336 err = register_switchdev_notifier(&br_switchdev_notifier); 337 if (err) 338 goto err_out4; 339 340 err = br_netlink_init(); 341 if (err) 342 goto err_out5; 343 344 brioctl_set(br_ioctl_deviceless_stub); 345 346 #if IS_ENABLED(CONFIG_ATM_LANE) 347 br_fdb_test_addr_hook = br_fdb_test_addr; 348 #endif 349 350 #if IS_MODULE(CONFIG_BRIDGE_NETFILTER) 351 pr_info("bridge: filtering via arp/ip/ip6tables is no longer available " 352 "by default. Update your scripts to load br_netfilter if you " 353 "need this.\n"); 354 #endif 355 356 return 0; 357 358 err_out5: 359 unregister_switchdev_notifier(&br_switchdev_notifier); 360 err_out4: 361 unregister_netdevice_notifier(&br_device_notifier); 362 err_out3: 363 br_nf_core_fini(); 364 err_out2: 365 unregister_pernet_subsys(&br_net_ops); 366 err_out1: 367 br_fdb_fini(); 368 err_out: 369 stp_proto_unregister(&br_stp_proto); 370 return err; 371 } 372 373 static void __exit br_deinit(void) 374 { 375 stp_proto_unregister(&br_stp_proto); 376 br_netlink_fini(); 377 unregister_switchdev_notifier(&br_switchdev_notifier); 378 unregister_netdevice_notifier(&br_device_notifier); 379 brioctl_set(NULL); 380 unregister_pernet_subsys(&br_net_ops); 381 382 rcu_barrier(); /* Wait for completion of call_rcu()'s */ 383 384 br_nf_core_fini(); 385 #if IS_ENABLED(CONFIG_ATM_LANE) 386 br_fdb_test_addr_hook = NULL; 387 #endif 388 br_fdb_fini(); 389 } 390 391 module_init(br_init) 392 module_exit(br_deinit) 393 MODULE_LICENSE("GPL"); 394 MODULE_VERSION(BR_VERSION); 395 MODULE_ALIAS_RTNL_LINK("bridge"); 396