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