~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/bridge/br.c

Version: ~ [ linux-6.0-rc1 ] ~ [ linux-5.19.1 ] ~ [ linux-5.18.17 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.60 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.136 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.210 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.255 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.290 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.325 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 (netif_is_bridge_master(dev)) {
 40                 err = br_vlan_bridge_event(dev, event, ptr);
 41                 if (err)
 42                         return notifier_from_errno(err);
 43 
 44                 if (event == NETDEV_REGISTER) {
 45                         /* register of bridge completed, add sysfs entries */
 46                         err = br_sysfs_addbr(dev);
 47                         if (err)
 48                                 return notifier_from_errno(err);
 49 
 50                         return NOTIFY_DONE;
 51                 }
 52         }
 53 
 54         /* not a port of a bridge */
 55         p = br_port_get_rtnl(dev);
 56         if (!p)
 57                 return NOTIFY_DONE;
 58 
 59         br = p->br;
 60 
 61         switch (event) {
 62         case NETDEV_CHANGEMTU:
 63                 br_mtu_auto_adjust(br);
 64                 break;
 65 
 66         case NETDEV_PRE_CHANGEADDR:
 67                 if (br->dev->addr_assign_type == NET_ADDR_SET)
 68                         break;
 69                 prechaddr_info = ptr;
 70                 err = dev_pre_changeaddr_notify(br->dev,
 71                                                 prechaddr_info->dev_addr,
 72                                                 extack);
 73                 if (err)
 74                         return notifier_from_errno(err);
 75                 break;
 76 
 77         case NETDEV_CHANGEADDR:
 78                 spin_lock_bh(&br->lock);
 79                 br_fdb_changeaddr(p, dev->dev_addr);
 80                 changed_addr = br_stp_recalculate_bridge_id(br);
 81                 spin_unlock_bh(&br->lock);
 82 
 83                 if (changed_addr)
 84                         call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
 85 
 86                 break;
 87 
 88         case NETDEV_CHANGE:
 89                 br_port_carrier_check(p, &notified);
 90                 break;
 91 
 92         case NETDEV_FEAT_CHANGE:
 93                 netdev_update_features(br->dev);
 94                 break;
 95 
 96         case NETDEV_DOWN:
 97                 spin_lock_bh(&br->lock);
 98                 if (br->dev->flags & IFF_UP) {
 99                         br_stp_disable_port(p);
100                         notified = true;
101                 }
102                 spin_unlock_bh(&br->lock);
103                 break;
104 
105         case NETDEV_UP:
106                 if (netif_running(br->dev) && netif_oper_up(dev)) {
107                         spin_lock_bh(&br->lock);
108                         br_stp_enable_port(p);
109                         notified = true;
110                         spin_unlock_bh(&br->lock);
111                 }
112                 break;
113 
114         case NETDEV_UNREGISTER:
115                 br_del_if(br, dev);
116                 break;
117 
118         case NETDEV_CHANGENAME:
119                 err = br_sysfs_renameif(p);
120                 if (err)
121                         return notifier_from_errno(err);
122                 break;
123 
124         case NETDEV_PRE_TYPE_CHANGE:
125                 /* Forbid underlying device to change its type. */
126                 return NOTIFY_BAD;
127 
128         case NETDEV_RESEND_IGMP:
129                 /* Propagate to master device */
130                 call_netdevice_notifiers(event, br->dev);
131                 break;
132         }
133 
134         if (event != NETDEV_UNREGISTER)
135                 br_vlan_port_event(p, event);
136 
137         /* Events that may cause spanning tree to refresh */
138         if (!notified && (event == NETDEV_CHANGEADDR || event == NETDEV_UP ||
139                           event == NETDEV_CHANGE || event == NETDEV_DOWN))
140                 br_ifinfo_notify(RTM_NEWLINK, NULL, p);
141 
142         return NOTIFY_DONE;
143 }
144 
145 static struct notifier_block br_device_notifier = {
146         .notifier_call = br_device_event
147 };
148 
149 /* called with RTNL or RCU */
150 static int br_switchdev_event(struct notifier_block *unused,
151                               unsigned long event, void *ptr)
152 {
153         struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
154         struct net_bridge_port *p;
155         struct net_bridge *br;
156         struct switchdev_notifier_fdb_info *fdb_info;
157         int err = NOTIFY_DONE;
158 
159         p = br_port_get_rtnl_rcu(dev);
160         if (!p)
161                 goto out;
162 
163         br = p->br;
164 
165         switch (event) {
166         case SWITCHDEV_FDB_ADD_TO_BRIDGE:
167                 fdb_info = ptr;
168                 err = br_fdb_external_learn_add(br, p, fdb_info->addr,
169                                                 fdb_info->vid, false);
170                 if (err) {
171                         err = notifier_from_errno(err);
172                         break;
173                 }
174                 br_fdb_offloaded_set(br, p, fdb_info->addr,
175                                      fdb_info->vid, true);
176                 break;
177         case SWITCHDEV_FDB_DEL_TO_BRIDGE:
178                 fdb_info = ptr;
179                 err = br_fdb_external_learn_del(br, p, fdb_info->addr,
180                                                 fdb_info->vid, false);
181                 if (err)
182                         err = notifier_from_errno(err);
183                 break;
184         case SWITCHDEV_FDB_OFFLOADED:
185                 fdb_info = ptr;
186                 br_fdb_offloaded_set(br, p, fdb_info->addr,
187                                      fdb_info->vid, fdb_info->offloaded);
188                 break;
189         case SWITCHDEV_FDB_FLUSH_TO_BRIDGE:
190                 fdb_info = ptr;
191                 /* Don't delete static entries */
192                 br_fdb_delete_by_port(br, p, fdb_info->vid, 0);
193                 break;
194         }
195 
196 out:
197         return err;
198 }
199 
200 static struct notifier_block br_switchdev_notifier = {
201         .notifier_call = br_switchdev_event,
202 };
203 
204 /* called under rtnl_mutex */
205 static int br_switchdev_blocking_event(struct notifier_block *nb,
206                                        unsigned long event, void *ptr)
207 {
208         struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(ptr);
209         struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
210         struct switchdev_notifier_brport_info *brport_info;
211         const struct switchdev_brport *b;
212         struct net_bridge_port *p;
213         int err = NOTIFY_DONE;
214 
215         p = br_port_get_rtnl(dev);
216         if (!p)
217                 goto out;
218 
219         switch (event) {
220         case SWITCHDEV_BRPORT_OFFLOADED:
221                 brport_info = ptr;
222                 b = &brport_info->brport;
223 
224                 err = br_switchdev_port_offload(p, b->dev, b->ctx,
225                                                 b->atomic_nb, b->blocking_nb,
226                                                 b->tx_fwd_offload, extack);
227                 err = notifier_from_errno(err);
228                 break;
229         case SWITCHDEV_BRPORT_UNOFFLOADED:
230                 brport_info = ptr;
231                 b = &brport_info->brport;
232 
233                 br_switchdev_port_unoffload(p, b->ctx, b->atomic_nb,
234                                             b->blocking_nb);
235                 break;
236         }
237 
238 out:
239         return err;
240 }
241 
242 static struct notifier_block br_switchdev_blocking_notifier = {
243         .notifier_call = br_switchdev_blocking_event,
244 };
245 
246 /* br_boolopt_toggle - change user-controlled boolean option
247  *
248  * @br: bridge device
249  * @opt: id of the option to change
250  * @on: new option value
251  * @extack: extack for error messages
252  *
253  * Changes the value of the respective boolean option to @on taking care of
254  * any internal option value mapping and configuration.
255  */
256 int br_boolopt_toggle(struct net_bridge *br, enum br_boolopt_id opt, bool on,
257                       struct netlink_ext_ack *extack)
258 {
259         int err = 0;
260 
261         switch (opt) {
262         case BR_BOOLOPT_NO_LL_LEARN:
263                 br_opt_toggle(br, BROPT_NO_LL_LEARN, on);
264                 break;
265         case BR_BOOLOPT_MCAST_VLAN_SNOOPING:
266                 err = br_multicast_toggle_vlan_snooping(br, on, extack);
267                 break;
268         default:
269                 /* shouldn't be called with unsupported options */
270                 WARN_ON(1);
271                 break;
272         }
273 
274         return err;
275 }
276 
277 int br_boolopt_get(const struct net_bridge *br, enum br_boolopt_id opt)
278 {
279         switch (opt) {
280         case BR_BOOLOPT_NO_LL_LEARN:
281                 return br_opt_get(br, BROPT_NO_LL_LEARN);
282         case BR_BOOLOPT_MCAST_VLAN_SNOOPING:
283                 return br_opt_get(br, BROPT_MCAST_VLAN_SNOOPING_ENABLED);
284         default:
285                 /* shouldn't be called with unsupported options */
286                 WARN_ON(1);
287                 break;
288         }
289 
290         return 0;
291 }
292 
293 int br_boolopt_multi_toggle(struct net_bridge *br,
294                             struct br_boolopt_multi *bm,
295                             struct netlink_ext_ack *extack)
296 {
297         unsigned long bitmap = bm->optmask;
298         int err = 0;
299         int opt_id;
300 
301         for_each_set_bit(opt_id, &bitmap, BR_BOOLOPT_MAX) {
302                 bool on = !!(bm->optval & BIT(opt_id));
303 
304                 err = br_boolopt_toggle(br, opt_id, on, extack);
305                 if (err) {
306                         br_debug(br, "boolopt multi-toggle error: option: %d current: %d new: %d error: %d\n",
307                                  opt_id, br_boolopt_get(br, opt_id), on, err);
308                         break;
309                 }
310         }
311 
312         return err;
313 }
314 
315 void br_boolopt_multi_get(const struct net_bridge *br,
316                           struct br_boolopt_multi *bm)
317 {
318         u32 optval = 0;
319         int opt_id;
320 
321         for (opt_id = 0; opt_id < BR_BOOLOPT_MAX; opt_id++)
322                 optval |= (br_boolopt_get(br, opt_id) << opt_id);
323 
324         bm->optval = optval;
325         bm->optmask = GENMASK((BR_BOOLOPT_MAX - 1), 0);
326 }
327 
328 /* private bridge options, controlled by the kernel */
329 void br_opt_toggle(struct net_bridge *br, enum net_bridge_opts opt, bool on)
330 {
331         bool cur = !!br_opt_get(br, opt);
332 
333         br_debug(br, "toggle option: %d state: %d -> %d\n",
334                  opt, cur, on);
335 
336         if (cur == on)
337                 return;
338 
339         if (on)
340                 set_bit(opt, &br->options);
341         else
342                 clear_bit(opt, &br->options);
343 }
344 
345 static void __net_exit br_net_exit(struct net *net)
346 {
347         struct net_device *dev;
348         LIST_HEAD(list);
349 
350         rtnl_lock();
351         for_each_netdev(net, dev)
352                 if (netif_is_bridge_master(dev))
353                         br_dev_delete(dev, &list);
354 
355         unregister_netdevice_many(&list);
356         rtnl_unlock();
357 
358 }
359 
360 static struct pernet_operations br_net_ops = {
361         .exit   = br_net_exit,
362 };
363 
364 static const struct stp_proto br_stp_proto = {
365         .rcv    = br_stp_rcv,
366 };
367 
368 static int __init br_init(void)
369 {
370         int err;
371 
372         BUILD_BUG_ON(sizeof(struct br_input_skb_cb) > sizeof_field(struct sk_buff, cb));
373 
374         err = stp_proto_register(&br_stp_proto);
375         if (err < 0) {
376                 pr_err("bridge: can't register sap for STP\n");
377                 return err;
378         }
379 
380         err = br_fdb_init();
381         if (err)
382                 goto err_out;
383 
384         err = register_pernet_subsys(&br_net_ops);
385         if (err)
386                 goto err_out1;
387 
388         err = br_nf_core_init();
389         if (err)
390                 goto err_out2;
391 
392         err = register_netdevice_notifier(&br_device_notifier);
393         if (err)
394                 goto err_out3;
395 
396         err = register_switchdev_notifier(&br_switchdev_notifier);
397         if (err)
398                 goto err_out4;
399 
400         err = register_switchdev_blocking_notifier(&br_switchdev_blocking_notifier);
401         if (err)
402                 goto err_out5;
403 
404         err = br_netlink_init();
405         if (err)
406                 goto err_out6;
407 
408         brioctl_set(br_ioctl_stub);
409 
410 #if IS_ENABLED(CONFIG_ATM_LANE)
411         br_fdb_test_addr_hook = br_fdb_test_addr;
412 #endif
413 
414 #if IS_MODULE(CONFIG_BRIDGE_NETFILTER)
415         pr_info("bridge: filtering via arp/ip/ip6tables is no longer available "
416                 "by default. Update your scripts to load br_netfilter if you "
417                 "need this.\n");
418 #endif
419 
420         return 0;
421 
422 err_out6:
423         unregister_switchdev_blocking_notifier(&br_switchdev_blocking_notifier);
424 err_out5:
425         unregister_switchdev_notifier(&br_switchdev_notifier);
426 err_out4:
427         unregister_netdevice_notifier(&br_device_notifier);
428 err_out3:
429         br_nf_core_fini();
430 err_out2:
431         unregister_pernet_subsys(&br_net_ops);
432 err_out1:
433         br_fdb_fini();
434 err_out:
435         stp_proto_unregister(&br_stp_proto);
436         return err;
437 }
438 
439 static void __exit br_deinit(void)
440 {
441         stp_proto_unregister(&br_stp_proto);
442         br_netlink_fini();
443         unregister_switchdev_blocking_notifier(&br_switchdev_blocking_notifier);
444         unregister_switchdev_notifier(&br_switchdev_notifier);
445         unregister_netdevice_notifier(&br_device_notifier);
446         brioctl_set(NULL);
447         unregister_pernet_subsys(&br_net_ops);
448 
449         rcu_barrier(); /* Wait for completion of call_rcu()'s */
450 
451         br_nf_core_fini();
452 #if IS_ENABLED(CONFIG_ATM_LANE)
453         br_fdb_test_addr_hook = NULL;
454 #endif
455         br_fdb_fini();
456 }
457 
458 module_init(br_init)
459 module_exit(br_deinit)
460 MODULE_LICENSE("GPL");
461 MODULE_VERSION(BR_VERSION);
462 MODULE_ALIAS_RTNL_LINK("bridge");
463 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp