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 | */ |
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(dev: 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(kref: &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(dev: dev1); |
120 | int dev2_parent_iflink = dev_get_iflink(dev: dev2); |
121 | const struct net *dev1_parent_net; |
122 | const struct net *dev2_parent_net; |
123 | |
124 | dev1_parent_net = batadv_getlink_net(netdev: dev1, fallback_net: net1); |
125 | dev2_parent_net = batadv_getlink_net(netdev: dev2, fallback_net: 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(net1: dev1_parent_net, net2) && |
133 | net_eq(net1: dev2_parent_net, net2: 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 | */ |
149 | static bool batadv_is_on_batman_iface(const struct net_device *net_dev) |
150 | { |
151 | struct net *net = dev_net(dev: 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(dev: net_dev); |
162 | if (iflink == 0) |
163 | return false; |
164 | |
165 | parent_net = batadv_getlink_net(netdev: net_dev, fallback_net: 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(net: (struct net *)parent_net, ifindex: 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(dev1: net_dev, net1: net, dev2: parent_dev, net2: parent_net)) |
180 | return false; |
181 | |
182 | ret = batadv_is_on_batman_iface(net_dev: parent_dev); |
183 | |
184 | return ret; |
185 | } |
186 | |
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 | */ |
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(dev: netdev); |
230 | if (iflink == 0) { |
231 | dev_hold(dev: netdev); |
232 | return netdev; |
233 | } |
234 | |
235 | hard_iface = batadv_hardif_get_by_netdev(net_dev: netdev); |
236 | if (!hard_iface || !hard_iface->soft_iface) |
237 | goto out; |
238 | |
239 | net = dev_net(dev: hard_iface->soft_iface); |
240 | real_net = batadv_getlink_net(netdev, fallback_net: 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(dev: real_netdev); |
246 | goto out; |
247 | } |
248 | |
249 | real_netdev = dev_get_by_index(net: real_net, ifindex: 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 | */ |
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(netdev: 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 | */ |
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 | */ |
307 | static bool batadv_is_cfg80211_netdev(struct net_device *net_device) |
308 | { |
309 | if (!net_device) |
310 | return false; |
311 | |
312 | #if IS_ENABLED(CONFIG_CFG80211) |
313 | /* cfg80211 drivers have to set ieee80211_ptr */ |
314 | if (net_device->ieee80211_ptr) |
315 | return true; |
316 | #endif |
317 | |
318 | return false; |
319 | } |
320 | |
321 | /** |
322 | * batadv_wifi_flags_evaluate() - calculate wifi flags for net_device |
323 | * @net_device: the device to check |
324 | * |
325 | * Return: batadv_hard_iface_wifi_flags flags of the device |
326 | */ |
327 | static u32 batadv_wifi_flags_evaluate(struct net_device *net_device) |
328 | { |
329 | u32 wifi_flags = 0; |
330 | struct net_device *real_netdev; |
331 | |
332 | if (batadv_is_wext_netdev(net_device)) |
333 | wifi_flags |= BATADV_HARDIF_WIFI_WEXT_DIRECT; |
334 | |
335 | if (batadv_is_cfg80211_netdev(net_device)) |
336 | wifi_flags |= BATADV_HARDIF_WIFI_CFG80211_DIRECT; |
337 | |
338 | real_netdev = batadv_get_real_netdevice(netdev: net_device); |
339 | if (!real_netdev) |
340 | return wifi_flags; |
341 | |
342 | if (real_netdev == net_device) |
343 | goto out; |
344 | |
345 | if (batadv_is_wext_netdev(net_device: real_netdev)) |
346 | wifi_flags |= BATADV_HARDIF_WIFI_WEXT_INDIRECT; |
347 | |
348 | if (batadv_is_cfg80211_netdev(net_device: real_netdev)) |
349 | wifi_flags |= BATADV_HARDIF_WIFI_CFG80211_INDIRECT; |
350 | |
351 | out: |
352 | dev_put(dev: real_netdev); |
353 | return wifi_flags; |
354 | } |
355 | |
356 | /** |
357 | * batadv_is_cfg80211_hardif() - check if the given hardif is a cfg80211 wifi |
358 | * interface |
359 | * @hard_iface: the device to check |
360 | * |
361 | * Return: true if the net device is a cfg80211 wireless device, false |
362 | * otherwise. |
363 | */ |
364 | bool batadv_is_cfg80211_hardif(struct batadv_hard_iface *hard_iface) |
365 | { |
366 | u32 allowed_flags = 0; |
367 | |
368 | allowed_flags |= BATADV_HARDIF_WIFI_CFG80211_DIRECT; |
369 | allowed_flags |= BATADV_HARDIF_WIFI_CFG80211_INDIRECT; |
370 | |
371 | return !!(hard_iface->wifi_flags & allowed_flags); |
372 | } |
373 | |
374 | /** |
375 | * batadv_is_wifi_hardif() - check if the given hardif is a wifi interface |
376 | * @hard_iface: the device to check |
377 | * |
378 | * Return: true if the net device is a 802.11 wireless device, false otherwise. |
379 | */ |
380 | bool batadv_is_wifi_hardif(struct batadv_hard_iface *hard_iface) |
381 | { |
382 | if (!hard_iface) |
383 | return false; |
384 | |
385 | return hard_iface->wifi_flags != 0; |
386 | } |
387 | |
388 | /** |
389 | * batadv_hardif_no_broadcast() - check whether (re)broadcast is necessary |
390 | * @if_outgoing: the outgoing interface checked and considered for (re)broadcast |
391 | * @orig_addr: the originator of this packet |
392 | * @orig_neigh: originator address of the forwarder we just got the packet from |
393 | * (NULL if we originated) |
394 | * |
395 | * Checks whether a packet needs to be (re)broadcasted on the given interface. |
396 | * |
397 | * Return: |
398 | * BATADV_HARDIF_BCAST_NORECIPIENT: No neighbor on interface |
399 | * BATADV_HARDIF_BCAST_DUPFWD: Just one neighbor, but it is the forwarder |
400 | * BATADV_HARDIF_BCAST_DUPORIG: Just one neighbor, but it is the originator |
401 | * BATADV_HARDIF_BCAST_OK: Several neighbors, must broadcast |
402 | */ |
403 | int batadv_hardif_no_broadcast(struct batadv_hard_iface *if_outgoing, |
404 | u8 *orig_addr, u8 *orig_neigh) |
405 | { |
406 | struct batadv_hardif_neigh_node *hardif_neigh; |
407 | struct hlist_node *first; |
408 | int ret = BATADV_HARDIF_BCAST_OK; |
409 | |
410 | rcu_read_lock(); |
411 | |
412 | /* 0 neighbors -> no (re)broadcast */ |
413 | first = rcu_dereference(hlist_first_rcu(&if_outgoing->neigh_list)); |
414 | if (!first) { |
415 | ret = BATADV_HARDIF_BCAST_NORECIPIENT; |
416 | goto out; |
417 | } |
418 | |
419 | /* >1 neighbors -> (re)broadcast */ |
420 | if (rcu_dereference(hlist_next_rcu(first))) |
421 | goto out; |
422 | |
423 | hardif_neigh = hlist_entry(first, struct batadv_hardif_neigh_node, |
424 | list); |
425 | |
426 | /* 1 neighbor, is the originator -> no rebroadcast */ |
427 | if (orig_addr && batadv_compare_eth(data1: hardif_neigh->orig, data2: orig_addr)) { |
428 | ret = BATADV_HARDIF_BCAST_DUPORIG; |
429 | /* 1 neighbor, is the one we received from -> no rebroadcast */ |
430 | } else if (orig_neigh && |
431 | batadv_compare_eth(data1: hardif_neigh->orig, data2: orig_neigh)) { |
432 | ret = BATADV_HARDIF_BCAST_DUPFWD; |
433 | } |
434 | |
435 | out: |
436 | rcu_read_unlock(); |
437 | return ret; |
438 | } |
439 | |
440 | static struct batadv_hard_iface * |
441 | batadv_hardif_get_active(const struct net_device *soft_iface) |
442 | { |
443 | struct batadv_hard_iface *hard_iface; |
444 | |
445 | rcu_read_lock(); |
446 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { |
447 | if (hard_iface->soft_iface != soft_iface) |
448 | continue; |
449 | |
450 | if (hard_iface->if_status == BATADV_IF_ACTIVE && |
451 | kref_get_unless_zero(kref: &hard_iface->refcount)) |
452 | goto out; |
453 | } |
454 | |
455 | hard_iface = NULL; |
456 | |
457 | out: |
458 | rcu_read_unlock(); |
459 | return hard_iface; |
460 | } |
461 | |
462 | static void batadv_primary_if_update_addr(struct batadv_priv *bat_priv, |
463 | struct batadv_hard_iface *oldif) |
464 | { |
465 | struct batadv_hard_iface *primary_if; |
466 | |
467 | primary_if = batadv_primary_if_get_selected(bat_priv); |
468 | if (!primary_if) |
469 | goto out; |
470 | |
471 | batadv_dat_init_own_addr(bat_priv, primary_if); |
472 | batadv_bla_update_orig_address(bat_priv, primary_if, oldif); |
473 | out: |
474 | batadv_hardif_put(hard_iface: primary_if); |
475 | } |
476 | |
477 | static void batadv_primary_if_select(struct batadv_priv *bat_priv, |
478 | struct batadv_hard_iface *new_hard_iface) |
479 | { |
480 | struct batadv_hard_iface *curr_hard_iface; |
481 | |
482 | ASSERT_RTNL(); |
483 | |
484 | if (new_hard_iface) |
485 | kref_get(kref: &new_hard_iface->refcount); |
486 | |
487 | curr_hard_iface = rcu_replace_pointer(bat_priv->primary_if, |
488 | new_hard_iface, 1); |
489 | |
490 | if (!new_hard_iface) |
491 | goto out; |
492 | |
493 | bat_priv->algo_ops->iface.primary_set(new_hard_iface); |
494 | batadv_primary_if_update_addr(bat_priv, oldif: curr_hard_iface); |
495 | |
496 | out: |
497 | batadv_hardif_put(hard_iface: curr_hard_iface); |
498 | } |
499 | |
500 | static bool |
501 | batadv_hardif_is_iface_up(const struct batadv_hard_iface *hard_iface) |
502 | { |
503 | if (hard_iface->net_dev->flags & IFF_UP) |
504 | return true; |
505 | |
506 | return false; |
507 | } |
508 | |
509 | static void batadv_check_known_mac_addr(const struct net_device *net_dev) |
510 | { |
511 | const struct batadv_hard_iface *hard_iface; |
512 | |
513 | rcu_read_lock(); |
514 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { |
515 | if (hard_iface->if_status != BATADV_IF_ACTIVE && |
516 | hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED) |
517 | continue; |
518 | |
519 | if (hard_iface->net_dev == net_dev) |
520 | continue; |
521 | |
522 | if (!batadv_compare_eth(data1: hard_iface->net_dev->dev_addr, |
523 | data2: net_dev->dev_addr)) |
524 | continue; |
525 | |
526 | pr_warn("The newly added mac address (%pM) already exists on: %s\n" , |
527 | net_dev->dev_addr, hard_iface->net_dev->name); |
528 | pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n" ); |
529 | } |
530 | rcu_read_unlock(); |
531 | } |
532 | |
533 | /** |
534 | * batadv_hardif_recalc_extra_skbroom() - Recalculate skbuff extra head/tailroom |
535 | * @soft_iface: netdev struct of the mesh interface |
536 | */ |
537 | static void (struct net_device *soft_iface) |
538 | { |
539 | const struct batadv_hard_iface *hard_iface; |
540 | unsigned short = ETH_HLEN; |
541 | unsigned short lower_headroom = 0; |
542 | unsigned short lower_tailroom = 0; |
543 | unsigned short needed_headroom; |
544 | |
545 | rcu_read_lock(); |
546 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { |
547 | if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) |
548 | continue; |
549 | |
550 | if (hard_iface->soft_iface != soft_iface) |
551 | continue; |
552 | |
553 | lower_header_len = max_t(unsigned short, lower_header_len, |
554 | hard_iface->net_dev->hard_header_len); |
555 | |
556 | lower_headroom = max_t(unsigned short, lower_headroom, |
557 | hard_iface->net_dev->needed_headroom); |
558 | |
559 | lower_tailroom = max_t(unsigned short, lower_tailroom, |
560 | hard_iface->net_dev->needed_tailroom); |
561 | } |
562 | rcu_read_unlock(); |
563 | |
564 | needed_headroom = lower_headroom + (lower_header_len - ETH_HLEN); |
565 | needed_headroom += batadv_max_header_len(); |
566 | |
567 | /* fragmentation headers don't strip the unicast/... header */ |
568 | needed_headroom += sizeof(struct batadv_frag_packet); |
569 | |
570 | soft_iface->needed_headroom = needed_headroom; |
571 | soft_iface->needed_tailroom = lower_tailroom; |
572 | } |
573 | |
574 | /** |
575 | * batadv_hardif_min_mtu() - Calculate maximum MTU for soft interface |
576 | * @soft_iface: netdev struct of the soft interface |
577 | * |
578 | * Return: MTU for the soft-interface (limited by the minimal MTU of all active |
579 | * slave interfaces) |
580 | */ |
581 | int batadv_hardif_min_mtu(struct net_device *soft_iface) |
582 | { |
583 | struct batadv_priv *bat_priv = netdev_priv(dev: soft_iface); |
584 | const struct batadv_hard_iface *hard_iface; |
585 | int min_mtu = INT_MAX; |
586 | |
587 | rcu_read_lock(); |
588 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { |
589 | if (hard_iface->if_status != BATADV_IF_ACTIVE && |
590 | hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED) |
591 | continue; |
592 | |
593 | if (hard_iface->soft_iface != soft_iface) |
594 | continue; |
595 | |
596 | min_mtu = min_t(int, hard_iface->net_dev->mtu, min_mtu); |
597 | } |
598 | rcu_read_unlock(); |
599 | |
600 | if (atomic_read(v: &bat_priv->fragmentation) == 0) |
601 | goto out; |
602 | |
603 | /* with fragmentation enabled the maximum size of internally generated |
604 | * packets such as translation table exchanges or tvlv containers, etc |
605 | * has to be calculated |
606 | */ |
607 | min_mtu = min_t(int, min_mtu, BATADV_FRAG_MAX_FRAG_SIZE); |
608 | min_mtu -= sizeof(struct batadv_frag_packet); |
609 | min_mtu *= BATADV_FRAG_MAX_FRAGMENTS; |
610 | |
611 | out: |
612 | /* report to the other components the maximum amount of bytes that |
613 | * batman-adv can send over the wire (without considering the payload |
614 | * overhead). For example, this value is used by TT to compute the |
615 | * maximum local table size |
616 | */ |
617 | atomic_set(v: &bat_priv->packet_size_max, i: min_mtu); |
618 | |
619 | /* the real soft-interface MTU is computed by removing the payload |
620 | * overhead from the maximum amount of bytes that was just computed. |
621 | * |
622 | * However batman-adv does not support MTUs bigger than ETH_DATA_LEN |
623 | */ |
624 | return min_t(int, min_mtu - batadv_max_header_len(), ETH_DATA_LEN); |
625 | } |
626 | |
627 | /** |
628 | * batadv_update_min_mtu() - Adjusts the MTU if a new interface with a smaller |
629 | * MTU appeared |
630 | * @soft_iface: netdev struct of the soft interface |
631 | */ |
632 | void batadv_update_min_mtu(struct net_device *soft_iface) |
633 | { |
634 | struct batadv_priv *bat_priv = netdev_priv(dev: soft_iface); |
635 | int limit_mtu; |
636 | int mtu; |
637 | |
638 | mtu = batadv_hardif_min_mtu(soft_iface); |
639 | |
640 | if (bat_priv->mtu_set_by_user) |
641 | limit_mtu = bat_priv->mtu_set_by_user; |
642 | else |
643 | limit_mtu = ETH_DATA_LEN; |
644 | |
645 | mtu = min(mtu, limit_mtu); |
646 | dev_set_mtu(soft_iface, mtu); |
647 | |
648 | /* Check if the local translate table should be cleaned up to match a |
649 | * new (and smaller) MTU. |
650 | */ |
651 | batadv_tt_local_resize_to_mtu(soft_iface); |
652 | } |
653 | |
654 | static void |
655 | batadv_hardif_activate_interface(struct batadv_hard_iface *hard_iface) |
656 | { |
657 | struct batadv_priv *bat_priv; |
658 | struct batadv_hard_iface *primary_if = NULL; |
659 | |
660 | if (hard_iface->if_status != BATADV_IF_INACTIVE) |
661 | goto out; |
662 | |
663 | bat_priv = netdev_priv(dev: hard_iface->soft_iface); |
664 | |
665 | bat_priv->algo_ops->iface.update_mac(hard_iface); |
666 | hard_iface->if_status = BATADV_IF_TO_BE_ACTIVATED; |
667 | |
668 | /* the first active interface becomes our primary interface or |
669 | * the next active interface after the old primary interface was removed |
670 | */ |
671 | primary_if = batadv_primary_if_get_selected(bat_priv); |
672 | if (!primary_if) |
673 | batadv_primary_if_select(bat_priv, new_hard_iface: hard_iface); |
674 | |
675 | batadv_info(hard_iface->soft_iface, "Interface activated: %s\n" , |
676 | hard_iface->net_dev->name); |
677 | |
678 | batadv_update_min_mtu(soft_iface: hard_iface->soft_iface); |
679 | |
680 | if (bat_priv->algo_ops->iface.activate) |
681 | bat_priv->algo_ops->iface.activate(hard_iface); |
682 | |
683 | out: |
684 | batadv_hardif_put(hard_iface: primary_if); |
685 | } |
686 | |
687 | static void |
688 | batadv_hardif_deactivate_interface(struct batadv_hard_iface *hard_iface) |
689 | { |
690 | if (hard_iface->if_status != BATADV_IF_ACTIVE && |
691 | hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED) |
692 | return; |
693 | |
694 | hard_iface->if_status = BATADV_IF_INACTIVE; |
695 | |
696 | batadv_info(hard_iface->soft_iface, "Interface deactivated: %s\n" , |
697 | hard_iface->net_dev->name); |
698 | |
699 | batadv_update_min_mtu(soft_iface: hard_iface->soft_iface); |
700 | } |
701 | |
702 | /** |
703 | * batadv_hardif_enable_interface() - Enslave hard interface to soft interface |
704 | * @hard_iface: hard interface to add to soft interface |
705 | * @soft_iface: netdev struct of the mesh interface |
706 | * |
707 | * Return: 0 on success or negative error number in case of failure |
708 | */ |
709 | int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, |
710 | struct net_device *soft_iface) |
711 | { |
712 | struct batadv_priv *bat_priv; |
713 | __be16 ethertype = htons(ETH_P_BATMAN); |
714 | int = batadv_max_header_len(); |
715 | unsigned int required_mtu; |
716 | unsigned int hardif_mtu; |
717 | int ret; |
718 | |
719 | hardif_mtu = READ_ONCE(hard_iface->net_dev->mtu); |
720 | required_mtu = READ_ONCE(soft_iface->mtu) + max_header_len; |
721 | |
722 | if (hardif_mtu < ETH_MIN_MTU + max_header_len) |
723 | return -EINVAL; |
724 | |
725 | if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) |
726 | goto out; |
727 | |
728 | kref_get(kref: &hard_iface->refcount); |
729 | |
730 | dev_hold(dev: soft_iface); |
731 | hard_iface->soft_iface = soft_iface; |
732 | bat_priv = netdev_priv(dev: hard_iface->soft_iface); |
733 | |
734 | ret = netdev_master_upper_dev_link(dev: hard_iface->net_dev, |
735 | upper_dev: soft_iface, NULL, NULL, NULL); |
736 | if (ret) |
737 | goto err_dev; |
738 | |
739 | ret = bat_priv->algo_ops->iface.enable(hard_iface); |
740 | if (ret < 0) |
741 | goto err_upper; |
742 | |
743 | hard_iface->if_status = BATADV_IF_INACTIVE; |
744 | |
745 | kref_get(kref: &hard_iface->refcount); |
746 | hard_iface->batman_adv_ptype.type = ethertype; |
747 | hard_iface->batman_adv_ptype.func = batadv_batman_skb_recv; |
748 | hard_iface->batman_adv_ptype.dev = hard_iface->net_dev; |
749 | dev_add_pack(pt: &hard_iface->batman_adv_ptype); |
750 | |
751 | batadv_info(hard_iface->soft_iface, "Adding interface: %s\n" , |
752 | hard_iface->net_dev->name); |
753 | |
754 | if (atomic_read(v: &bat_priv->fragmentation) && |
755 | hardif_mtu < required_mtu) |
756 | batadv_info(hard_iface->soft_iface, |
757 | "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" , |
758 | hard_iface->net_dev->name, hardif_mtu, |
759 | required_mtu); |
760 | |
761 | if (!atomic_read(v: &bat_priv->fragmentation) && |
762 | hardif_mtu < required_mtu) |
763 | batadv_info(hard_iface->soft_iface, |
764 | "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" , |
765 | hard_iface->net_dev->name, hardif_mtu, |
766 | required_mtu); |
767 | |
768 | if (batadv_hardif_is_iface_up(hard_iface)) |
769 | batadv_hardif_activate_interface(hard_iface); |
770 | else |
771 | batadv_err(hard_iface->soft_iface, |
772 | "Not using interface %s (retrying later): interface not active\n" , |
773 | hard_iface->net_dev->name); |
774 | |
775 | batadv_hardif_recalc_extra_skbroom(soft_iface); |
776 | |
777 | if (bat_priv->algo_ops->iface.enabled) |
778 | bat_priv->algo_ops->iface.enabled(hard_iface); |
779 | |
780 | out: |
781 | return 0; |
782 | |
783 | err_upper: |
784 | netdev_upper_dev_unlink(dev: hard_iface->net_dev, upper_dev: soft_iface); |
785 | err_dev: |
786 | hard_iface->soft_iface = NULL; |
787 | dev_put(dev: soft_iface); |
788 | batadv_hardif_put(hard_iface); |
789 | return ret; |
790 | } |
791 | |
792 | /** |
793 | * batadv_hardif_cnt() - get number of interfaces enslaved to soft interface |
794 | * @soft_iface: soft interface to check |
795 | * |
796 | * This function is only using RCU for locking - the result can therefore be |
797 | * off when another function is modifying the list at the same time. The |
798 | * caller can use the rtnl_lock to make sure that the count is accurate. |
799 | * |
800 | * Return: number of connected/enslaved hard interfaces |
801 | */ |
802 | static size_t batadv_hardif_cnt(const struct net_device *soft_iface) |
803 | { |
804 | struct batadv_hard_iface *hard_iface; |
805 | size_t count = 0; |
806 | |
807 | rcu_read_lock(); |
808 | list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { |
809 | if (hard_iface->soft_iface != soft_iface) |
810 | continue; |
811 | |
812 | count++; |
813 | } |
814 | rcu_read_unlock(); |
815 | |
816 | return count; |
817 | } |
818 | |
819 | /** |
820 | * batadv_hardif_disable_interface() - Remove hard interface from soft interface |
821 | * @hard_iface: hard interface to be removed |
822 | */ |
823 | void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface) |
824 | { |
825 | struct batadv_priv *bat_priv = netdev_priv(dev: hard_iface->soft_iface); |
826 | struct batadv_hard_iface *primary_if = NULL; |
827 | |
828 | batadv_hardif_deactivate_interface(hard_iface); |
829 | |
830 | if (hard_iface->if_status != BATADV_IF_INACTIVE) |
831 | goto out; |
832 | |
833 | batadv_info(hard_iface->soft_iface, "Removing interface: %s\n" , |
834 | hard_iface->net_dev->name); |
835 | dev_remove_pack(pt: &hard_iface->batman_adv_ptype); |
836 | batadv_hardif_put(hard_iface); |
837 | |
838 | primary_if = batadv_primary_if_get_selected(bat_priv); |
839 | if (hard_iface == primary_if) { |
840 | struct batadv_hard_iface *new_if; |
841 | |
842 | new_if = batadv_hardif_get_active(soft_iface: hard_iface->soft_iface); |
843 | batadv_primary_if_select(bat_priv, new_hard_iface: new_if); |
844 | |
845 | batadv_hardif_put(hard_iface: new_if); |
846 | } |
847 | |
848 | bat_priv->algo_ops->iface.disable(hard_iface); |
849 | hard_iface->if_status = BATADV_IF_NOT_IN_USE; |
850 | |
851 | /* delete all references to this hard_iface */ |
852 | batadv_purge_orig_ref(bat_priv); |
853 | batadv_purge_outstanding_packets(bat_priv, hard_iface); |
854 | dev_put(dev: hard_iface->soft_iface); |
855 | |
856 | netdev_upper_dev_unlink(dev: hard_iface->net_dev, upper_dev: hard_iface->soft_iface); |
857 | batadv_hardif_recalc_extra_skbroom(soft_iface: hard_iface->soft_iface); |
858 | |
859 | /* nobody uses this interface anymore */ |
860 | if (batadv_hardif_cnt(soft_iface: hard_iface->soft_iface) <= 1) |
861 | batadv_gw_check_client_stop(bat_priv); |
862 | |
863 | hard_iface->soft_iface = NULL; |
864 | batadv_hardif_put(hard_iface); |
865 | |
866 | out: |
867 | batadv_hardif_put(hard_iface: primary_if); |
868 | } |
869 | |
870 | static struct batadv_hard_iface * |
871 | batadv_hardif_add_interface(struct net_device *net_dev) |
872 | { |
873 | struct batadv_hard_iface *hard_iface; |
874 | |
875 | ASSERT_RTNL(); |
876 | |
877 | if (!batadv_is_valid_iface(net_dev)) |
878 | goto out; |
879 | |
880 | dev_hold(dev: net_dev); |
881 | |
882 | hard_iface = kzalloc(size: sizeof(*hard_iface), GFP_ATOMIC); |
883 | if (!hard_iface) |
884 | goto release_dev; |
885 | |
886 | hard_iface->net_dev = net_dev; |
887 | hard_iface->soft_iface = NULL; |
888 | hard_iface->if_status = BATADV_IF_NOT_IN_USE; |
889 | |
890 | INIT_LIST_HEAD(list: &hard_iface->list); |
891 | INIT_HLIST_HEAD(&hard_iface->neigh_list); |
892 | |
893 | mutex_init(&hard_iface->bat_iv.ogm_buff_mutex); |
894 | spin_lock_init(&hard_iface->neigh_list_lock); |
895 | kref_init(kref: &hard_iface->refcount); |
896 | |
897 | hard_iface->num_bcasts = BATADV_NUM_BCASTS_DEFAULT; |
898 | hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_device: net_dev); |
899 | if (batadv_is_wifi_hardif(hard_iface)) |
900 | hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS; |
901 | |
902 | atomic_set(v: &hard_iface->hop_penalty, i: 0); |
903 | |
904 | batadv_v_hardif_init(hardif: hard_iface); |
905 | |
906 | batadv_check_known_mac_addr(net_dev: hard_iface->net_dev); |
907 | kref_get(kref: &hard_iface->refcount); |
908 | list_add_tail_rcu(new: &hard_iface->list, head: &batadv_hardif_list); |
909 | batadv_hardif_generation++; |
910 | |
911 | return hard_iface; |
912 | |
913 | release_dev: |
914 | dev_put(dev: net_dev); |
915 | out: |
916 | return NULL; |
917 | } |
918 | |
919 | static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface) |
920 | { |
921 | ASSERT_RTNL(); |
922 | |
923 | /* first deactivate interface */ |
924 | if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) |
925 | batadv_hardif_disable_interface(hard_iface); |
926 | |
927 | if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) |
928 | return; |
929 | |
930 | hard_iface->if_status = BATADV_IF_TO_BE_REMOVED; |
931 | batadv_hardif_put(hard_iface); |
932 | } |
933 | |
934 | /** |
935 | * batadv_hard_if_event_softif() - Handle events for soft interfaces |
936 | * @event: NETDEV_* event to handle |
937 | * @net_dev: net_device which generated an event |
938 | * |
939 | * Return: NOTIFY_* result |
940 | */ |
941 | static int batadv_hard_if_event_softif(unsigned long event, |
942 | struct net_device *net_dev) |
943 | { |
944 | struct batadv_priv *bat_priv; |
945 | |
946 | switch (event) { |
947 | case NETDEV_REGISTER: |
948 | bat_priv = netdev_priv(dev: net_dev); |
949 | batadv_softif_create_vlan(bat_priv, BATADV_NO_FLAGS); |
950 | break; |
951 | } |
952 | |
953 | return NOTIFY_DONE; |
954 | } |
955 | |
956 | static int batadv_hard_if_event(struct notifier_block *this, |
957 | unsigned long event, void *ptr) |
958 | { |
959 | struct net_device *net_dev = netdev_notifier_info_to_dev(info: ptr); |
960 | struct batadv_hard_iface *hard_iface; |
961 | struct batadv_hard_iface *primary_if = NULL; |
962 | struct batadv_priv *bat_priv; |
963 | |
964 | if (batadv_softif_is_valid(net_dev)) |
965 | return batadv_hard_if_event_softif(event, net_dev); |
966 | |
967 | hard_iface = batadv_hardif_get_by_netdev(net_dev); |
968 | if (!hard_iface && (event == NETDEV_REGISTER || |
969 | event == NETDEV_POST_TYPE_CHANGE)) |
970 | hard_iface = batadv_hardif_add_interface(net_dev); |
971 | |
972 | if (!hard_iface) |
973 | goto out; |
974 | |
975 | switch (event) { |
976 | case NETDEV_UP: |
977 | batadv_hardif_activate_interface(hard_iface); |
978 | break; |
979 | case NETDEV_GOING_DOWN: |
980 | case NETDEV_DOWN: |
981 | batadv_hardif_deactivate_interface(hard_iface); |
982 | break; |
983 | case NETDEV_UNREGISTER: |
984 | case NETDEV_PRE_TYPE_CHANGE: |
985 | list_del_rcu(entry: &hard_iface->list); |
986 | batadv_hardif_generation++; |
987 | |
988 | batadv_hardif_remove_interface(hard_iface); |
989 | break; |
990 | case NETDEV_CHANGEMTU: |
991 | if (hard_iface->soft_iface) |
992 | batadv_update_min_mtu(soft_iface: hard_iface->soft_iface); |
993 | break; |
994 | case NETDEV_CHANGEADDR: |
995 | if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) |
996 | goto hardif_put; |
997 | |
998 | batadv_check_known_mac_addr(net_dev: hard_iface->net_dev); |
999 | |
1000 | bat_priv = netdev_priv(dev: hard_iface->soft_iface); |
1001 | bat_priv->algo_ops->iface.update_mac(hard_iface); |
1002 | |
1003 | primary_if = batadv_primary_if_get_selected(bat_priv); |
1004 | if (!primary_if) |
1005 | goto hardif_put; |
1006 | |
1007 | if (hard_iface == primary_if) |
1008 | batadv_primary_if_update_addr(bat_priv, NULL); |
1009 | break; |
1010 | case NETDEV_CHANGEUPPER: |
1011 | hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_device: net_dev); |
1012 | if (batadv_is_wifi_hardif(hard_iface)) |
1013 | hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS; |
1014 | break; |
1015 | default: |
1016 | break; |
1017 | } |
1018 | |
1019 | hardif_put: |
1020 | batadv_hardif_put(hard_iface); |
1021 | out: |
1022 | batadv_hardif_put(hard_iface: primary_if); |
1023 | return NOTIFY_DONE; |
1024 | } |
1025 | |
1026 | struct notifier_block batadv_hard_if_notifier = { |
1027 | .notifier_call = batadv_hard_if_event, |
1028 | }; |
1029 | |