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