• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) B.A.T.M.A.N. contributors:
3  *
4  * Marek Lindner, Simon Wunderlich
5  */
6 
7 #include "hard-interface.h"
8 #include "main.h"
9 
10 #include <linux/atomic.h>
11 #include <linux/byteorder/generic.h>
12 #include <linux/compiler.h>
13 #include <linux/container_of.h>
14 #include <linux/errno.h>
15 #include <linux/gfp.h>
16 #include <linux/if.h>
17 #include <linux/if_arp.h>
18 #include <linux/if_ether.h>
19 #include <linux/kref.h>
20 #include <linux/limits.h>
21 #include <linux/list.h>
22 #include <linux/minmax.h>
23 #include <linux/mutex.h>
24 #include <linux/netdevice.h>
25 #include <linux/printk.h>
26 #include <linux/rculist.h>
27 #include <linux/rtnetlink.h>
28 #include <linux/slab.h>
29 #include <linux/spinlock.h>
30 #include <net/net_namespace.h>
31 #include <net/rtnetlink.h>
32 #include <uapi/linux/batadv_packet.h>
33 
34 #include "bat_v.h"
35 #include "bridge_loop_avoidance.h"
36 #include "distributed-arp-table.h"
37 #include "gateway_client.h"
38 #include "log.h"
39 #include "originator.h"
40 #include "send.h"
41 #include "soft-interface.h"
42 #include "translation-table.h"
43 
44 /**
45  * batadv_hardif_release() - release hard interface from lists and queue for
46  *  free after rcu grace period
47  * @ref: kref pointer of the hard interface
48  */
batadv_hardif_release(struct kref * ref)49 void batadv_hardif_release(struct kref *ref)
50 {
51 	struct batadv_hard_iface *hard_iface;
52 
53 	hard_iface = container_of(ref, struct batadv_hard_iface, refcount);
54 	dev_put(hard_iface->net_dev);
55 
56 	kfree_rcu(hard_iface, rcu);
57 }
58 
59 /**
60  * batadv_hardif_get_by_netdev() - Get hard interface object of a net_device
61  * @net_dev: net_device to search for
62  *
63  * Return: batadv_hard_iface of net_dev (with increased refcnt), NULL on errors
64  */
65 struct batadv_hard_iface *
batadv_hardif_get_by_netdev(const struct net_device * net_dev)66 batadv_hardif_get_by_netdev(const struct net_device *net_dev)
67 {
68 	struct batadv_hard_iface *hard_iface;
69 
70 	rcu_read_lock();
71 	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
72 		if (hard_iface->net_dev == net_dev &&
73 		    kref_get_unless_zero(&hard_iface->refcount))
74 			goto out;
75 	}
76 
77 	hard_iface = NULL;
78 
79 out:
80 	rcu_read_unlock();
81 	return hard_iface;
82 }
83 
84 /**
85  * batadv_getlink_net() - return link net namespace (of use fallback)
86  * @netdev: net_device to check
87  * @fallback_net: return in case get_link_net is not available for @netdev
88  *
89  * Return: result of rtnl_link_ops->get_link_net or @fallback_net
90  */
batadv_getlink_net(const struct net_device * netdev,struct net * fallback_net)91 static struct net *batadv_getlink_net(const struct net_device *netdev,
92 				      struct net *fallback_net)
93 {
94 	if (!netdev->rtnl_link_ops)
95 		return fallback_net;
96 
97 	if (!netdev->rtnl_link_ops->get_link_net)
98 		return fallback_net;
99 
100 	return netdev->rtnl_link_ops->get_link_net(netdev);
101 }
102 
103 /**
104  * batadv_mutual_parents() - check if two devices are each others parent
105  * @dev1: 1st net dev
106  * @net1: 1st devices netns
107  * @dev2: 2nd net dev
108  * @net2: 2nd devices netns
109  *
110  * veth devices come in pairs and each is the parent of the other!
111  *
112  * Return: true if the devices are each others parent, otherwise false
113  */
batadv_mutual_parents(const struct net_device * dev1,struct net * net1,const struct net_device * dev2,struct net * net2)114 static bool batadv_mutual_parents(const struct net_device *dev1,
115 				  struct net *net1,
116 				  const struct net_device *dev2,
117 				  struct net *net2)
118 {
119 	int dev1_parent_iflink = dev_get_iflink(dev1);
120 	int dev2_parent_iflink = dev_get_iflink(dev2);
121 	const struct net *dev1_parent_net;
122 	const struct net *dev2_parent_net;
123 
124 	dev1_parent_net = batadv_getlink_net(dev1, net1);
125 	dev2_parent_net = batadv_getlink_net(dev2, net2);
126 
127 	if (!dev1_parent_iflink || !dev2_parent_iflink)
128 		return false;
129 
130 	return (dev1_parent_iflink == dev2->ifindex) &&
131 	       (dev2_parent_iflink == dev1->ifindex) &&
132 	       net_eq(dev1_parent_net, net2) &&
133 	       net_eq(dev2_parent_net, net1);
134 }
135 
136 /**
137  * batadv_is_on_batman_iface() - check if a device is a batman iface descendant
138  * @net_dev: the device to check
139  *
140  * If the user creates any virtual device on top of a batman-adv interface, it
141  * is important to prevent this new interface from being used to create a new
142  * mesh network (this behaviour would lead to a batman-over-batman
143  * configuration). This function recursively checks all the fathers of the
144  * device passed as argument looking for a batman-adv soft interface.
145  *
146  * Return: true if the device is descendant of a batman-adv mesh interface (or
147  * if it is a batman-adv interface itself), false otherwise
148  */
batadv_is_on_batman_iface(const struct net_device * net_dev)149 static bool batadv_is_on_batman_iface(const struct net_device *net_dev)
150 {
151 	struct net *net = dev_net(net_dev);
152 	struct net_device *parent_dev;
153 	struct net *parent_net;
154 	int iflink;
155 	bool ret;
156 
157 	/* check if this is a batman-adv mesh interface */
158 	if (batadv_softif_is_valid(net_dev))
159 		return true;
160 
161 	iflink = dev_get_iflink(net_dev);
162 	if (iflink == 0)
163 		return false;
164 
165 	parent_net = batadv_getlink_net(net_dev, net);
166 
167 	/* iflink to itself, most likely physical device */
168 	if (net == parent_net && iflink == net_dev->ifindex)
169 		return false;
170 
171 	/* recurse over the parent device */
172 	parent_dev = __dev_get_by_index((struct net *)parent_net, iflink);
173 	if (!parent_dev) {
174 		pr_warn("Cannot find parent device. Skipping batadv-on-batadv check for %s\n",
175 			net_dev->name);
176 		return false;
177 	}
178 
179 	if (batadv_mutual_parents(net_dev, net, parent_dev, parent_net))
180 		return false;
181 
182 	ret = batadv_is_on_batman_iface(parent_dev);
183 
184 	return ret;
185 }
186 
batadv_is_valid_iface(const struct net_device * net_dev)187 static bool batadv_is_valid_iface(const struct net_device *net_dev)
188 {
189 	if (net_dev->flags & IFF_LOOPBACK)
190 		return false;
191 
192 	if (net_dev->type != ARPHRD_ETHER)
193 		return false;
194 
195 	if (net_dev->addr_len != ETH_ALEN)
196 		return false;
197 
198 	/* no batman over batman */
199 	if (batadv_is_on_batman_iface(net_dev))
200 		return false;
201 
202 	return true;
203 }
204 
205 /**
206  * batadv_get_real_netdevice() - check if the given netdev struct is a virtual
207  *  interface on top of another 'real' interface
208  * @netdev: the device to check
209  *
210  * Callers must hold the rtnl semaphore. You may want batadv_get_real_netdev()
211  * instead of this.
212  *
213  * Return: the 'real' net device or the original net device and NULL in case
214  *  of an error.
215  */
batadv_get_real_netdevice(struct net_device * netdev)216 static struct net_device *batadv_get_real_netdevice(struct net_device *netdev)
217 {
218 	struct batadv_hard_iface *hard_iface = NULL;
219 	struct net_device *real_netdev = NULL;
220 	struct net *real_net;
221 	struct net *net;
222 	int iflink;
223 
224 	ASSERT_RTNL();
225 
226 	if (!netdev)
227 		return NULL;
228 
229 	iflink = dev_get_iflink(netdev);
230 	if (iflink == 0) {
231 		dev_hold(netdev);
232 		return netdev;
233 	}
234 
235 	hard_iface = batadv_hardif_get_by_netdev(netdev);
236 	if (!hard_iface || !hard_iface->soft_iface)
237 		goto out;
238 
239 	net = dev_net(hard_iface->soft_iface);
240 	real_net = batadv_getlink_net(netdev, net);
241 
242 	/* iflink to itself, most likely physical device */
243 	if (net == real_net && netdev->ifindex == iflink) {
244 		real_netdev = netdev;
245 		dev_hold(real_netdev);
246 		goto out;
247 	}
248 
249 	real_netdev = dev_get_by_index(real_net, iflink);
250 
251 out:
252 	batadv_hardif_put(hard_iface);
253 	return real_netdev;
254 }
255 
256 /**
257  * batadv_get_real_netdev() - check if the given net_device struct is a virtual
258  *  interface on top of another 'real' interface
259  * @net_device: the device to check
260  *
261  * Return: the 'real' net device or the original net device and NULL in case
262  *  of an error.
263  */
batadv_get_real_netdev(struct net_device * net_device)264 struct net_device *batadv_get_real_netdev(struct net_device *net_device)
265 {
266 	struct net_device *real_netdev;
267 
268 	rtnl_lock();
269 	real_netdev = batadv_get_real_netdevice(net_device);
270 	rtnl_unlock();
271 
272 	return real_netdev;
273 }
274 
275 /**
276  * batadv_is_wext_netdev() - check if the given net_device struct is a
277  *  wext wifi interface
278  * @net_device: the device to check
279  *
280  * Return: true if the net device is a wext wireless device, false
281  *  otherwise.
282  */
batadv_is_wext_netdev(struct net_device * net_device)283 static bool batadv_is_wext_netdev(struct net_device *net_device)
284 {
285 	if (!net_device)
286 		return false;
287 
288 #ifdef CONFIG_WIRELESS_EXT
289 	/* pre-cfg80211 drivers have to implement WEXT, so it is possible to
290 	 * check for wireless_handlers != NULL
291 	 */
292 	if (net_device->wireless_handlers)
293 		return true;
294 #endif
295 
296 	return false;
297 }
298 
299 /**
300  * batadv_is_cfg80211_netdev() - check if the given net_device struct is a
301  *  cfg80211 wifi interface
302  * @net_device: the device to check
303  *
304  * Return: true if the net device is a cfg80211 wireless device, false
305  *  otherwise.
306  */
batadv_is_cfg80211_netdev(struct net_device * net_device)307 static bool batadv_is_cfg80211_netdev(struct net_device *net_device)
308 {
309 	if (!net_device)
310 		return false;
311 
312 	/* cfg80211 drivers have to set ieee80211_ptr */
313 	if (net_device->ieee80211_ptr)
314 		return true;
315 
316 	return false;
317 }
318 
319 /**
320  * batadv_wifi_flags_evaluate() - calculate wifi flags for net_device
321  * @net_device: the device to check
322  *
323  * Return: batadv_hard_iface_wifi_flags flags of the device
324  */
batadv_wifi_flags_evaluate(struct net_device * net_device)325 static u32 batadv_wifi_flags_evaluate(struct net_device *net_device)
326 {
327 	u32 wifi_flags = 0;
328 	struct net_device *real_netdev;
329 
330 	if (batadv_is_wext_netdev(net_device))
331 		wifi_flags |= BATADV_HARDIF_WIFI_WEXT_DIRECT;
332 
333 	if (batadv_is_cfg80211_netdev(net_device))
334 		wifi_flags |= BATADV_HARDIF_WIFI_CFG80211_DIRECT;
335 
336 	real_netdev = batadv_get_real_netdevice(net_device);
337 	if (!real_netdev)
338 		return wifi_flags;
339 
340 	if (real_netdev == net_device)
341 		goto out;
342 
343 	if (batadv_is_wext_netdev(real_netdev))
344 		wifi_flags |= BATADV_HARDIF_WIFI_WEXT_INDIRECT;
345 
346 	if (batadv_is_cfg80211_netdev(real_netdev))
347 		wifi_flags |= BATADV_HARDIF_WIFI_CFG80211_INDIRECT;
348 
349 out:
350 	dev_put(real_netdev);
351 	return wifi_flags;
352 }
353 
354 /**
355  * batadv_is_cfg80211_hardif() - check if the given hardif is a cfg80211 wifi
356  *  interface
357  * @hard_iface: the device to check
358  *
359  * Return: true if the net device is a cfg80211 wireless device, false
360  *  otherwise.
361  */
batadv_is_cfg80211_hardif(struct batadv_hard_iface * hard_iface)362 bool batadv_is_cfg80211_hardif(struct batadv_hard_iface *hard_iface)
363 {
364 	u32 allowed_flags = 0;
365 
366 	allowed_flags |= BATADV_HARDIF_WIFI_CFG80211_DIRECT;
367 	allowed_flags |= BATADV_HARDIF_WIFI_CFG80211_INDIRECT;
368 
369 	return !!(hard_iface->wifi_flags & allowed_flags);
370 }
371 
372 /**
373  * batadv_is_wifi_hardif() - check if the given hardif is a wifi interface
374  * @hard_iface: the device to check
375  *
376  * Return: true if the net device is a 802.11 wireless device, false otherwise.
377  */
batadv_is_wifi_hardif(struct batadv_hard_iface * hard_iface)378 bool batadv_is_wifi_hardif(struct batadv_hard_iface *hard_iface)
379 {
380 	if (!hard_iface)
381 		return false;
382 
383 	return hard_iface->wifi_flags != 0;
384 }
385 
386 /**
387  * batadv_hardif_no_broadcast() - check whether (re)broadcast is necessary
388  * @if_outgoing: the outgoing interface checked and considered for (re)broadcast
389  * @orig_addr: the originator of this packet
390  * @orig_neigh: originator address of the forwarder we just got the packet from
391  *  (NULL if we originated)
392  *
393  * Checks whether a packet needs to be (re)broadcasted on the given interface.
394  *
395  * Return:
396  *	BATADV_HARDIF_BCAST_NORECIPIENT: No neighbor on interface
397  *	BATADV_HARDIF_BCAST_DUPFWD: Just one neighbor, but it is the forwarder
398  *	BATADV_HARDIF_BCAST_DUPORIG: Just one neighbor, but it is the originator
399  *	BATADV_HARDIF_BCAST_OK: Several neighbors, must broadcast
400  */
batadv_hardif_no_broadcast(struct batadv_hard_iface * if_outgoing,u8 * orig_addr,u8 * orig_neigh)401 int batadv_hardif_no_broadcast(struct batadv_hard_iface *if_outgoing,
402 			       u8 *orig_addr, u8 *orig_neigh)
403 {
404 	struct batadv_hardif_neigh_node *hardif_neigh;
405 	struct hlist_node *first;
406 	int ret = BATADV_HARDIF_BCAST_OK;
407 
408 	rcu_read_lock();
409 
410 	/* 0 neighbors -> no (re)broadcast */
411 	first = rcu_dereference(hlist_first_rcu(&if_outgoing->neigh_list));
412 	if (!first) {
413 		ret = BATADV_HARDIF_BCAST_NORECIPIENT;
414 		goto out;
415 	}
416 
417 	/* >1 neighbors -> (re)broadcast */
418 	if (rcu_dereference(hlist_next_rcu(first)))
419 		goto out;
420 
421 	hardif_neigh = hlist_entry(first, struct batadv_hardif_neigh_node,
422 				   list);
423 
424 	/* 1 neighbor, is the originator -> no rebroadcast */
425 	if (orig_addr && batadv_compare_eth(hardif_neigh->orig, orig_addr)) {
426 		ret = BATADV_HARDIF_BCAST_DUPORIG;
427 	/* 1 neighbor, is the one we received from -> no rebroadcast */
428 	} else if (orig_neigh &&
429 		   batadv_compare_eth(hardif_neigh->orig, orig_neigh)) {
430 		ret = BATADV_HARDIF_BCAST_DUPFWD;
431 	}
432 
433 out:
434 	rcu_read_unlock();
435 	return ret;
436 }
437 
438 static struct batadv_hard_iface *
batadv_hardif_get_active(const struct net_device * soft_iface)439 batadv_hardif_get_active(const struct net_device *soft_iface)
440 {
441 	struct batadv_hard_iface *hard_iface;
442 
443 	rcu_read_lock();
444 	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
445 		if (hard_iface->soft_iface != soft_iface)
446 			continue;
447 
448 		if (hard_iface->if_status == BATADV_IF_ACTIVE &&
449 		    kref_get_unless_zero(&hard_iface->refcount))
450 			goto out;
451 	}
452 
453 	hard_iface = NULL;
454 
455 out:
456 	rcu_read_unlock();
457 	return hard_iface;
458 }
459 
batadv_primary_if_update_addr(struct batadv_priv * bat_priv,struct batadv_hard_iface * oldif)460 static void batadv_primary_if_update_addr(struct batadv_priv *bat_priv,
461 					  struct batadv_hard_iface *oldif)
462 {
463 	struct batadv_hard_iface *primary_if;
464 
465 	primary_if = batadv_primary_if_get_selected(bat_priv);
466 	if (!primary_if)
467 		goto out;
468 
469 	batadv_dat_init_own_addr(bat_priv, primary_if);
470 	batadv_bla_update_orig_address(bat_priv, primary_if, oldif);
471 out:
472 	batadv_hardif_put(primary_if);
473 }
474 
batadv_primary_if_select(struct batadv_priv * bat_priv,struct batadv_hard_iface * new_hard_iface)475 static void batadv_primary_if_select(struct batadv_priv *bat_priv,
476 				     struct batadv_hard_iface *new_hard_iface)
477 {
478 	struct batadv_hard_iface *curr_hard_iface;
479 
480 	ASSERT_RTNL();
481 
482 	if (new_hard_iface)
483 		kref_get(&new_hard_iface->refcount);
484 
485 	curr_hard_iface = rcu_replace_pointer(bat_priv->primary_if,
486 					      new_hard_iface, 1);
487 
488 	if (!new_hard_iface)
489 		goto out;
490 
491 	bat_priv->algo_ops->iface.primary_set(new_hard_iface);
492 	batadv_primary_if_update_addr(bat_priv, curr_hard_iface);
493 
494 out:
495 	batadv_hardif_put(curr_hard_iface);
496 }
497 
498 static bool
batadv_hardif_is_iface_up(const struct batadv_hard_iface * hard_iface)499 batadv_hardif_is_iface_up(const struct batadv_hard_iface *hard_iface)
500 {
501 	if (hard_iface->net_dev->flags & IFF_UP)
502 		return true;
503 
504 	return false;
505 }
506 
batadv_check_known_mac_addr(const struct net_device * net_dev)507 static void batadv_check_known_mac_addr(const struct net_device *net_dev)
508 {
509 	const struct batadv_hard_iface *hard_iface;
510 
511 	rcu_read_lock();
512 	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
513 		if (hard_iface->if_status != BATADV_IF_ACTIVE &&
514 		    hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)
515 			continue;
516 
517 		if (hard_iface->net_dev == net_dev)
518 			continue;
519 
520 		if (!batadv_compare_eth(hard_iface->net_dev->dev_addr,
521 					net_dev->dev_addr))
522 			continue;
523 
524 		pr_warn("The newly added mac address (%pM) already exists on: %s\n",
525 			net_dev->dev_addr, hard_iface->net_dev->name);
526 		pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n");
527 	}
528 	rcu_read_unlock();
529 }
530 
531 /**
532  * batadv_hardif_recalc_extra_skbroom() - Recalculate skbuff extra head/tailroom
533  * @soft_iface: netdev struct of the mesh interface
534  */
batadv_hardif_recalc_extra_skbroom(struct net_device * soft_iface)535 static void batadv_hardif_recalc_extra_skbroom(struct net_device *soft_iface)
536 {
537 	const struct batadv_hard_iface *hard_iface;
538 	unsigned short lower_header_len = ETH_HLEN;
539 	unsigned short lower_headroom = 0;
540 	unsigned short lower_tailroom = 0;
541 	unsigned short needed_headroom;
542 
543 	rcu_read_lock();
544 	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
545 		if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
546 			continue;
547 
548 		if (hard_iface->soft_iface != soft_iface)
549 			continue;
550 
551 		lower_header_len = max_t(unsigned short, lower_header_len,
552 					 hard_iface->net_dev->hard_header_len);
553 
554 		lower_headroom = max_t(unsigned short, lower_headroom,
555 				       hard_iface->net_dev->needed_headroom);
556 
557 		lower_tailroom = max_t(unsigned short, lower_tailroom,
558 				       hard_iface->net_dev->needed_tailroom);
559 	}
560 	rcu_read_unlock();
561 
562 	needed_headroom = lower_headroom + (lower_header_len - ETH_HLEN);
563 	needed_headroom += batadv_max_header_len();
564 
565 	/* fragmentation headers don't strip the unicast/... header */
566 	needed_headroom += sizeof(struct batadv_frag_packet);
567 
568 	soft_iface->needed_headroom = needed_headroom;
569 	soft_iface->needed_tailroom = lower_tailroom;
570 }
571 
572 /**
573  * batadv_hardif_min_mtu() - Calculate maximum MTU for soft interface
574  * @soft_iface: netdev struct of the soft interface
575  *
576  * Return: MTU for the soft-interface (limited by the minimal MTU of all active
577  *  slave interfaces)
578  */
batadv_hardif_min_mtu(struct net_device * soft_iface)579 int batadv_hardif_min_mtu(struct net_device *soft_iface)
580 {
581 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
582 	const struct batadv_hard_iface *hard_iface;
583 	int min_mtu = INT_MAX;
584 
585 	rcu_read_lock();
586 	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
587 		if (hard_iface->if_status != BATADV_IF_ACTIVE &&
588 		    hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)
589 			continue;
590 
591 		if (hard_iface->soft_iface != soft_iface)
592 			continue;
593 
594 		min_mtu = min_t(int, hard_iface->net_dev->mtu, min_mtu);
595 	}
596 	rcu_read_unlock();
597 
598 	if (atomic_read(&bat_priv->fragmentation) == 0)
599 		goto out;
600 
601 	/* with fragmentation enabled the maximum size of internally generated
602 	 * packets such as translation table exchanges or tvlv containers, etc
603 	 * has to be calculated
604 	 */
605 	min_mtu = min_t(int, min_mtu, BATADV_FRAG_MAX_FRAG_SIZE);
606 	min_mtu -= sizeof(struct batadv_frag_packet);
607 	min_mtu *= BATADV_FRAG_MAX_FRAGMENTS;
608 
609 out:
610 	/* report to the other components the maximum amount of bytes that
611 	 * batman-adv can send over the wire (without considering the payload
612 	 * overhead). For example, this value is used by TT to compute the
613 	 * maximum local table size
614 	 */
615 	atomic_set(&bat_priv->packet_size_max, min_mtu);
616 
617 	/* the real soft-interface MTU is computed by removing the payload
618 	 * overhead from the maximum amount of bytes that was just computed.
619 	 *
620 	 * However batman-adv does not support MTUs bigger than ETH_DATA_LEN
621 	 */
622 	return min_t(int, min_mtu - batadv_max_header_len(), ETH_DATA_LEN);
623 }
624 
625 /**
626  * batadv_update_min_mtu() - Adjusts the MTU if a new interface with a smaller
627  *  MTU appeared
628  * @soft_iface: netdev struct of the soft interface
629  */
batadv_update_min_mtu(struct net_device * soft_iface)630 void batadv_update_min_mtu(struct net_device *soft_iface)
631 {
632 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
633 	int limit_mtu;
634 	int mtu;
635 
636 	mtu = batadv_hardif_min_mtu(soft_iface);
637 
638 	if (bat_priv->mtu_set_by_user)
639 		limit_mtu = bat_priv->mtu_set_by_user;
640 	else
641 		limit_mtu = ETH_DATA_LEN;
642 
643 	mtu = min(mtu, limit_mtu);
644 	dev_set_mtu(soft_iface, mtu);
645 
646 	/* Check if the local translate table should be cleaned up to match a
647 	 * new (and smaller) MTU.
648 	 */
649 	batadv_tt_local_resize_to_mtu(soft_iface);
650 }
651 
652 static void
batadv_hardif_activate_interface(struct batadv_hard_iface * hard_iface)653 batadv_hardif_activate_interface(struct batadv_hard_iface *hard_iface)
654 {
655 	struct batadv_priv *bat_priv;
656 	struct batadv_hard_iface *primary_if = NULL;
657 
658 	if (hard_iface->if_status != BATADV_IF_INACTIVE)
659 		goto out;
660 
661 	bat_priv = netdev_priv(hard_iface->soft_iface);
662 
663 	bat_priv->algo_ops->iface.update_mac(hard_iface);
664 	hard_iface->if_status = BATADV_IF_TO_BE_ACTIVATED;
665 
666 	/* the first active interface becomes our primary interface or
667 	 * the next active interface after the old primary interface was removed
668 	 */
669 	primary_if = batadv_primary_if_get_selected(bat_priv);
670 	if (!primary_if)
671 		batadv_primary_if_select(bat_priv, hard_iface);
672 
673 	batadv_info(hard_iface->soft_iface, "Interface activated: %s\n",
674 		    hard_iface->net_dev->name);
675 
676 	batadv_update_min_mtu(hard_iface->soft_iface);
677 
678 	if (bat_priv->algo_ops->iface.activate)
679 		bat_priv->algo_ops->iface.activate(hard_iface);
680 
681 out:
682 	batadv_hardif_put(primary_if);
683 }
684 
685 static void
batadv_hardif_deactivate_interface(struct batadv_hard_iface * hard_iface)686 batadv_hardif_deactivate_interface(struct batadv_hard_iface *hard_iface)
687 {
688 	if (hard_iface->if_status != BATADV_IF_ACTIVE &&
689 	    hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)
690 		return;
691 
692 	hard_iface->if_status = BATADV_IF_INACTIVE;
693 
694 	batadv_info(hard_iface->soft_iface, "Interface deactivated: %s\n",
695 		    hard_iface->net_dev->name);
696 
697 	batadv_update_min_mtu(hard_iface->soft_iface);
698 }
699 
700 /**
701  * batadv_hardif_enable_interface() - Enslave hard interface to soft interface
702  * @hard_iface: hard interface to add to soft interface
703  * @soft_iface: netdev struct of the mesh interface
704  *
705  * Return: 0 on success or negative error number in case of failure
706  */
batadv_hardif_enable_interface(struct batadv_hard_iface * hard_iface,struct net_device * soft_iface)707 int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface,
708 				   struct net_device *soft_iface)
709 {
710 	struct batadv_priv *bat_priv;
711 	__be16 ethertype = htons(ETH_P_BATMAN);
712 	int max_header_len = batadv_max_header_len();
713 	unsigned int required_mtu;
714 	unsigned int hardif_mtu;
715 	int ret;
716 
717 	hardif_mtu = READ_ONCE(hard_iface->net_dev->mtu);
718 	required_mtu = READ_ONCE(soft_iface->mtu) + max_header_len;
719 
720 	if (hardif_mtu < ETH_MIN_MTU + max_header_len)
721 		return -EINVAL;
722 
723 	if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
724 		goto out;
725 
726 	kref_get(&hard_iface->refcount);
727 
728 	dev_hold(soft_iface);
729 	hard_iface->soft_iface = soft_iface;
730 	bat_priv = netdev_priv(hard_iface->soft_iface);
731 
732 	ret = netdev_master_upper_dev_link(hard_iface->net_dev,
733 					   soft_iface, NULL, NULL, NULL);
734 	if (ret)
735 		goto err_dev;
736 
737 	ret = bat_priv->algo_ops->iface.enable(hard_iface);
738 	if (ret < 0)
739 		goto err_upper;
740 
741 	hard_iface->if_status = BATADV_IF_INACTIVE;
742 
743 	kref_get(&hard_iface->refcount);
744 	hard_iface->batman_adv_ptype.type = ethertype;
745 	hard_iface->batman_adv_ptype.func = batadv_batman_skb_recv;
746 	hard_iface->batman_adv_ptype.dev = hard_iface->net_dev;
747 	dev_add_pack(&hard_iface->batman_adv_ptype);
748 
749 	batadv_info(hard_iface->soft_iface, "Adding interface: %s\n",
750 		    hard_iface->net_dev->name);
751 
752 	if (atomic_read(&bat_priv->fragmentation) &&
753 	    hardif_mtu < required_mtu)
754 		batadv_info(hard_iface->soft_iface,
755 			    "The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. Packets going over this interface will be fragmented on layer2 which could impact the performance. Setting the MTU to %i would solve the problem.\n",
756 			    hard_iface->net_dev->name, hardif_mtu,
757 			    required_mtu);
758 
759 	if (!atomic_read(&bat_priv->fragmentation) &&
760 	    hardif_mtu < required_mtu)
761 		batadv_info(hard_iface->soft_iface,
762 			    "The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. If you experience problems getting traffic through try increasing the MTU to %i.\n",
763 			    hard_iface->net_dev->name, hardif_mtu,
764 			    required_mtu);
765 
766 	if (batadv_hardif_is_iface_up(hard_iface))
767 		batadv_hardif_activate_interface(hard_iface);
768 	else
769 		batadv_err(hard_iface->soft_iface,
770 			   "Not using interface %s (retrying later): interface not active\n",
771 			   hard_iface->net_dev->name);
772 
773 	batadv_hardif_recalc_extra_skbroom(soft_iface);
774 
775 	if (bat_priv->algo_ops->iface.enabled)
776 		bat_priv->algo_ops->iface.enabled(hard_iface);
777 
778 out:
779 	return 0;
780 
781 err_upper:
782 	netdev_upper_dev_unlink(hard_iface->net_dev, soft_iface);
783 err_dev:
784 	hard_iface->soft_iface = NULL;
785 	dev_put(soft_iface);
786 	batadv_hardif_put(hard_iface);
787 	return ret;
788 }
789 
790 /**
791  * batadv_hardif_cnt() - get number of interfaces enslaved to soft interface
792  * @soft_iface: soft interface to check
793  *
794  * This function is only using RCU for locking - the result can therefore be
795  * off when another function is modifying the list at the same time. The
796  * caller can use the rtnl_lock to make sure that the count is accurate.
797  *
798  * Return: number of connected/enslaved hard interfaces
799  */
batadv_hardif_cnt(const struct net_device * soft_iface)800 static size_t batadv_hardif_cnt(const struct net_device *soft_iface)
801 {
802 	struct batadv_hard_iface *hard_iface;
803 	size_t count = 0;
804 
805 	rcu_read_lock();
806 	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
807 		if (hard_iface->soft_iface != soft_iface)
808 			continue;
809 
810 		count++;
811 	}
812 	rcu_read_unlock();
813 
814 	return count;
815 }
816 
817 /**
818  * batadv_hardif_disable_interface() - Remove hard interface from soft interface
819  * @hard_iface: hard interface to be removed
820  */
batadv_hardif_disable_interface(struct batadv_hard_iface * hard_iface)821 void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface)
822 {
823 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
824 	struct batadv_hard_iface *primary_if = NULL;
825 
826 	batadv_hardif_deactivate_interface(hard_iface);
827 
828 	if (hard_iface->if_status != BATADV_IF_INACTIVE)
829 		goto out;
830 
831 	batadv_info(hard_iface->soft_iface, "Removing interface: %s\n",
832 		    hard_iface->net_dev->name);
833 	dev_remove_pack(&hard_iface->batman_adv_ptype);
834 	batadv_hardif_put(hard_iface);
835 
836 	primary_if = batadv_primary_if_get_selected(bat_priv);
837 	if (hard_iface == primary_if) {
838 		struct batadv_hard_iface *new_if;
839 
840 		new_if = batadv_hardif_get_active(hard_iface->soft_iface);
841 		batadv_primary_if_select(bat_priv, new_if);
842 
843 		batadv_hardif_put(new_if);
844 	}
845 
846 	bat_priv->algo_ops->iface.disable(hard_iface);
847 	hard_iface->if_status = BATADV_IF_NOT_IN_USE;
848 
849 	/* delete all references to this hard_iface */
850 	batadv_purge_orig_ref(bat_priv);
851 	batadv_purge_outstanding_packets(bat_priv, hard_iface);
852 	dev_put(hard_iface->soft_iface);
853 
854 	netdev_upper_dev_unlink(hard_iface->net_dev, hard_iface->soft_iface);
855 	batadv_hardif_recalc_extra_skbroom(hard_iface->soft_iface);
856 
857 	/* nobody uses this interface anymore */
858 	if (batadv_hardif_cnt(hard_iface->soft_iface) <= 1)
859 		batadv_gw_check_client_stop(bat_priv);
860 
861 	hard_iface->soft_iface = NULL;
862 	batadv_hardif_put(hard_iface);
863 
864 out:
865 	batadv_hardif_put(primary_if);
866 }
867 
868 static struct batadv_hard_iface *
batadv_hardif_add_interface(struct net_device * net_dev)869 batadv_hardif_add_interface(struct net_device *net_dev)
870 {
871 	struct batadv_hard_iface *hard_iface;
872 
873 	ASSERT_RTNL();
874 
875 	if (!batadv_is_valid_iface(net_dev))
876 		goto out;
877 
878 	dev_hold(net_dev);
879 
880 	hard_iface = kzalloc(sizeof(*hard_iface), GFP_ATOMIC);
881 	if (!hard_iface)
882 		goto release_dev;
883 
884 	hard_iface->net_dev = net_dev;
885 	hard_iface->soft_iface = NULL;
886 	hard_iface->if_status = BATADV_IF_NOT_IN_USE;
887 
888 	INIT_LIST_HEAD(&hard_iface->list);
889 	INIT_HLIST_HEAD(&hard_iface->neigh_list);
890 
891 	mutex_init(&hard_iface->bat_iv.ogm_buff_mutex);
892 	spin_lock_init(&hard_iface->neigh_list_lock);
893 	kref_init(&hard_iface->refcount);
894 
895 	hard_iface->num_bcasts = BATADV_NUM_BCASTS_DEFAULT;
896 	hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_dev);
897 	if (batadv_is_wifi_hardif(hard_iface))
898 		hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS;
899 
900 	atomic_set(&hard_iface->hop_penalty, 0);
901 
902 	batadv_v_hardif_init(hard_iface);
903 
904 	batadv_check_known_mac_addr(hard_iface->net_dev);
905 	kref_get(&hard_iface->refcount);
906 	list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list);
907 	batadv_hardif_generation++;
908 
909 	return hard_iface;
910 
911 release_dev:
912 	dev_put(net_dev);
913 out:
914 	return NULL;
915 }
916 
batadv_hardif_remove_interface(struct batadv_hard_iface * hard_iface)917 static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface)
918 {
919 	ASSERT_RTNL();
920 
921 	/* first deactivate interface */
922 	if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
923 		batadv_hardif_disable_interface(hard_iface);
924 
925 	if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
926 		return;
927 
928 	hard_iface->if_status = BATADV_IF_TO_BE_REMOVED;
929 	batadv_hardif_put(hard_iface);
930 }
931 
932 /**
933  * batadv_hard_if_event_softif() - Handle events for soft interfaces
934  * @event: NETDEV_* event to handle
935  * @net_dev: net_device which generated an event
936  *
937  * Return: NOTIFY_* result
938  */
batadv_hard_if_event_softif(unsigned long event,struct net_device * net_dev)939 static int batadv_hard_if_event_softif(unsigned long event,
940 				       struct net_device *net_dev)
941 {
942 	struct batadv_priv *bat_priv;
943 
944 	switch (event) {
945 	case NETDEV_REGISTER:
946 		bat_priv = netdev_priv(net_dev);
947 		batadv_softif_create_vlan(bat_priv, BATADV_NO_FLAGS);
948 		break;
949 	}
950 
951 	return NOTIFY_DONE;
952 }
953 
batadv_hard_if_event(struct notifier_block * this,unsigned long event,void * ptr)954 static int batadv_hard_if_event(struct notifier_block *this,
955 				unsigned long event, void *ptr)
956 {
957 	struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
958 	struct batadv_hard_iface *hard_iface;
959 	struct batadv_hard_iface *primary_if = NULL;
960 	struct batadv_priv *bat_priv;
961 
962 	if (batadv_softif_is_valid(net_dev))
963 		return batadv_hard_if_event_softif(event, net_dev);
964 
965 	hard_iface = batadv_hardif_get_by_netdev(net_dev);
966 	if (!hard_iface && (event == NETDEV_REGISTER ||
967 			    event == NETDEV_POST_TYPE_CHANGE))
968 		hard_iface = batadv_hardif_add_interface(net_dev);
969 
970 	if (!hard_iface)
971 		goto out;
972 
973 	switch (event) {
974 	case NETDEV_UP:
975 		batadv_hardif_activate_interface(hard_iface);
976 		break;
977 	case NETDEV_GOING_DOWN:
978 	case NETDEV_DOWN:
979 		batadv_hardif_deactivate_interface(hard_iface);
980 		break;
981 	case NETDEV_UNREGISTER:
982 	case NETDEV_PRE_TYPE_CHANGE:
983 		list_del_rcu(&hard_iface->list);
984 		batadv_hardif_generation++;
985 
986 		batadv_hardif_remove_interface(hard_iface);
987 		break;
988 	case NETDEV_CHANGEMTU:
989 		if (hard_iface->soft_iface)
990 			batadv_update_min_mtu(hard_iface->soft_iface);
991 		break;
992 	case NETDEV_CHANGEADDR:
993 		if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
994 			goto hardif_put;
995 
996 		batadv_check_known_mac_addr(hard_iface->net_dev);
997 
998 		bat_priv = netdev_priv(hard_iface->soft_iface);
999 		bat_priv->algo_ops->iface.update_mac(hard_iface);
1000 
1001 		primary_if = batadv_primary_if_get_selected(bat_priv);
1002 		if (!primary_if)
1003 			goto hardif_put;
1004 
1005 		if (hard_iface == primary_if)
1006 			batadv_primary_if_update_addr(bat_priv, NULL);
1007 		break;
1008 	case NETDEV_CHANGEUPPER:
1009 		hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_dev);
1010 		if (batadv_is_wifi_hardif(hard_iface))
1011 			hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS;
1012 		break;
1013 	default:
1014 		break;
1015 	}
1016 
1017 hardif_put:
1018 	batadv_hardif_put(hard_iface);
1019 out:
1020 	batadv_hardif_put(primary_if);
1021 	return NOTIFY_DONE;
1022 }
1023 
1024 struct notifier_block batadv_hard_if_notifier = {
1025 	.notifier_call = batadv_hard_if_event,
1026 };
1027