1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2007-2017 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_num = bat_priv->num_ifaces; 776 bat_priv->num_ifaces++; 777 hard_iface->if_status = BATADV_IF_INACTIVE; 778 ret = batadv_orig_hash_add_if(hard_iface, bat_priv->num_ifaces); 779 if (ret < 0) { 780 bat_priv->algo_ops->iface.disable(hard_iface); 781 bat_priv->num_ifaces--; 782 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 783 goto err_upper; 784 } 785 786 kref_get(&hard_iface->refcount); 787 hard_iface->batman_adv_ptype.type = ethertype; 788 hard_iface->batman_adv_ptype.func = batadv_batman_skb_recv; 789 hard_iface->batman_adv_ptype.dev = hard_iface->net_dev; 790 dev_add_pack(&hard_iface->batman_adv_ptype); 791 792 batadv_info(hard_iface->soft_iface, "Adding interface: %s\n", 793 hard_iface->net_dev->name); 794 795 if (atomic_read(&bat_priv->fragmentation) && 796 hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len) 797 batadv_info(hard_iface->soft_iface, 798 "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", 799 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 800 ETH_DATA_LEN + max_header_len); 801 802 if (!atomic_read(&bat_priv->fragmentation) && 803 hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len) 804 batadv_info(hard_iface->soft_iface, 805 "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", 806 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 807 ETH_DATA_LEN + max_header_len); 808 809 if (batadv_hardif_is_iface_up(hard_iface)) 810 batadv_hardif_activate_interface(hard_iface); 811 else 812 batadv_err(hard_iface->soft_iface, 813 "Not using interface %s (retrying later): interface not active\n", 814 hard_iface->net_dev->name); 815 816 batadv_hardif_recalc_extra_skbroom(soft_iface); 817 818 out: 819 return 0; 820 821 err_upper: 822 netdev_upper_dev_unlink(hard_iface->net_dev, soft_iface); 823 err_dev: 824 hard_iface->soft_iface = NULL; 825 dev_put(soft_iface); 826 err: 827 batadv_hardif_put(hard_iface); 828 return ret; 829 } 830 831 /** 832 * batadv_hardif_disable_interface() - Remove hard interface from soft interface 833 * @hard_iface: hard interface to be removed 834 * @autodel: whether to delete soft interface when it doesn't contain any other 835 * slave interfaces 836 */ 837 void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface, 838 enum batadv_hard_if_cleanup autodel) 839 { 840 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 841 struct batadv_hard_iface *primary_if = NULL; 842 843 batadv_hardif_deactivate_interface(hard_iface); 844 845 if (hard_iface->if_status != BATADV_IF_INACTIVE) 846 goto out; 847 848 batadv_info(hard_iface->soft_iface, "Removing interface: %s\n", 849 hard_iface->net_dev->name); 850 dev_remove_pack(&hard_iface->batman_adv_ptype); 851 batadv_hardif_put(hard_iface); 852 853 bat_priv->num_ifaces--; 854 batadv_orig_hash_del_if(hard_iface, bat_priv->num_ifaces); 855 856 primary_if = batadv_primary_if_get_selected(bat_priv); 857 if (hard_iface == primary_if) { 858 struct batadv_hard_iface *new_if; 859 860 new_if = batadv_hardif_get_active(hard_iface->soft_iface); 861 batadv_primary_if_select(bat_priv, new_if); 862 863 if (new_if) 864 batadv_hardif_put(new_if); 865 } 866 867 bat_priv->algo_ops->iface.disable(hard_iface); 868 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 869 870 /* delete all references to this hard_iface */ 871 batadv_purge_orig_ref(bat_priv); 872 batadv_purge_outstanding_packets(bat_priv, hard_iface); 873 dev_put(hard_iface->soft_iface); 874 875 netdev_upper_dev_unlink(hard_iface->net_dev, hard_iface->soft_iface); 876 batadv_hardif_recalc_extra_skbroom(hard_iface->soft_iface); 877 878 /* nobody uses this interface anymore */ 879 if (!bat_priv->num_ifaces) { 880 batadv_gw_check_client_stop(bat_priv); 881 882 if (autodel == BATADV_IF_CLEANUP_AUTO) 883 batadv_softif_destroy_sysfs(hard_iface->soft_iface); 884 } 885 886 hard_iface->soft_iface = NULL; 887 batadv_hardif_put(hard_iface); 888 889 out: 890 if (primary_if) 891 batadv_hardif_put(primary_if); 892 } 893 894 static struct batadv_hard_iface * 895 batadv_hardif_add_interface(struct net_device *net_dev) 896 { 897 struct batadv_hard_iface *hard_iface; 898 int ret; 899 900 ASSERT_RTNL(); 901 902 if (!batadv_is_valid_iface(net_dev)) 903 goto out; 904 905 dev_hold(net_dev); 906 907 hard_iface = kzalloc(sizeof(*hard_iface), GFP_ATOMIC); 908 if (!hard_iface) 909 goto release_dev; 910 911 ret = batadv_sysfs_add_hardif(&hard_iface->hardif_obj, net_dev); 912 if (ret) 913 goto free_if; 914 915 hard_iface->if_num = -1; 916 hard_iface->net_dev = net_dev; 917 hard_iface->soft_iface = NULL; 918 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 919 920 ret = batadv_debugfs_add_hardif(hard_iface); 921 if (ret) 922 goto free_sysfs; 923 924 INIT_LIST_HEAD(&hard_iface->list); 925 INIT_HLIST_HEAD(&hard_iface->neigh_list); 926 927 spin_lock_init(&hard_iface->neigh_list_lock); 928 kref_init(&hard_iface->refcount); 929 930 hard_iface->num_bcasts = BATADV_NUM_BCASTS_DEFAULT; 931 hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_dev); 932 if (batadv_is_wifi_hardif(hard_iface)) 933 hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS; 934 935 batadv_v_hardif_init(hard_iface); 936 937 batadv_check_known_mac_addr(hard_iface->net_dev); 938 kref_get(&hard_iface->refcount); 939 list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list); 940 941 return hard_iface; 942 943 free_sysfs: 944 batadv_sysfs_del_hardif(&hard_iface->hardif_obj); 945 free_if: 946 kfree(hard_iface); 947 release_dev: 948 dev_put(net_dev); 949 out: 950 return NULL; 951 } 952 953 static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface) 954 { 955 ASSERT_RTNL(); 956 957 /* first deactivate interface */ 958 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 959 batadv_hardif_disable_interface(hard_iface, 960 BATADV_IF_CLEANUP_KEEP); 961 962 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 963 return; 964 965 hard_iface->if_status = BATADV_IF_TO_BE_REMOVED; 966 batadv_debugfs_del_hardif(hard_iface); 967 batadv_sysfs_del_hardif(&hard_iface->hardif_obj); 968 batadv_hardif_put(hard_iface); 969 } 970 971 /** 972 * batadv_hardif_remove_interfaces() - Remove all hard interfaces 973 */ 974 void batadv_hardif_remove_interfaces(void) 975 { 976 struct batadv_hard_iface *hard_iface, *hard_iface_tmp; 977 978 rtnl_lock(); 979 list_for_each_entry_safe(hard_iface, hard_iface_tmp, 980 &batadv_hardif_list, list) { 981 list_del_rcu(&hard_iface->list); 982 batadv_hardif_remove_interface(hard_iface); 983 } 984 rtnl_unlock(); 985 } 986 987 static int batadv_hard_if_event(struct notifier_block *this, 988 unsigned long event, void *ptr) 989 { 990 struct net_device *net_dev = netdev_notifier_info_to_dev(ptr); 991 struct batadv_hard_iface *hard_iface; 992 struct batadv_hard_iface *primary_if = NULL; 993 struct batadv_priv *bat_priv; 994 995 if (batadv_softif_is_valid(net_dev) && event == NETDEV_REGISTER) { 996 batadv_sysfs_add_meshif(net_dev); 997 bat_priv = netdev_priv(net_dev); 998 batadv_softif_create_vlan(bat_priv, BATADV_NO_FLAGS); 999 return NOTIFY_DONE; 1000 } 1001 1002 hard_iface = batadv_hardif_get_by_netdev(net_dev); 1003 if (!hard_iface && (event == NETDEV_REGISTER || 1004 event == NETDEV_POST_TYPE_CHANGE)) 1005 hard_iface = batadv_hardif_add_interface(net_dev); 1006 1007 if (!hard_iface) 1008 goto out; 1009 1010 switch (event) { 1011 case NETDEV_UP: 1012 batadv_hardif_activate_interface(hard_iface); 1013 break; 1014 case NETDEV_GOING_DOWN: 1015 case NETDEV_DOWN: 1016 batadv_hardif_deactivate_interface(hard_iface); 1017 break; 1018 case NETDEV_UNREGISTER: 1019 case NETDEV_PRE_TYPE_CHANGE: 1020 list_del_rcu(&hard_iface->list); 1021 1022 batadv_hardif_remove_interface(hard_iface); 1023 break; 1024 case NETDEV_CHANGEMTU: 1025 if (hard_iface->soft_iface) 1026 batadv_update_min_mtu(hard_iface->soft_iface); 1027 break; 1028 case NETDEV_CHANGEADDR: 1029 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) 1030 goto hardif_put; 1031 1032 batadv_check_known_mac_addr(hard_iface->net_dev); 1033 1034 bat_priv = netdev_priv(hard_iface->soft_iface); 1035 bat_priv->algo_ops->iface.update_mac(hard_iface); 1036 1037 primary_if = batadv_primary_if_get_selected(bat_priv); 1038 if (!primary_if) 1039 goto hardif_put; 1040 1041 if (hard_iface == primary_if) 1042 batadv_primary_if_update_addr(bat_priv, NULL); 1043 break; 1044 case NETDEV_CHANGEUPPER: 1045 hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_dev); 1046 if (batadv_is_wifi_hardif(hard_iface)) 1047 hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS; 1048 break; 1049 default: 1050 break; 1051 } 1052 1053 hardif_put: 1054 batadv_hardif_put(hard_iface); 1055 out: 1056 if (primary_if) 1057 batadv_hardif_put(primary_if); 1058 return NOTIFY_DONE; 1059 } 1060 1061 struct notifier_block batadv_hard_if_notifier = { 1062 .notifier_call = batadv_hard_if_event, 1063 }; 1064