Loading...
1/*
2 * Generic parts
3 * Linux ethernet bridge
4 *
5 * Authors:
6 * Lennert Buytenhek <buytenh@gnu.org>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/netdevice.h>
17#include <linux/etherdevice.h>
18#include <linux/init.h>
19#include <linux/llc.h>
20#include <net/llc.h>
21#include <net/stp.h>
22#include <net/switchdev.h>
23
24#include "br_private.h"
25
26/*
27 * Handle changes in state of network devices enslaved to a bridge.
28 *
29 * Note: don't care about up/down if bridge itself is down, because
30 * port state is checked when bridge is brought up.
31 */
32static int br_device_event(struct notifier_block *unused, unsigned long event, void *ptr)
33{
34 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
35 struct net_bridge_port *p;
36 struct net_bridge *br;
37 bool changed_addr;
38 int err;
39
40 /* register of bridge completed, add sysfs entries */
41 if ((dev->priv_flags & IFF_EBRIDGE) && event == NETDEV_REGISTER) {
42 br_sysfs_addbr(dev);
43 return NOTIFY_DONE;
44 }
45
46 /* not a port of a bridge */
47 p = br_port_get_rtnl(dev);
48 if (!p)
49 return NOTIFY_DONE;
50
51 br = p->br;
52
53 switch (event) {
54 case NETDEV_CHANGEMTU:
55 dev_set_mtu(br->dev, br_min_mtu(br));
56 break;
57
58 case NETDEV_CHANGEADDR:
59 spin_lock_bh(&br->lock);
60 br_fdb_changeaddr(p, dev->dev_addr);
61 changed_addr = br_stp_recalculate_bridge_id(br);
62 spin_unlock_bh(&br->lock);
63
64 if (changed_addr)
65 call_netdevice_notifiers(NETDEV_CHANGEADDR, br->dev);
66
67 break;
68
69 case NETDEV_CHANGE:
70 br_port_carrier_check(p);
71 break;
72
73 case NETDEV_FEAT_CHANGE:
74 netdev_update_features(br->dev);
75 break;
76
77 case NETDEV_DOWN:
78 spin_lock_bh(&br->lock);
79 if (br->dev->flags & IFF_UP)
80 br_stp_disable_port(p);
81 spin_unlock_bh(&br->lock);
82 break;
83
84 case NETDEV_UP:
85 if (netif_running(br->dev) && netif_oper_up(dev)) {
86 spin_lock_bh(&br->lock);
87 br_stp_enable_port(p);
88 spin_unlock_bh(&br->lock);
89 }
90 break;
91
92 case NETDEV_UNREGISTER:
93 br_del_if(br, dev);
94 break;
95
96 case NETDEV_CHANGENAME:
97 err = br_sysfs_renameif(p);
98 if (err)
99 return notifier_from_errno(err);
100 break;
101
102 case NETDEV_PRE_TYPE_CHANGE:
103 /* Forbid underlaying device to change its type. */
104 return NOTIFY_BAD;
105
106 case NETDEV_RESEND_IGMP:
107 /* Propagate to master device */
108 call_netdevice_notifiers(event, br->dev);
109 break;
110 }
111
112 /* Events that may cause spanning tree to refresh */
113 if (event == NETDEV_CHANGEADDR || event == NETDEV_UP ||
114 event == NETDEV_CHANGE || event == NETDEV_DOWN)
115 br_ifinfo_notify(RTM_NEWLINK, p);
116
117 return NOTIFY_DONE;
118}
119
120static struct notifier_block br_device_notifier = {
121 .notifier_call = br_device_event
122};
123
124/* called with RTNL */
125static int br_switchdev_event(struct notifier_block *unused,
126 unsigned long event, void *ptr)
127{
128 struct net_device *dev = switchdev_notifier_info_to_dev(ptr);
129 struct net_bridge_port *p;
130 struct net_bridge *br;
131 struct switchdev_notifier_fdb_info *fdb_info;
132 int err = NOTIFY_DONE;
133
134 p = br_port_get_rtnl(dev);
135 if (!p)
136 goto out;
137
138 br = p->br;
139
140 switch (event) {
141 case SWITCHDEV_FDB_ADD:
142 fdb_info = ptr;
143 err = br_fdb_external_learn_add(br, p, fdb_info->addr,
144 fdb_info->vid);
145 if (err)
146 err = notifier_from_errno(err);
147 break;
148 case SWITCHDEV_FDB_DEL:
149 fdb_info = ptr;
150 err = br_fdb_external_learn_del(br, p, fdb_info->addr,
151 fdb_info->vid);
152 if (err)
153 err = notifier_from_errno(err);
154 break;
155 }
156
157out:
158 return err;
159}
160
161static struct notifier_block br_switchdev_notifier = {
162 .notifier_call = br_switchdev_event,
163};
164
165static void __net_exit br_net_exit(struct net *net)
166{
167 struct net_device *dev;
168 LIST_HEAD(list);
169
170 rtnl_lock();
171 for_each_netdev(net, dev)
172 if (dev->priv_flags & IFF_EBRIDGE)
173 br_dev_delete(dev, &list);
174
175 unregister_netdevice_many(&list);
176 rtnl_unlock();
177
178}
179
180static struct pernet_operations br_net_ops = {
181 .exit = br_net_exit,
182};
183
184static const struct stp_proto br_stp_proto = {
185 .rcv = br_stp_rcv,
186};
187
188static int __init br_init(void)
189{
190 int err;
191
192 BUILD_BUG_ON(sizeof(struct br_input_skb_cb) > FIELD_SIZEOF(struct sk_buff, cb));
193
194 err = stp_proto_register(&br_stp_proto);
195 if (err < 0) {
196 pr_err("bridge: can't register sap for STP\n");
197 return err;
198 }
199
200 err = br_fdb_init();
201 if (err)
202 goto err_out;
203
204 err = register_pernet_subsys(&br_net_ops);
205 if (err)
206 goto err_out1;
207
208 err = br_nf_core_init();
209 if (err)
210 goto err_out2;
211
212 err = register_netdevice_notifier(&br_device_notifier);
213 if (err)
214 goto err_out3;
215
216 err = register_switchdev_notifier(&br_switchdev_notifier);
217 if (err)
218 goto err_out4;
219
220 err = br_netlink_init();
221 if (err)
222 goto err_out5;
223
224 brioctl_set(br_ioctl_deviceless_stub);
225
226#if IS_ENABLED(CONFIG_ATM_LANE)
227 br_fdb_test_addr_hook = br_fdb_test_addr;
228#endif
229
230 pr_info("bridge: automatic filtering via arp/ip/ip6tables has been "
231 "deprecated. Update your scripts to load br_netfilter if you "
232 "need this.\n");
233
234 return 0;
235
236err_out5:
237 unregister_switchdev_notifier(&br_switchdev_notifier);
238err_out4:
239 unregister_netdevice_notifier(&br_device_notifier);
240err_out3:
241 br_nf_core_fini();
242err_out2:
243 unregister_pernet_subsys(&br_net_ops);
244err_out1:
245 br_fdb_fini();
246err_out:
247 stp_proto_unregister(&br_stp_proto);
248 return err;
249}
250
251static void __exit br_deinit(void)
252{
253 stp_proto_unregister(&br_stp_proto);
254 br_netlink_fini();
255 unregister_switchdev_notifier(&br_switchdev_notifier);
256 unregister_netdevice_notifier(&br_device_notifier);
257 brioctl_set(NULL);
258 unregister_pernet_subsys(&br_net_ops);
259
260 rcu_barrier(); /* Wait for completion of call_rcu()'s */
261
262 br_nf_core_fini();
263#if IS_ENABLED(CONFIG_ATM_LANE)
264 br_fdb_test_addr_hook = NULL;
265#endif
266 br_fdb_fini();
267}
268
269module_init(br_init)
270module_exit(br_deinit)
271MODULE_LICENSE("GPL");
272MODULE_VERSION(BR_VERSION);
273MODULE_ALIAS_RTNL_LINK("bridge");
1/*
2 * Generic parts
3 * Linux ethernet bridge
4 *
5 * Authors:
6 * Lennert Buytenhek <buytenh@gnu.org>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version
11 * 2 of the License, or (at your option) any later version.
12 */
13
14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/netdevice.h>
17#include <linux/etherdevice.h>
18#include <linux/init.h>
19#include <linux/llc.h>
20#include <net/llc.h>
21#include <net/stp.h>
22
23#include "br_private.h"
24
25static const struct stp_proto br_stp_proto = {
26 .rcv = br_stp_rcv,
27};
28
29static struct pernet_operations br_net_ops = {
30 .exit = br_net_exit,
31};
32
33static int __init br_init(void)
34{
35 int err;
36
37 err = stp_proto_register(&br_stp_proto);
38 if (err < 0) {
39 pr_err("bridge: can't register sap for STP\n");
40 return err;
41 }
42
43 err = br_fdb_init();
44 if (err)
45 goto err_out;
46
47 err = register_pernet_subsys(&br_net_ops);
48 if (err)
49 goto err_out1;
50
51 err = br_netfilter_init();
52 if (err)
53 goto err_out2;
54
55 err = register_netdevice_notifier(&br_device_notifier);
56 if (err)
57 goto err_out3;
58
59 err = br_netlink_init();
60 if (err)
61 goto err_out4;
62
63 brioctl_set(br_ioctl_deviceless_stub);
64
65#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
66 br_fdb_test_addr_hook = br_fdb_test_addr;
67#endif
68
69 return 0;
70err_out4:
71 unregister_netdevice_notifier(&br_device_notifier);
72err_out3:
73 br_netfilter_fini();
74err_out2:
75 unregister_pernet_subsys(&br_net_ops);
76err_out1:
77 br_fdb_fini();
78err_out:
79 stp_proto_unregister(&br_stp_proto);
80 return err;
81}
82
83static void __exit br_deinit(void)
84{
85 stp_proto_unregister(&br_stp_proto);
86
87 br_netlink_fini();
88 unregister_netdevice_notifier(&br_device_notifier);
89 brioctl_set(NULL);
90
91 unregister_pernet_subsys(&br_net_ops);
92
93 rcu_barrier(); /* Wait for completion of call_rcu()'s */
94
95 br_netfilter_fini();
96#if defined(CONFIG_ATM_LANE) || defined(CONFIG_ATM_LANE_MODULE)
97 br_fdb_test_addr_hook = NULL;
98#endif
99
100 br_fdb_fini();
101}
102
103module_init(br_init)
104module_exit(br_deinit)
105MODULE_LICENSE("GPL");
106MODULE_VERSION(BR_VERSION);
107MODULE_ALIAS_RTNL_LINK("bridge");