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