xref: /openbmc/linux/net/bridge/br.c (revision b830f94f)
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, &notified);
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