1 /* Copyright (C) 2007-2016 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 const struct net *batadv_getlink_net(const struct net_device *netdev, 96 const 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 const struct net *net1, 120 const struct net_device *dev2, 121 const 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 const 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_is_wifi_netdev - check if the given net_device struct is a wifi 206 * interface 207 * @net_device: the device to check 208 * 209 * Return: true if the net device is a 802.11 wireless device, false otherwise. 210 */ 211 bool batadv_is_wifi_netdev(struct net_device *net_device) 212 { 213 if (!net_device) 214 return false; 215 216 #ifdef CONFIG_WIRELESS_EXT 217 /* pre-cfg80211 drivers have to implement WEXT, so it is possible to 218 * check for wireless_handlers != NULL 219 */ 220 if (net_device->wireless_handlers) 221 return true; 222 #endif 223 224 /* cfg80211 drivers have to set ieee80211_ptr */ 225 if (net_device->ieee80211_ptr) 226 return true; 227 228 return false; 229 } 230 231 static struct batadv_hard_iface * 232 batadv_hardif_get_active(const struct net_device *soft_iface) 233 { 234 struct batadv_hard_iface *hard_iface; 235 236 rcu_read_lock(); 237 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 238 if (hard_iface->soft_iface != soft_iface) 239 continue; 240 241 if (hard_iface->if_status == BATADV_IF_ACTIVE && 242 kref_get_unless_zero(&hard_iface->refcount)) 243 goto out; 244 } 245 246 hard_iface = NULL; 247 248 out: 249 rcu_read_unlock(); 250 return hard_iface; 251 } 252 253 static void batadv_primary_if_update_addr(struct batadv_priv *bat_priv, 254 struct batadv_hard_iface *oldif) 255 { 256 struct batadv_hard_iface *primary_if; 257 258 primary_if = batadv_primary_if_get_selected(bat_priv); 259 if (!primary_if) 260 goto out; 261 262 batadv_dat_init_own_addr(bat_priv, primary_if); 263 batadv_bla_update_orig_address(bat_priv, primary_if, oldif); 264 out: 265 if (primary_if) 266 batadv_hardif_put(primary_if); 267 } 268 269 static void batadv_primary_if_select(struct batadv_priv *bat_priv, 270 struct batadv_hard_iface *new_hard_iface) 271 { 272 struct batadv_hard_iface *curr_hard_iface; 273 274 ASSERT_RTNL(); 275 276 if (new_hard_iface) 277 kref_get(&new_hard_iface->refcount); 278 279 curr_hard_iface = rcu_dereference_protected(bat_priv->primary_if, 1); 280 rcu_assign_pointer(bat_priv->primary_if, new_hard_iface); 281 282 if (!new_hard_iface) 283 goto out; 284 285 bat_priv->algo_ops->iface.primary_set(new_hard_iface); 286 batadv_primary_if_update_addr(bat_priv, curr_hard_iface); 287 288 out: 289 if (curr_hard_iface) 290 batadv_hardif_put(curr_hard_iface); 291 } 292 293 static bool 294 batadv_hardif_is_iface_up(const struct batadv_hard_iface *hard_iface) 295 { 296 if (hard_iface->net_dev->flags & IFF_UP) 297 return true; 298 299 return false; 300 } 301 302 static void batadv_check_known_mac_addr(const struct net_device *net_dev) 303 { 304 const struct batadv_hard_iface *hard_iface; 305 306 rcu_read_lock(); 307 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 308 if ((hard_iface->if_status != BATADV_IF_ACTIVE) && 309 (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) 310 continue; 311 312 if (hard_iface->net_dev == net_dev) 313 continue; 314 315 if (!batadv_compare_eth(hard_iface->net_dev->dev_addr, 316 net_dev->dev_addr)) 317 continue; 318 319 pr_warn("The newly added mac address (%pM) already exists on: %s\n", 320 net_dev->dev_addr, hard_iface->net_dev->name); 321 pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n"); 322 } 323 rcu_read_unlock(); 324 } 325 326 /** 327 * batadv_hardif_recalc_extra_skbroom() - Recalculate skbuff extra head/tailroom 328 * @soft_iface: netdev struct of the mesh interface 329 */ 330 static void batadv_hardif_recalc_extra_skbroom(struct net_device *soft_iface) 331 { 332 const struct batadv_hard_iface *hard_iface; 333 unsigned short lower_header_len = ETH_HLEN; 334 unsigned short lower_headroom = 0; 335 unsigned short lower_tailroom = 0; 336 unsigned short needed_headroom; 337 338 rcu_read_lock(); 339 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 340 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) 341 continue; 342 343 if (hard_iface->soft_iface != soft_iface) 344 continue; 345 346 lower_header_len = max_t(unsigned short, lower_header_len, 347 hard_iface->net_dev->hard_header_len); 348 349 lower_headroom = max_t(unsigned short, lower_headroom, 350 hard_iface->net_dev->needed_headroom); 351 352 lower_tailroom = max_t(unsigned short, lower_tailroom, 353 hard_iface->net_dev->needed_tailroom); 354 } 355 rcu_read_unlock(); 356 357 needed_headroom = lower_headroom + (lower_header_len - ETH_HLEN); 358 needed_headroom += batadv_max_header_len(); 359 360 soft_iface->needed_headroom = needed_headroom; 361 soft_iface->needed_tailroom = lower_tailroom; 362 } 363 364 int batadv_hardif_min_mtu(struct net_device *soft_iface) 365 { 366 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 367 const struct batadv_hard_iface *hard_iface; 368 int min_mtu = INT_MAX; 369 370 rcu_read_lock(); 371 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 372 if ((hard_iface->if_status != BATADV_IF_ACTIVE) && 373 (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) 374 continue; 375 376 if (hard_iface->soft_iface != soft_iface) 377 continue; 378 379 min_mtu = min_t(int, hard_iface->net_dev->mtu, min_mtu); 380 } 381 rcu_read_unlock(); 382 383 if (atomic_read(&bat_priv->fragmentation) == 0) 384 goto out; 385 386 /* with fragmentation enabled the maximum size of internally generated 387 * packets such as translation table exchanges or tvlv containers, etc 388 * has to be calculated 389 */ 390 min_mtu = min_t(int, min_mtu, BATADV_FRAG_MAX_FRAG_SIZE); 391 min_mtu -= sizeof(struct batadv_frag_packet); 392 min_mtu *= BATADV_FRAG_MAX_FRAGMENTS; 393 394 out: 395 /* report to the other components the maximum amount of bytes that 396 * batman-adv can send over the wire (without considering the payload 397 * overhead). For example, this value is used by TT to compute the 398 * maximum local table table size 399 */ 400 atomic_set(&bat_priv->packet_size_max, min_mtu); 401 402 /* the real soft-interface MTU is computed by removing the payload 403 * overhead from the maximum amount of bytes that was just computed. 404 * 405 * However batman-adv does not support MTUs bigger than ETH_DATA_LEN 406 */ 407 return min_t(int, min_mtu - batadv_max_header_len(), ETH_DATA_LEN); 408 } 409 410 /* adjusts the MTU if a new interface with a smaller MTU appeared. */ 411 void batadv_update_min_mtu(struct net_device *soft_iface) 412 { 413 soft_iface->mtu = batadv_hardif_min_mtu(soft_iface); 414 415 /* Check if the local translate table should be cleaned up to match a 416 * new (and smaller) MTU. 417 */ 418 batadv_tt_local_resize_to_mtu(soft_iface); 419 } 420 421 static void 422 batadv_hardif_activate_interface(struct batadv_hard_iface *hard_iface) 423 { 424 struct batadv_priv *bat_priv; 425 struct batadv_hard_iface *primary_if = NULL; 426 427 if (hard_iface->if_status != BATADV_IF_INACTIVE) 428 goto out; 429 430 bat_priv = netdev_priv(hard_iface->soft_iface); 431 432 bat_priv->algo_ops->iface.update_mac(hard_iface); 433 hard_iface->if_status = BATADV_IF_TO_BE_ACTIVATED; 434 435 /* the first active interface becomes our primary interface or 436 * the next active interface after the old primary interface was removed 437 */ 438 primary_if = batadv_primary_if_get_selected(bat_priv); 439 if (!primary_if) 440 batadv_primary_if_select(bat_priv, hard_iface); 441 442 batadv_info(hard_iface->soft_iface, "Interface activated: %s\n", 443 hard_iface->net_dev->name); 444 445 batadv_update_min_mtu(hard_iface->soft_iface); 446 447 if (bat_priv->algo_ops->iface.activate) 448 bat_priv->algo_ops->iface.activate(hard_iface); 449 450 out: 451 if (primary_if) 452 batadv_hardif_put(primary_if); 453 } 454 455 static void 456 batadv_hardif_deactivate_interface(struct batadv_hard_iface *hard_iface) 457 { 458 if ((hard_iface->if_status != BATADV_IF_ACTIVE) && 459 (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) 460 return; 461 462 hard_iface->if_status = BATADV_IF_INACTIVE; 463 464 batadv_info(hard_iface->soft_iface, "Interface deactivated: %s\n", 465 hard_iface->net_dev->name); 466 467 batadv_update_min_mtu(hard_iface->soft_iface); 468 } 469 470 /** 471 * batadv_master_del_slave - remove hard_iface from the current master interface 472 * @slave: the interface enslaved in another master 473 * @master: the master from which slave has to be removed 474 * 475 * Invoke ndo_del_slave on master passing slave as argument. In this way slave 476 * is free'd and master can correctly change its internal state. 477 * 478 * Return: 0 on success, a negative value representing the error otherwise 479 */ 480 static int batadv_master_del_slave(struct batadv_hard_iface *slave, 481 struct net_device *master) 482 { 483 int ret; 484 485 if (!master) 486 return 0; 487 488 ret = -EBUSY; 489 if (master->netdev_ops->ndo_del_slave) 490 ret = master->netdev_ops->ndo_del_slave(master, slave->net_dev); 491 492 return ret; 493 } 494 495 int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, 496 struct net *net, const char *iface_name) 497 { 498 struct batadv_priv *bat_priv; 499 struct net_device *soft_iface, *master; 500 __be16 ethertype = htons(ETH_P_BATMAN); 501 int max_header_len = batadv_max_header_len(); 502 int ret; 503 504 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 505 goto out; 506 507 kref_get(&hard_iface->refcount); 508 509 soft_iface = dev_get_by_name(net, iface_name); 510 511 if (!soft_iface) { 512 soft_iface = batadv_softif_create(net, iface_name); 513 514 if (!soft_iface) { 515 ret = -ENOMEM; 516 goto err; 517 } 518 519 /* dev_get_by_name() increases the reference counter for us */ 520 dev_hold(soft_iface); 521 } 522 523 if (!batadv_softif_is_valid(soft_iface)) { 524 pr_err("Can't create batman mesh interface %s: already exists as regular interface\n", 525 soft_iface->name); 526 ret = -EINVAL; 527 goto err_dev; 528 } 529 530 /* check if the interface is enslaved in another virtual one and 531 * in that case unlink it first 532 */ 533 master = netdev_master_upper_dev_get(hard_iface->net_dev); 534 ret = batadv_master_del_slave(hard_iface, master); 535 if (ret) 536 goto err_dev; 537 538 hard_iface->soft_iface = soft_iface; 539 bat_priv = netdev_priv(hard_iface->soft_iface); 540 541 ret = netdev_master_upper_dev_link(hard_iface->net_dev, 542 soft_iface, NULL, NULL); 543 if (ret) 544 goto err_dev; 545 546 ret = bat_priv->algo_ops->iface.enable(hard_iface); 547 if (ret < 0) 548 goto err_upper; 549 550 hard_iface->if_num = bat_priv->num_ifaces; 551 bat_priv->num_ifaces++; 552 hard_iface->if_status = BATADV_IF_INACTIVE; 553 ret = batadv_orig_hash_add_if(hard_iface, bat_priv->num_ifaces); 554 if (ret < 0) { 555 bat_priv->algo_ops->iface.disable(hard_iface); 556 bat_priv->num_ifaces--; 557 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 558 goto err_upper; 559 } 560 561 kref_get(&hard_iface->refcount); 562 hard_iface->batman_adv_ptype.type = ethertype; 563 hard_iface->batman_adv_ptype.func = batadv_batman_skb_recv; 564 hard_iface->batman_adv_ptype.dev = hard_iface->net_dev; 565 dev_add_pack(&hard_iface->batman_adv_ptype); 566 567 batadv_info(hard_iface->soft_iface, "Adding interface: %s\n", 568 hard_iface->net_dev->name); 569 570 if (atomic_read(&bat_priv->fragmentation) && 571 hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len) 572 batadv_info(hard_iface->soft_iface, 573 "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", 574 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 575 ETH_DATA_LEN + max_header_len); 576 577 if (!atomic_read(&bat_priv->fragmentation) && 578 hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len) 579 batadv_info(hard_iface->soft_iface, 580 "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", 581 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 582 ETH_DATA_LEN + max_header_len); 583 584 if (batadv_hardif_is_iface_up(hard_iface)) 585 batadv_hardif_activate_interface(hard_iface); 586 else 587 batadv_err(hard_iface->soft_iface, 588 "Not using interface %s (retrying later): interface not active\n", 589 hard_iface->net_dev->name); 590 591 batadv_hardif_recalc_extra_skbroom(soft_iface); 592 593 out: 594 return 0; 595 596 err_upper: 597 netdev_upper_dev_unlink(hard_iface->net_dev, soft_iface); 598 err_dev: 599 hard_iface->soft_iface = NULL; 600 dev_put(soft_iface); 601 err: 602 batadv_hardif_put(hard_iface); 603 return ret; 604 } 605 606 void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface, 607 enum batadv_hard_if_cleanup autodel) 608 { 609 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 610 struct batadv_hard_iface *primary_if = NULL; 611 612 batadv_hardif_deactivate_interface(hard_iface); 613 614 if (hard_iface->if_status != BATADV_IF_INACTIVE) 615 goto out; 616 617 batadv_info(hard_iface->soft_iface, "Removing interface: %s\n", 618 hard_iface->net_dev->name); 619 dev_remove_pack(&hard_iface->batman_adv_ptype); 620 batadv_hardif_put(hard_iface); 621 622 bat_priv->num_ifaces--; 623 batadv_orig_hash_del_if(hard_iface, bat_priv->num_ifaces); 624 625 primary_if = batadv_primary_if_get_selected(bat_priv); 626 if (hard_iface == primary_if) { 627 struct batadv_hard_iface *new_if; 628 629 new_if = batadv_hardif_get_active(hard_iface->soft_iface); 630 batadv_primary_if_select(bat_priv, new_if); 631 632 if (new_if) 633 batadv_hardif_put(new_if); 634 } 635 636 bat_priv->algo_ops->iface.disable(hard_iface); 637 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 638 639 /* delete all references to this hard_iface */ 640 batadv_purge_orig_ref(bat_priv); 641 batadv_purge_outstanding_packets(bat_priv, hard_iface); 642 dev_put(hard_iface->soft_iface); 643 644 netdev_upper_dev_unlink(hard_iface->net_dev, hard_iface->soft_iface); 645 batadv_hardif_recalc_extra_skbroom(hard_iface->soft_iface); 646 647 /* nobody uses this interface anymore */ 648 if (!bat_priv->num_ifaces) { 649 batadv_gw_check_client_stop(bat_priv); 650 651 if (autodel == BATADV_IF_CLEANUP_AUTO) 652 batadv_softif_destroy_sysfs(hard_iface->soft_iface); 653 } 654 655 batadv_hardif_put(hard_iface); 656 657 out: 658 if (primary_if) 659 batadv_hardif_put(primary_if); 660 } 661 662 static struct batadv_hard_iface * 663 batadv_hardif_add_interface(struct net_device *net_dev) 664 { 665 struct batadv_hard_iface *hard_iface; 666 int ret; 667 668 ASSERT_RTNL(); 669 670 if (!batadv_is_valid_iface(net_dev)) 671 goto out; 672 673 dev_hold(net_dev); 674 675 hard_iface = kzalloc(sizeof(*hard_iface), GFP_ATOMIC); 676 if (!hard_iface) 677 goto release_dev; 678 679 ret = batadv_sysfs_add_hardif(&hard_iface->hardif_obj, net_dev); 680 if (ret) 681 goto free_if; 682 683 hard_iface->if_num = -1; 684 hard_iface->net_dev = net_dev; 685 hard_iface->soft_iface = NULL; 686 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 687 688 ret = batadv_debugfs_add_hardif(hard_iface); 689 if (ret) 690 goto free_sysfs; 691 692 INIT_LIST_HEAD(&hard_iface->list); 693 INIT_HLIST_HEAD(&hard_iface->neigh_list); 694 695 spin_lock_init(&hard_iface->neigh_list_lock); 696 kref_init(&hard_iface->refcount); 697 698 hard_iface->num_bcasts = BATADV_NUM_BCASTS_DEFAULT; 699 if (batadv_is_wifi_netdev(net_dev)) 700 hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS; 701 702 batadv_v_hardif_init(hard_iface); 703 704 batadv_check_known_mac_addr(hard_iface->net_dev); 705 kref_get(&hard_iface->refcount); 706 list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list); 707 708 return hard_iface; 709 710 free_sysfs: 711 batadv_sysfs_del_hardif(&hard_iface->hardif_obj); 712 free_if: 713 kfree(hard_iface); 714 release_dev: 715 dev_put(net_dev); 716 out: 717 return NULL; 718 } 719 720 static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface) 721 { 722 ASSERT_RTNL(); 723 724 /* first deactivate interface */ 725 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 726 batadv_hardif_disable_interface(hard_iface, 727 BATADV_IF_CLEANUP_KEEP); 728 729 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 730 return; 731 732 hard_iface->if_status = BATADV_IF_TO_BE_REMOVED; 733 batadv_debugfs_del_hardif(hard_iface); 734 batadv_sysfs_del_hardif(&hard_iface->hardif_obj); 735 batadv_hardif_put(hard_iface); 736 } 737 738 void batadv_hardif_remove_interfaces(void) 739 { 740 struct batadv_hard_iface *hard_iface, *hard_iface_tmp; 741 742 rtnl_lock(); 743 list_for_each_entry_safe(hard_iface, hard_iface_tmp, 744 &batadv_hardif_list, list) { 745 list_del_rcu(&hard_iface->list); 746 batadv_hardif_remove_interface(hard_iface); 747 } 748 rtnl_unlock(); 749 } 750 751 static int batadv_hard_if_event(struct notifier_block *this, 752 unsigned long event, void *ptr) 753 { 754 struct net_device *net_dev = netdev_notifier_info_to_dev(ptr); 755 struct batadv_hard_iface *hard_iface; 756 struct batadv_hard_iface *primary_if = NULL; 757 struct batadv_priv *bat_priv; 758 759 if (batadv_softif_is_valid(net_dev) && event == NETDEV_REGISTER) { 760 batadv_sysfs_add_meshif(net_dev); 761 bat_priv = netdev_priv(net_dev); 762 batadv_softif_create_vlan(bat_priv, BATADV_NO_FLAGS); 763 return NOTIFY_DONE; 764 } 765 766 hard_iface = batadv_hardif_get_by_netdev(net_dev); 767 if (!hard_iface && (event == NETDEV_REGISTER || 768 event == NETDEV_POST_TYPE_CHANGE)) 769 hard_iface = batadv_hardif_add_interface(net_dev); 770 771 if (!hard_iface) 772 goto out; 773 774 switch (event) { 775 case NETDEV_UP: 776 batadv_hardif_activate_interface(hard_iface); 777 break; 778 case NETDEV_GOING_DOWN: 779 case NETDEV_DOWN: 780 batadv_hardif_deactivate_interface(hard_iface); 781 break; 782 case NETDEV_UNREGISTER: 783 case NETDEV_PRE_TYPE_CHANGE: 784 list_del_rcu(&hard_iface->list); 785 786 batadv_hardif_remove_interface(hard_iface); 787 break; 788 case NETDEV_CHANGEMTU: 789 if (hard_iface->soft_iface) 790 batadv_update_min_mtu(hard_iface->soft_iface); 791 break; 792 case NETDEV_CHANGEADDR: 793 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) 794 goto hardif_put; 795 796 batadv_check_known_mac_addr(hard_iface->net_dev); 797 798 bat_priv = netdev_priv(hard_iface->soft_iface); 799 bat_priv->algo_ops->iface.update_mac(hard_iface); 800 801 primary_if = batadv_primary_if_get_selected(bat_priv); 802 if (!primary_if) 803 goto hardif_put; 804 805 if (hard_iface == primary_if) 806 batadv_primary_if_update_addr(bat_priv, NULL); 807 break; 808 default: 809 break; 810 } 811 812 hardif_put: 813 batadv_hardif_put(hard_iface); 814 out: 815 if (primary_if) 816 batadv_hardif_put(primary_if); 817 return NOTIFY_DONE; 818 } 819 820 struct notifier_block batadv_hard_if_notifier = { 821 .notifier_call = batadv_hard_if_event, 822 }; 823