1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *	Device handling code
4  *	Linux ethernet bridge
5  *
6  *	Authors:
7  *	Lennert Buytenhek		<buytenh@gnu.org>
8  */
9 
10 #include <linux/kernel.h>
11 #include <linux/netdevice.h>
12 #include <linux/netpoll.h>
13 #include <linux/etherdevice.h>
14 #include <linux/ethtool.h>
15 #include <linux/list.h>
16 #include <linux/netfilter_bridge.h>
17 
18 #include <linux/uaccess.h>
19 #include "br_private.h"
20 
21 #define COMMON_FEATURES (NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | \
22 			 NETIF_F_GSO_MASK | NETIF_F_HW_CSUM)
23 
24 const struct nf_br_ops __rcu *nf_br_ops __read_mostly;
25 EXPORT_SYMBOL_GPL(nf_br_ops);
26 
27 /* net device transmit always called with BH disabled */
br_dev_xmit(struct sk_buff * skb,struct net_device * dev)28 netdev_tx_t br_dev_xmit(struct sk_buff *skb, struct net_device *dev)
29 {
30 	struct net_bridge *br = netdev_priv(dev);
31 	struct net_bridge_fdb_entry *dst;
32 	struct net_bridge_mdb_entry *mdst;
33 	struct pcpu_sw_netstats *brstats = this_cpu_ptr(br->stats);
34 	const struct nf_br_ops *nf_ops;
35 	u8 state = BR_STATE_FORWARDING;
36 	const unsigned char *dest;
37 	u16 vid = 0;
38 
39 	memset(skb->cb, 0, sizeof(struct br_input_skb_cb));
40 
41 	rcu_read_lock();
42 	nf_ops = rcu_dereference(nf_br_ops);
43 	if (nf_ops && nf_ops->br_dev_xmit_hook(skb)) {
44 		rcu_read_unlock();
45 		return NETDEV_TX_OK;
46 	}
47 
48 	u64_stats_update_begin(&brstats->syncp);
49 	brstats->tx_packets++;
50 	brstats->tx_bytes += skb->len;
51 	u64_stats_update_end(&brstats->syncp);
52 
53 	br_switchdev_frame_unmark(skb);
54 	BR_INPUT_SKB_CB(skb)->brdev = dev;
55 	BR_INPUT_SKB_CB(skb)->frag_max_size = 0;
56 
57 	skb_reset_mac_header(skb);
58 	skb_pull(skb, ETH_HLEN);
59 
60 	if (!br_allowed_ingress(br, br_vlan_group_rcu(br), skb, &vid, &state))
61 		goto out;
62 
63 	if (IS_ENABLED(CONFIG_INET) &&
64 	    (eth_hdr(skb)->h_proto == htons(ETH_P_ARP) ||
65 	     eth_hdr(skb)->h_proto == htons(ETH_P_RARP)) &&
66 	    br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED)) {
67 		br_do_proxy_suppress_arp(skb, br, vid, NULL);
68 	} else if (IS_ENABLED(CONFIG_IPV6) &&
69 		   skb->protocol == htons(ETH_P_IPV6) &&
70 		   br_opt_get(br, BROPT_NEIGH_SUPPRESS_ENABLED) &&
71 		   pskb_may_pull(skb, sizeof(struct ipv6hdr) +
72 				 sizeof(struct nd_msg)) &&
73 		   ipv6_hdr(skb)->nexthdr == IPPROTO_ICMPV6) {
74 			struct nd_msg *msg, _msg;
75 
76 			msg = br_is_nd_neigh_msg(skb, &_msg);
77 			if (msg)
78 				br_do_suppress_nd(skb, br, vid, NULL, msg);
79 	}
80 
81 	dest = eth_hdr(skb)->h_dest;
82 	if (is_broadcast_ether_addr(dest)) {
83 		br_flood(br, skb, BR_PKT_BROADCAST, false, true);
84 	} else if (is_multicast_ether_addr(dest)) {
85 		if (unlikely(netpoll_tx_running(dev))) {
86 			br_flood(br, skb, BR_PKT_MULTICAST, false, true);
87 			goto out;
88 		}
89 		if (br_multicast_rcv(br, NULL, skb, vid)) {
90 			kfree_skb(skb);
91 			goto out;
92 		}
93 
94 		mdst = br_mdb_get(br, skb, vid);
95 		if ((mdst || BR_INPUT_SKB_CB_MROUTERS_ONLY(skb)) &&
96 		    br_multicast_querier_exists(br, eth_hdr(skb)))
97 			br_multicast_flood(mdst, skb, false, true);
98 		else
99 			br_flood(br, skb, BR_PKT_MULTICAST, false, true);
100 	} else if ((dst = br_fdb_find_rcu(br, dest, vid)) != NULL) {
101 		br_forward(dst->dst, skb, false, true);
102 	} else {
103 		br_flood(br, skb, BR_PKT_UNICAST, false, true);
104 	}
105 out:
106 	rcu_read_unlock();
107 	return NETDEV_TX_OK;
108 }
109 
110 static struct lock_class_key bridge_netdev_addr_lock_key;
111 
br_set_lockdep_class(struct net_device * dev)112 static void br_set_lockdep_class(struct net_device *dev)
113 {
114 	lockdep_set_class(&dev->addr_list_lock, &bridge_netdev_addr_lock_key);
115 }
116 
br_dev_init(struct net_device * dev)117 static int br_dev_init(struct net_device *dev)
118 {
119 	struct net_bridge *br = netdev_priv(dev);
120 	int err;
121 
122 	br->stats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
123 	if (!br->stats)
124 		return -ENOMEM;
125 
126 	err = br_fdb_hash_init(br);
127 	if (err) {
128 		free_percpu(br->stats);
129 		return err;
130 	}
131 
132 	err = br_mdb_hash_init(br);
133 	if (err) {
134 		free_percpu(br->stats);
135 		br_fdb_hash_fini(br);
136 		return err;
137 	}
138 
139 	err = br_vlan_init(br);
140 	if (err) {
141 		free_percpu(br->stats);
142 		br_mdb_hash_fini(br);
143 		br_fdb_hash_fini(br);
144 		return err;
145 	}
146 
147 	err = br_multicast_init_stats(br);
148 	if (err) {
149 		free_percpu(br->stats);
150 		br_vlan_flush(br);
151 		br_mdb_hash_fini(br);
152 		br_fdb_hash_fini(br);
153 	}
154 
155 	br_set_lockdep_class(dev);
156 	return err;
157 }
158 
br_dev_uninit(struct net_device * dev)159 static void br_dev_uninit(struct net_device *dev)
160 {
161 	struct net_bridge *br = netdev_priv(dev);
162 
163 	br_multicast_dev_del(br);
164 	br_multicast_uninit_stats(br);
165 	br_vlan_flush(br);
166 	br_mdb_hash_fini(br);
167 	br_fdb_hash_fini(br);
168 	free_percpu(br->stats);
169 }
170 
br_dev_open(struct net_device * dev)171 static int br_dev_open(struct net_device *dev)
172 {
173 	struct net_bridge *br = netdev_priv(dev);
174 
175 	netdev_update_features(dev);
176 	netif_start_queue(dev);
177 	br_stp_enable_bridge(br);
178 	br_multicast_open(br);
179 
180 	if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
181 		br_multicast_join_snoopers(br);
182 
183 	return 0;
184 }
185 
br_dev_set_multicast_list(struct net_device * dev)186 static void br_dev_set_multicast_list(struct net_device *dev)
187 {
188 }
189 
br_dev_change_rx_flags(struct net_device * dev,int change)190 static void br_dev_change_rx_flags(struct net_device *dev, int change)
191 {
192 	if (change & IFF_PROMISC)
193 		br_manage_promisc(netdev_priv(dev));
194 }
195 
br_dev_stop(struct net_device * dev)196 static int br_dev_stop(struct net_device *dev)
197 {
198 	struct net_bridge *br = netdev_priv(dev);
199 
200 	br_stp_disable_bridge(br);
201 	br_multicast_stop(br);
202 
203 	if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
204 		br_multicast_leave_snoopers(br);
205 
206 	netif_stop_queue(dev);
207 
208 	return 0;
209 }
210 
br_get_stats64(struct net_device * dev,struct rtnl_link_stats64 * stats)211 static void br_get_stats64(struct net_device *dev,
212 			   struct rtnl_link_stats64 *stats)
213 {
214 	struct net_bridge *br = netdev_priv(dev);
215 
216 	netdev_stats_to_stats64(stats, &dev->stats);
217 	dev_fetch_sw_netstats(stats, br->stats);
218 }
219 
br_change_mtu(struct net_device * dev,int new_mtu)220 static int br_change_mtu(struct net_device *dev, int new_mtu)
221 {
222 	struct net_bridge *br = netdev_priv(dev);
223 
224 	dev->mtu = new_mtu;
225 
226 	/* this flag will be cleared if the MTU was automatically adjusted */
227 	br_opt_toggle(br, BROPT_MTU_SET_BY_USER, true);
228 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
229 	/* remember the MTU in the rtable for PMTU */
230 	dst_metric_set(&br->fake_rtable.dst, RTAX_MTU, new_mtu);
231 #endif
232 
233 	return 0;
234 }
235 
236 /* Allow setting mac address to any valid ethernet address. */
br_set_mac_address(struct net_device * dev,void * p)237 static int br_set_mac_address(struct net_device *dev, void *p)
238 {
239 	struct net_bridge *br = netdev_priv(dev);
240 	struct sockaddr *addr = p;
241 
242 	if (!is_valid_ether_addr(addr->sa_data))
243 		return -EADDRNOTAVAIL;
244 
245 	/* dev_set_mac_addr() can be called by a master device on bridge's
246 	 * NETDEV_UNREGISTER, but since it's being destroyed do nothing
247 	 */
248 	if (dev->reg_state != NETREG_REGISTERED)
249 		return -EBUSY;
250 
251 	spin_lock_bh(&br->lock);
252 	if (!ether_addr_equal(dev->dev_addr, addr->sa_data)) {
253 		/* Mac address will be changed in br_stp_change_bridge_id(). */
254 		br_stp_change_bridge_id(br, addr->sa_data);
255 	}
256 	spin_unlock_bh(&br->lock);
257 
258 	return 0;
259 }
260 
br_getinfo(struct net_device * dev,struct ethtool_drvinfo * info)261 static void br_getinfo(struct net_device *dev, struct ethtool_drvinfo *info)
262 {
263 	strlcpy(info->driver, "bridge", sizeof(info->driver));
264 	strlcpy(info->version, BR_VERSION, sizeof(info->version));
265 	strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
266 	strlcpy(info->bus_info, "N/A", sizeof(info->bus_info));
267 }
268 
br_get_link_ksettings(struct net_device * dev,struct ethtool_link_ksettings * cmd)269 static int br_get_link_ksettings(struct net_device *dev,
270 				 struct ethtool_link_ksettings *cmd)
271 {
272 	struct net_bridge *br = netdev_priv(dev);
273 	struct net_bridge_port *p;
274 
275 	cmd->base.duplex = DUPLEX_UNKNOWN;
276 	cmd->base.port = PORT_OTHER;
277 	cmd->base.speed = SPEED_UNKNOWN;
278 
279 	list_for_each_entry(p, &br->port_list, list) {
280 		struct ethtool_link_ksettings ecmd;
281 		struct net_device *pdev = p->dev;
282 
283 		if (!netif_running(pdev) || !netif_oper_up(pdev))
284 			continue;
285 
286 		if (__ethtool_get_link_ksettings(pdev, &ecmd))
287 			continue;
288 
289 		if (ecmd.base.speed == (__u32)SPEED_UNKNOWN)
290 			continue;
291 
292 		if (cmd->base.speed == (__u32)SPEED_UNKNOWN ||
293 		    cmd->base.speed < ecmd.base.speed)
294 			cmd->base.speed = ecmd.base.speed;
295 	}
296 
297 	return 0;
298 }
299 
br_fix_features(struct net_device * dev,netdev_features_t features)300 static netdev_features_t br_fix_features(struct net_device *dev,
301 	netdev_features_t features)
302 {
303 	struct net_bridge *br = netdev_priv(dev);
304 
305 	return br_features_recompute(br, features);
306 }
307 
308 #ifdef CONFIG_NET_POLL_CONTROLLER
br_poll_controller(struct net_device * br_dev)309 static void br_poll_controller(struct net_device *br_dev)
310 {
311 }
312 
br_netpoll_cleanup(struct net_device * dev)313 static void br_netpoll_cleanup(struct net_device *dev)
314 {
315 	struct net_bridge *br = netdev_priv(dev);
316 	struct net_bridge_port *p;
317 
318 	list_for_each_entry(p, &br->port_list, list)
319 		br_netpoll_disable(p);
320 }
321 
__br_netpoll_enable(struct net_bridge_port * p)322 static int __br_netpoll_enable(struct net_bridge_port *p)
323 {
324 	struct netpoll *np;
325 	int err;
326 
327 	np = kzalloc(sizeof(*p->np), GFP_KERNEL);
328 	if (!np)
329 		return -ENOMEM;
330 
331 	err = __netpoll_setup(np, p->dev);
332 	if (err) {
333 		kfree(np);
334 		return err;
335 	}
336 
337 	p->np = np;
338 	return err;
339 }
340 
br_netpoll_enable(struct net_bridge_port * p)341 int br_netpoll_enable(struct net_bridge_port *p)
342 {
343 	if (!p->br->dev->npinfo)
344 		return 0;
345 
346 	return __br_netpoll_enable(p);
347 }
348 
br_netpoll_setup(struct net_device * dev,struct netpoll_info * ni)349 static int br_netpoll_setup(struct net_device *dev, struct netpoll_info *ni)
350 {
351 	struct net_bridge *br = netdev_priv(dev);
352 	struct net_bridge_port *p;
353 	int err = 0;
354 
355 	list_for_each_entry(p, &br->port_list, list) {
356 		if (!p->dev)
357 			continue;
358 		err = __br_netpoll_enable(p);
359 		if (err)
360 			goto fail;
361 	}
362 
363 out:
364 	return err;
365 
366 fail:
367 	br_netpoll_cleanup(dev);
368 	goto out;
369 }
370 
br_netpoll_disable(struct net_bridge_port * p)371 void br_netpoll_disable(struct net_bridge_port *p)
372 {
373 	struct netpoll *np = p->np;
374 
375 	if (!np)
376 		return;
377 
378 	p->np = NULL;
379 
380 	__netpoll_free(np);
381 }
382 
383 #endif
384 
br_add_slave(struct net_device * dev,struct net_device * slave_dev,struct netlink_ext_ack * extack)385 static int br_add_slave(struct net_device *dev, struct net_device *slave_dev,
386 			struct netlink_ext_ack *extack)
387 
388 {
389 	struct net_bridge *br = netdev_priv(dev);
390 
391 	return br_add_if(br, slave_dev, extack);
392 }
393 
br_del_slave(struct net_device * dev,struct net_device * slave_dev)394 static int br_del_slave(struct net_device *dev, struct net_device *slave_dev)
395 {
396 	struct net_bridge *br = netdev_priv(dev);
397 
398 	return br_del_if(br, slave_dev);
399 }
400 
401 static const struct ethtool_ops br_ethtool_ops = {
402 	.get_drvinfo		 = br_getinfo,
403 	.get_link		 = ethtool_op_get_link,
404 	.get_link_ksettings	 = br_get_link_ksettings,
405 };
406 
407 static const struct net_device_ops br_netdev_ops = {
408 	.ndo_open		 = br_dev_open,
409 	.ndo_stop		 = br_dev_stop,
410 	.ndo_init		 = br_dev_init,
411 	.ndo_uninit		 = br_dev_uninit,
412 	.ndo_start_xmit		 = br_dev_xmit,
413 	.ndo_get_stats64	 = br_get_stats64,
414 	.ndo_set_mac_address	 = br_set_mac_address,
415 	.ndo_set_rx_mode	 = br_dev_set_multicast_list,
416 	.ndo_change_rx_flags	 = br_dev_change_rx_flags,
417 	.ndo_change_mtu		 = br_change_mtu,
418 	.ndo_do_ioctl		 = br_dev_ioctl,
419 #ifdef CONFIG_NET_POLL_CONTROLLER
420 	.ndo_netpoll_setup	 = br_netpoll_setup,
421 	.ndo_netpoll_cleanup	 = br_netpoll_cleanup,
422 	.ndo_poll_controller	 = br_poll_controller,
423 #endif
424 	.ndo_add_slave		 = br_add_slave,
425 	.ndo_del_slave		 = br_del_slave,
426 	.ndo_fix_features        = br_fix_features,
427 	.ndo_fdb_add		 = br_fdb_add,
428 	.ndo_fdb_del		 = br_fdb_delete,
429 	.ndo_fdb_dump		 = br_fdb_dump,
430 	.ndo_fdb_get		 = br_fdb_get,
431 	.ndo_bridge_getlink	 = br_getlink,
432 	.ndo_bridge_setlink	 = br_setlink,
433 	.ndo_bridge_dellink	 = br_dellink,
434 	.ndo_features_check	 = passthru_features_check,
435 };
436 
437 static struct device_type br_type = {
438 	.name	= "bridge",
439 };
440 
br_dev_setup(struct net_device * dev)441 void br_dev_setup(struct net_device *dev)
442 {
443 	struct net_bridge *br = netdev_priv(dev);
444 
445 	eth_hw_addr_random(dev);
446 	ether_setup(dev);
447 
448 	dev->netdev_ops = &br_netdev_ops;
449 	dev->needs_free_netdev = true;
450 	dev->ethtool_ops = &br_ethtool_ops;
451 	SET_NETDEV_DEVTYPE(dev, &br_type);
452 	dev->priv_flags = IFF_EBRIDGE | IFF_NO_QUEUE;
453 
454 	dev->features = COMMON_FEATURES | NETIF_F_LLTX | NETIF_F_NETNS_LOCAL |
455 			NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
456 	dev->hw_features = COMMON_FEATURES | NETIF_F_HW_VLAN_CTAG_TX |
457 			   NETIF_F_HW_VLAN_STAG_TX;
458 	dev->vlan_features = COMMON_FEATURES;
459 
460 	br->dev = dev;
461 	spin_lock_init(&br->lock);
462 	INIT_LIST_HEAD(&br->port_list);
463 	INIT_HLIST_HEAD(&br->fdb_list);
464 #if IS_ENABLED(CONFIG_BRIDGE_MRP)
465 	INIT_LIST_HEAD(&br->mrp_list);
466 #endif
467 	spin_lock_init(&br->hash_lock);
468 
469 	br->bridge_id.prio[0] = 0x80;
470 	br->bridge_id.prio[1] = 0x00;
471 
472 	ether_addr_copy(br->group_addr, eth_stp_addr);
473 
474 	br->stp_enabled = BR_NO_STP;
475 	br->group_fwd_mask = BR_GROUPFWD_DEFAULT;
476 	br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT;
477 
478 	br->designated_root = br->bridge_id;
479 	br->bridge_max_age = br->max_age = 20 * HZ;
480 	br->bridge_hello_time = br->hello_time = 2 * HZ;
481 	br->bridge_forward_delay = br->forward_delay = 15 * HZ;
482 	br->bridge_ageing_time = br->ageing_time = BR_DEFAULT_AGEING_TIME;
483 	dev->max_mtu = ETH_MAX_MTU;
484 
485 	br_netfilter_rtable_init(br);
486 	br_stp_timer_init(br);
487 	br_multicast_init(br);
488 	INIT_DELAYED_WORK(&br->gc_work, br_fdb_cleanup);
489 }
490