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