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