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 */ 49void 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 */ 65struct batadv_hard_iface * 66batadv_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 79out: 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 */ 91static 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 */ 114static bool batadv_mutual_parents(const struct net_device *dev1, 115 struct net *net1, 116 const struct net_device *dev2, 117 struct net *net2) 118{ 119 int dev1_parent_iflink = dev_get_iflink(dev1); 120 int dev2_parent_iflink = dev_get_iflink(dev2); 121 const struct net *dev1_parent_net; 122 const struct net *dev2_parent_net; 123 124 dev1_parent_net = batadv_getlink_net(dev1, net1); 125 dev2_parent_net = batadv_getlink_net(dev2, net2); 126 127 if (!dev1_parent_iflink || !dev2_parent_iflink) 128 return false; 129 130 return (dev1_parent_iflink == dev2->ifindex) && 131 (dev2_parent_iflink == dev1->ifindex) && 132 net_eq(dev1_parent_net, net2) && 133 net_eq(dev2_parent_net, net1); 134} 135 136/** 137 * batadv_is_on_batman_iface() - check if a device is a batman iface descendant 138 * @net_dev: the device to check 139 * 140 * If the user creates any virtual device on top of a batman-adv interface, it 141 * is important to prevent this new interface from being used to create a new 142 * mesh network (this behaviour would lead to a batman-over-batman 143 * configuration). This function recursively checks all the fathers of the 144 * device passed as argument looking for a batman-adv soft interface. 145 * 146 * Return: true if the device is descendant of a batman-adv mesh interface (or 147 * if it is a batman-adv interface itself), false otherwise 148 */ 149static bool batadv_is_on_batman_iface(const struct net_device *net_dev) 150{ 151 struct net *net = dev_net(net_dev); 152 struct net_device *parent_dev; 153 struct net *parent_net; 154 int iflink; 155 bool ret; 156 157 /* check if this is a batman-adv mesh interface */ 158 if (batadv_softif_is_valid(net_dev)) 159 return true; 160 161 iflink = dev_get_iflink(net_dev); 162 if (iflink == 0) 163 return false; 164 165 parent_net = batadv_getlink_net(net_dev, net); 166 167 /* iflink to itself, most likely physical device */ 168 if (net == parent_net && iflink == net_dev->ifindex) 169 return false; 170 171 /* recurse over the parent device */ 172 parent_dev = __dev_get_by_index((struct net *)parent_net, iflink); 173 if (!parent_dev) { 174 pr_warn("Cannot find parent device. Skipping batadv-on-batadv check for %s\n", 175 net_dev->name); 176 return false; 177 } 178 179 if (batadv_mutual_parents(net_dev, net, parent_dev, parent_net)) 180 return false; 181 182 ret = batadv_is_on_batman_iface(parent_dev); 183 184 return ret; 185} 186 187static 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 */ 216static struct net_device *batadv_get_real_netdevice(struct net_device *netdev) 217{ 218 struct batadv_hard_iface *hard_iface = NULL; 219 struct net_device *real_netdev = NULL; 220 struct net *real_net; 221 struct net *net; 222 int iflink; 223 224 ASSERT_RTNL(); 225 226 if (!netdev) 227 return NULL; 228 229 iflink = dev_get_iflink(netdev); 230 if (iflink == 0) { 231 dev_hold(netdev); 232 return netdev; 233 } 234 235 hard_iface = batadv_hardif_get_by_netdev(netdev); 236 if (!hard_iface || !hard_iface->soft_iface) 237 goto out; 238 239 net = dev_net(hard_iface->soft_iface); 240 real_net = batadv_getlink_net(netdev, net); 241 242 /* iflink to itself, most likely physical device */ 243 if (net == real_net && netdev->ifindex == iflink) { 244 real_netdev = netdev; 245 dev_hold(real_netdev); 246 goto out; 247 } 248 249 real_netdev = dev_get_by_index(real_net, iflink); 250 251out: 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 */ 264struct net_device *batadv_get_real_netdev(struct net_device *net_device) 265{ 266 struct net_device *real_netdev; 267 268 rtnl_lock(); 269 real_netdev = batadv_get_real_netdevice(net_device); 270 rtnl_unlock(); 271 272 return real_netdev; 273} 274 275/** 276 * batadv_is_wext_netdev() - check if the given net_device struct is a 277 * wext wifi interface 278 * @net_device: the device to check 279 * 280 * Return: true if the net device is a wext wireless device, false 281 * otherwise. 282 */ 283static 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 */ 307static 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 */ 327static 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(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(real_netdev)) 346 wifi_flags |= BATADV_HARDIF_WIFI_WEXT_INDIRECT; 347 348 if (batadv_is_cfg80211_netdev(real_netdev)) 349 wifi_flags |= BATADV_HARDIF_WIFI_CFG80211_INDIRECT; 350 351out: 352 dev_put(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 */ 364bool 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 */ 380bool 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 */ 403int 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(hardif_neigh->orig, 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(hardif_neigh->orig, orig_neigh)) { 432 ret = BATADV_HARDIF_BCAST_DUPFWD; 433 } 434 435out: 436 rcu_read_unlock(); 437 return ret; 438} 439 440static struct batadv_hard_iface * 441batadv_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(&hard_iface->refcount)) 452 goto out; 453 } 454 455 hard_iface = NULL; 456 457out: 458 rcu_read_unlock(); 459 return hard_iface; 460} 461 462static 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); 473out: 474 batadv_hardif_put(primary_if); 475} 476 477static 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(&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, curr_hard_iface); 495 496out: 497 batadv_hardif_put(curr_hard_iface); 498} 499 500static bool 501batadv_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 509static 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(hard_iface->net_dev->dev_addr, 523 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 */ 537static void batadv_hardif_recalc_extra_skbroom(struct net_device *soft_iface) 538{ 539 const struct batadv_hard_iface *hard_iface; 540 unsigned short lower_header_len = 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 */ 581int batadv_hardif_min_mtu(struct net_device *soft_iface) 582{ 583 struct batadv_priv *bat_priv = netdev_priv(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(&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 611out: 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(&bat_priv->packet_size_max, 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 */ 632void batadv_update_min_mtu(struct net_device *soft_iface) 633{ 634 struct batadv_priv *bat_priv = netdev_priv(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 654static void 655batadv_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(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, 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(hard_iface->soft_iface); 679 680 if (bat_priv->algo_ops->iface.activate) 681 bat_priv->algo_ops->iface.activate(hard_iface); 682 683out: 684 batadv_hardif_put(primary_if); 685} 686 687static void 688batadv_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(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 */ 709int 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 max_header_len = 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(&hard_iface->refcount); 729 730 dev_hold(soft_iface); 731 hard_iface->soft_iface = soft_iface; 732 bat_priv = netdev_priv(hard_iface->soft_iface); 733 734 ret = netdev_master_upper_dev_link(hard_iface->net_dev, 735 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(&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(&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(&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(&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 780out: 781 return 0; 782 783err_upper: 784 netdev_upper_dev_unlink(hard_iface->net_dev, soft_iface); 785err_dev: 786 hard_iface->soft_iface = NULL; 787 dev_put(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 */ 802static 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 */ 823void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface) 824{ 825 struct batadv_priv *bat_priv = netdev_priv(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(&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(hard_iface->soft_iface); 843 batadv_primary_if_select(bat_priv, new_if); 844 845 batadv_hardif_put(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(hard_iface->soft_iface); 855 856 netdev_upper_dev_unlink(hard_iface->net_dev, hard_iface->soft_iface); 857 batadv_hardif_recalc_extra_skbroom(hard_iface->soft_iface); 858 859 /* nobody uses this interface anymore */ 860 if (batadv_hardif_cnt(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 866out: 867 batadv_hardif_put(primary_if); 868} 869 870static struct batadv_hard_iface * 871batadv_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(net_dev); 881 882 hard_iface = kzalloc(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(&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(&hard_iface->refcount); 896 897 hard_iface->num_bcasts = BATADV_NUM_BCASTS_DEFAULT; 898 hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_dev); 899 if (batadv_is_wifi_hardif(hard_iface)) 900 hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS; 901 902 atomic_set(&hard_iface->hop_penalty, 0); 903 904 batadv_v_hardif_init(hard_iface); 905 906 batadv_check_known_mac_addr(hard_iface->net_dev); 907 kref_get(&hard_iface->refcount); 908 list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list); 909 batadv_hardif_generation++; 910 911 return hard_iface; 912 913release_dev: 914 dev_put(net_dev); 915out: 916 return NULL; 917} 918 919static 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 */ 941static 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(net_dev); 949 batadv_softif_create_vlan(bat_priv, BATADV_NO_FLAGS); 950 break; 951 } 952 953 return NOTIFY_DONE; 954} 955 956static 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(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(&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(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(hard_iface->net_dev); 999 1000 bat_priv = netdev_priv(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_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 1019hardif_put: 1020 batadv_hardif_put(hard_iface); 1021out: 1022 batadv_hardif_put(primary_if); 1023 return NOTIFY_DONE; 1024} 1025 1026struct notifier_block batadv_hard_if_notifier = { 1027 .notifier_call = batadv_hard_if_event, 1028}; 1029