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