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