1 /* Copyright (C) 2007-2014 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 "main.h" 19 #include "distributed-arp-table.h" 20 #include "hard-interface.h" 21 #include "soft-interface.h" 22 #include "send.h" 23 #include "translation-table.h" 24 #include "routing.h" 25 #include "sysfs.h" 26 #include "debugfs.h" 27 #include "originator.h" 28 #include "hash.h" 29 #include "bridge_loop_avoidance.h" 30 #include "gateway_client.h" 31 32 #include <linux/if_arp.h> 33 #include <linux/if_ether.h> 34 35 void batadv_hardif_free_rcu(struct rcu_head *rcu) 36 { 37 struct batadv_hard_iface *hard_iface; 38 39 hard_iface = container_of(rcu, struct batadv_hard_iface, rcu); 40 dev_put(hard_iface->net_dev); 41 kfree(hard_iface); 42 } 43 44 struct batadv_hard_iface * 45 batadv_hardif_get_by_netdev(const struct net_device *net_dev) 46 { 47 struct batadv_hard_iface *hard_iface; 48 49 rcu_read_lock(); 50 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 51 if (hard_iface->net_dev == net_dev && 52 atomic_inc_not_zero(&hard_iface->refcount)) 53 goto out; 54 } 55 56 hard_iface = NULL; 57 58 out: 59 rcu_read_unlock(); 60 return hard_iface; 61 } 62 63 /** 64 * batadv_is_on_batman_iface - check if a device is a batman iface descendant 65 * @net_dev: the device to check 66 * 67 * If the user creates any virtual device on top of a batman-adv interface, it 68 * is important to prevent this new interface to be used to create a new mesh 69 * network (this behaviour would lead to a batman-over-batman configuration). 70 * This function recursively checks all the fathers of the device passed as 71 * argument looking for a batman-adv soft interface. 72 * 73 * Returns true if the device is descendant of a batman-adv mesh interface (or 74 * if it is a batman-adv interface itself), false otherwise 75 */ 76 static bool batadv_is_on_batman_iface(const struct net_device *net_dev) 77 { 78 struct net_device *parent_dev; 79 bool ret; 80 81 /* check if this is a batman-adv mesh interface */ 82 if (batadv_softif_is_valid(net_dev)) 83 return true; 84 85 /* no more parents..stop recursion */ 86 if (net_dev->iflink == net_dev->ifindex) 87 return false; 88 89 /* recurse over the parent device */ 90 parent_dev = __dev_get_by_index(&init_net, net_dev->iflink); 91 /* if we got a NULL parent_dev there is something broken.. */ 92 if (WARN(!parent_dev, "Cannot find parent device")) 93 return false; 94 95 ret = batadv_is_on_batman_iface(parent_dev); 96 97 return ret; 98 } 99 100 static int batadv_is_valid_iface(const struct net_device *net_dev) 101 { 102 if (net_dev->flags & IFF_LOOPBACK) 103 return 0; 104 105 if (net_dev->type != ARPHRD_ETHER) 106 return 0; 107 108 if (net_dev->addr_len != ETH_ALEN) 109 return 0; 110 111 /* no batman over batman */ 112 if (batadv_is_on_batman_iface(net_dev)) 113 return 0; 114 115 return 1; 116 } 117 118 /** 119 * batadv_is_wifi_netdev - check if the given net_device struct is a wifi 120 * interface 121 * @net_device: the device to check 122 * 123 * Returns true if the net device is a 802.11 wireless device, false otherwise. 124 */ 125 bool batadv_is_wifi_netdev(struct net_device *net_device) 126 { 127 if (!net_device) 128 return false; 129 130 #ifdef CONFIG_WIRELESS_EXT 131 /* pre-cfg80211 drivers have to implement WEXT, so it is possible to 132 * check for wireless_handlers != NULL 133 */ 134 if (net_device->wireless_handlers) 135 return true; 136 #endif 137 138 /* cfg80211 drivers have to set ieee80211_ptr */ 139 if (net_device->ieee80211_ptr) 140 return true; 141 142 return false; 143 } 144 145 static struct batadv_hard_iface * 146 batadv_hardif_get_active(const struct net_device *soft_iface) 147 { 148 struct batadv_hard_iface *hard_iface; 149 150 rcu_read_lock(); 151 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 152 if (hard_iface->soft_iface != soft_iface) 153 continue; 154 155 if (hard_iface->if_status == BATADV_IF_ACTIVE && 156 atomic_inc_not_zero(&hard_iface->refcount)) 157 goto out; 158 } 159 160 hard_iface = NULL; 161 162 out: 163 rcu_read_unlock(); 164 return hard_iface; 165 } 166 167 static void batadv_primary_if_update_addr(struct batadv_priv *bat_priv, 168 struct batadv_hard_iface *oldif) 169 { 170 struct batadv_hard_iface *primary_if; 171 172 primary_if = batadv_primary_if_get_selected(bat_priv); 173 if (!primary_if) 174 goto out; 175 176 batadv_dat_init_own_addr(bat_priv, primary_if); 177 batadv_bla_update_orig_address(bat_priv, primary_if, oldif); 178 out: 179 if (primary_if) 180 batadv_hardif_free_ref(primary_if); 181 } 182 183 static void batadv_primary_if_select(struct batadv_priv *bat_priv, 184 struct batadv_hard_iface *new_hard_iface) 185 { 186 struct batadv_hard_iface *curr_hard_iface; 187 188 ASSERT_RTNL(); 189 190 if (new_hard_iface && !atomic_inc_not_zero(&new_hard_iface->refcount)) 191 new_hard_iface = NULL; 192 193 curr_hard_iface = rcu_dereference_protected(bat_priv->primary_if, 1); 194 rcu_assign_pointer(bat_priv->primary_if, new_hard_iface); 195 196 if (!new_hard_iface) 197 goto out; 198 199 bat_priv->bat_algo_ops->bat_primary_iface_set(new_hard_iface); 200 batadv_primary_if_update_addr(bat_priv, curr_hard_iface); 201 202 out: 203 if (curr_hard_iface) 204 batadv_hardif_free_ref(curr_hard_iface); 205 } 206 207 static bool 208 batadv_hardif_is_iface_up(const struct batadv_hard_iface *hard_iface) 209 { 210 if (hard_iface->net_dev->flags & IFF_UP) 211 return true; 212 213 return false; 214 } 215 216 static void batadv_check_known_mac_addr(const struct net_device *net_dev) 217 { 218 const struct batadv_hard_iface *hard_iface; 219 220 rcu_read_lock(); 221 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 222 if ((hard_iface->if_status != BATADV_IF_ACTIVE) && 223 (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) 224 continue; 225 226 if (hard_iface->net_dev == net_dev) 227 continue; 228 229 if (!batadv_compare_eth(hard_iface->net_dev->dev_addr, 230 net_dev->dev_addr)) 231 continue; 232 233 pr_warn("The newly added mac address (%pM) already exists on: %s\n", 234 net_dev->dev_addr, hard_iface->net_dev->name); 235 pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n"); 236 } 237 rcu_read_unlock(); 238 } 239 240 int batadv_hardif_min_mtu(struct net_device *soft_iface) 241 { 242 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 243 const struct batadv_hard_iface *hard_iface; 244 int min_mtu = INT_MAX; 245 246 rcu_read_lock(); 247 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 248 if ((hard_iface->if_status != BATADV_IF_ACTIVE) && 249 (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) 250 continue; 251 252 if (hard_iface->soft_iface != soft_iface) 253 continue; 254 255 min_mtu = min_t(int, hard_iface->net_dev->mtu, min_mtu); 256 } 257 rcu_read_unlock(); 258 259 if (atomic_read(&bat_priv->fragmentation) == 0) 260 goto out; 261 262 /* with fragmentation enabled the maximum size of internally generated 263 * packets such as translation table exchanges or tvlv containers, etc 264 * has to be calculated 265 */ 266 min_mtu = min_t(int, min_mtu, BATADV_FRAG_MAX_FRAG_SIZE); 267 min_mtu -= sizeof(struct batadv_frag_packet); 268 min_mtu *= BATADV_FRAG_MAX_FRAGMENTS; 269 270 out: 271 /* report to the other components the maximum amount of bytes that 272 * batman-adv can send over the wire (without considering the payload 273 * overhead). For example, this value is used by TT to compute the 274 * maximum local table table size 275 */ 276 atomic_set(&bat_priv->packet_size_max, min_mtu); 277 278 /* the real soft-interface MTU is computed by removing the payload 279 * overhead from the maximum amount of bytes that was just computed. 280 * 281 * However batman-adv does not support MTUs bigger than ETH_DATA_LEN 282 */ 283 return min_t(int, min_mtu - batadv_max_header_len(), ETH_DATA_LEN); 284 } 285 286 /* adjusts the MTU if a new interface with a smaller MTU appeared. */ 287 void batadv_update_min_mtu(struct net_device *soft_iface) 288 { 289 soft_iface->mtu = batadv_hardif_min_mtu(soft_iface); 290 291 /* Check if the local translate table should be cleaned up to match a 292 * new (and smaller) MTU. 293 */ 294 batadv_tt_local_resize_to_mtu(soft_iface); 295 } 296 297 static void 298 batadv_hardif_activate_interface(struct batadv_hard_iface *hard_iface) 299 { 300 struct batadv_priv *bat_priv; 301 struct batadv_hard_iface *primary_if = NULL; 302 303 if (hard_iface->if_status != BATADV_IF_INACTIVE) 304 goto out; 305 306 bat_priv = netdev_priv(hard_iface->soft_iface); 307 308 bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface); 309 hard_iface->if_status = BATADV_IF_TO_BE_ACTIVATED; 310 311 /* the first active interface becomes our primary interface or 312 * the next active interface after the old primary interface was removed 313 */ 314 primary_if = batadv_primary_if_get_selected(bat_priv); 315 if (!primary_if) 316 batadv_primary_if_select(bat_priv, hard_iface); 317 318 batadv_info(hard_iface->soft_iface, "Interface activated: %s\n", 319 hard_iface->net_dev->name); 320 321 batadv_update_min_mtu(hard_iface->soft_iface); 322 323 out: 324 if (primary_if) 325 batadv_hardif_free_ref(primary_if); 326 } 327 328 static void 329 batadv_hardif_deactivate_interface(struct batadv_hard_iface *hard_iface) 330 { 331 if ((hard_iface->if_status != BATADV_IF_ACTIVE) && 332 (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) 333 return; 334 335 hard_iface->if_status = BATADV_IF_INACTIVE; 336 337 batadv_info(hard_iface->soft_iface, "Interface deactivated: %s\n", 338 hard_iface->net_dev->name); 339 340 batadv_update_min_mtu(hard_iface->soft_iface); 341 } 342 343 /** 344 * batadv_master_del_slave - remove hard_iface from the current master interface 345 * @slave: the interface enslaved in another master 346 * @master: the master from which slave has to be removed 347 * 348 * Invoke ndo_del_slave on master passing slave as argument. In this way slave 349 * is free'd and master can correctly change its internal state. 350 * Return 0 on success, a negative value representing the error otherwise 351 */ 352 static int batadv_master_del_slave(struct batadv_hard_iface *slave, 353 struct net_device *master) 354 { 355 int ret; 356 357 if (!master) 358 return 0; 359 360 ret = -EBUSY; 361 if (master->netdev_ops->ndo_del_slave) 362 ret = master->netdev_ops->ndo_del_slave(master, slave->net_dev); 363 364 return ret; 365 } 366 367 int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, 368 const char *iface_name) 369 { 370 struct batadv_priv *bat_priv; 371 struct net_device *soft_iface, *master; 372 __be16 ethertype = htons(ETH_P_BATMAN); 373 int max_header_len = batadv_max_header_len(); 374 int ret; 375 376 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 377 goto out; 378 379 if (!atomic_inc_not_zero(&hard_iface->refcount)) 380 goto out; 381 382 soft_iface = dev_get_by_name(&init_net, iface_name); 383 384 if (!soft_iface) { 385 soft_iface = batadv_softif_create(iface_name); 386 387 if (!soft_iface) { 388 ret = -ENOMEM; 389 goto err; 390 } 391 392 /* dev_get_by_name() increases the reference counter for us */ 393 dev_hold(soft_iface); 394 } 395 396 if (!batadv_softif_is_valid(soft_iface)) { 397 pr_err("Can't create batman mesh interface %s: already exists as regular interface\n", 398 soft_iface->name); 399 ret = -EINVAL; 400 goto err_dev; 401 } 402 403 /* check if the interface is enslaved in another virtual one and 404 * in that case unlink it first 405 */ 406 master = netdev_master_upper_dev_get(hard_iface->net_dev); 407 ret = batadv_master_del_slave(hard_iface, master); 408 if (ret) 409 goto err_dev; 410 411 hard_iface->soft_iface = soft_iface; 412 bat_priv = netdev_priv(hard_iface->soft_iface); 413 414 ret = netdev_master_upper_dev_link(hard_iface->net_dev, soft_iface); 415 if (ret) 416 goto err_dev; 417 418 ret = bat_priv->bat_algo_ops->bat_iface_enable(hard_iface); 419 if (ret < 0) 420 goto err_upper; 421 422 hard_iface->if_num = bat_priv->num_ifaces; 423 bat_priv->num_ifaces++; 424 hard_iface->if_status = BATADV_IF_INACTIVE; 425 ret = batadv_orig_hash_add_if(hard_iface, bat_priv->num_ifaces); 426 if (ret < 0) { 427 bat_priv->bat_algo_ops->bat_iface_disable(hard_iface); 428 bat_priv->num_ifaces--; 429 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 430 goto err_upper; 431 } 432 433 hard_iface->batman_adv_ptype.type = ethertype; 434 hard_iface->batman_adv_ptype.func = batadv_batman_skb_recv; 435 hard_iface->batman_adv_ptype.dev = hard_iface->net_dev; 436 dev_add_pack(&hard_iface->batman_adv_ptype); 437 438 batadv_info(hard_iface->soft_iface, "Adding interface: %s\n", 439 hard_iface->net_dev->name); 440 441 if (atomic_read(&bat_priv->fragmentation) && 442 hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len) 443 batadv_info(hard_iface->soft_iface, 444 "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", 445 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 446 ETH_DATA_LEN + max_header_len); 447 448 if (!atomic_read(&bat_priv->fragmentation) && 449 hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len) 450 batadv_info(hard_iface->soft_iface, 451 "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", 452 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 453 ETH_DATA_LEN + max_header_len); 454 455 if (batadv_hardif_is_iface_up(hard_iface)) 456 batadv_hardif_activate_interface(hard_iface); 457 else 458 batadv_err(hard_iface->soft_iface, 459 "Not using interface %s (retrying later): interface not active\n", 460 hard_iface->net_dev->name); 461 462 /* begin scheduling originator messages on that interface */ 463 batadv_schedule_bat_ogm(hard_iface); 464 465 out: 466 return 0; 467 468 err_upper: 469 netdev_upper_dev_unlink(hard_iface->net_dev, soft_iface); 470 err_dev: 471 hard_iface->soft_iface = NULL; 472 dev_put(soft_iface); 473 err: 474 batadv_hardif_free_ref(hard_iface); 475 return ret; 476 } 477 478 void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface, 479 enum batadv_hard_if_cleanup autodel) 480 { 481 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 482 struct batadv_hard_iface *primary_if = NULL; 483 484 if (hard_iface->if_status == BATADV_IF_ACTIVE) 485 batadv_hardif_deactivate_interface(hard_iface); 486 487 if (hard_iface->if_status != BATADV_IF_INACTIVE) 488 goto out; 489 490 batadv_info(hard_iface->soft_iface, "Removing interface: %s\n", 491 hard_iface->net_dev->name); 492 dev_remove_pack(&hard_iface->batman_adv_ptype); 493 494 bat_priv->num_ifaces--; 495 batadv_orig_hash_del_if(hard_iface, bat_priv->num_ifaces); 496 497 primary_if = batadv_primary_if_get_selected(bat_priv); 498 if (hard_iface == primary_if) { 499 struct batadv_hard_iface *new_if; 500 501 new_if = batadv_hardif_get_active(hard_iface->soft_iface); 502 batadv_primary_if_select(bat_priv, new_if); 503 504 if (new_if) 505 batadv_hardif_free_ref(new_if); 506 } 507 508 bat_priv->bat_algo_ops->bat_iface_disable(hard_iface); 509 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 510 511 /* delete all references to this hard_iface */ 512 batadv_purge_orig_ref(bat_priv); 513 batadv_purge_outstanding_packets(bat_priv, hard_iface); 514 dev_put(hard_iface->soft_iface); 515 516 /* nobody uses this interface anymore */ 517 if (!bat_priv->num_ifaces) { 518 batadv_gw_check_client_stop(bat_priv); 519 520 if (autodel == BATADV_IF_CLEANUP_AUTO) 521 batadv_softif_destroy_sysfs(hard_iface->soft_iface); 522 } 523 524 netdev_upper_dev_unlink(hard_iface->net_dev, hard_iface->soft_iface); 525 hard_iface->soft_iface = NULL; 526 batadv_hardif_free_ref(hard_iface); 527 528 out: 529 if (primary_if) 530 batadv_hardif_free_ref(primary_if); 531 } 532 533 /** 534 * batadv_hardif_remove_interface_finish - cleans up the remains of a hardif 535 * @work: work queue item 536 * 537 * Free the parts of the hard interface which can not be removed under 538 * rtnl lock (to prevent deadlock situations). 539 */ 540 static void batadv_hardif_remove_interface_finish(struct work_struct *work) 541 { 542 struct batadv_hard_iface *hard_iface; 543 544 hard_iface = container_of(work, struct batadv_hard_iface, 545 cleanup_work); 546 547 batadv_debugfs_del_hardif(hard_iface); 548 batadv_sysfs_del_hardif(&hard_iface->hardif_obj); 549 batadv_hardif_free_ref(hard_iface); 550 } 551 552 static struct batadv_hard_iface * 553 batadv_hardif_add_interface(struct net_device *net_dev) 554 { 555 struct batadv_hard_iface *hard_iface; 556 int ret; 557 558 ASSERT_RTNL(); 559 560 ret = batadv_is_valid_iface(net_dev); 561 if (ret != 1) 562 goto out; 563 564 dev_hold(net_dev); 565 566 hard_iface = kzalloc(sizeof(*hard_iface), GFP_ATOMIC); 567 if (!hard_iface) 568 goto release_dev; 569 570 ret = batadv_sysfs_add_hardif(&hard_iface->hardif_obj, net_dev); 571 if (ret) 572 goto free_if; 573 574 hard_iface->if_num = -1; 575 hard_iface->net_dev = net_dev; 576 hard_iface->soft_iface = NULL; 577 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 578 579 ret = batadv_debugfs_add_hardif(hard_iface); 580 if (ret) 581 goto free_sysfs; 582 583 INIT_LIST_HEAD(&hard_iface->list); 584 INIT_WORK(&hard_iface->cleanup_work, 585 batadv_hardif_remove_interface_finish); 586 587 hard_iface->num_bcasts = BATADV_NUM_BCASTS_DEFAULT; 588 if (batadv_is_wifi_netdev(net_dev)) 589 hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS; 590 591 /* extra reference for return */ 592 atomic_set(&hard_iface->refcount, 2); 593 594 batadv_check_known_mac_addr(hard_iface->net_dev); 595 list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list); 596 597 return hard_iface; 598 599 free_sysfs: 600 batadv_sysfs_del_hardif(&hard_iface->hardif_obj); 601 free_if: 602 kfree(hard_iface); 603 release_dev: 604 dev_put(net_dev); 605 out: 606 return NULL; 607 } 608 609 static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface) 610 { 611 ASSERT_RTNL(); 612 613 /* first deactivate interface */ 614 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 615 batadv_hardif_disable_interface(hard_iface, 616 BATADV_IF_CLEANUP_AUTO); 617 618 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 619 return; 620 621 hard_iface->if_status = BATADV_IF_TO_BE_REMOVED; 622 queue_work(batadv_event_workqueue, &hard_iface->cleanup_work); 623 } 624 625 void batadv_hardif_remove_interfaces(void) 626 { 627 struct batadv_hard_iface *hard_iface, *hard_iface_tmp; 628 629 rtnl_lock(); 630 list_for_each_entry_safe(hard_iface, hard_iface_tmp, 631 &batadv_hardif_list, list) { 632 list_del_rcu(&hard_iface->list); 633 batadv_hardif_remove_interface(hard_iface); 634 } 635 rtnl_unlock(); 636 } 637 638 static int batadv_hard_if_event(struct notifier_block *this, 639 unsigned long event, void *ptr) 640 { 641 struct net_device *net_dev = netdev_notifier_info_to_dev(ptr); 642 struct batadv_hard_iface *hard_iface; 643 struct batadv_hard_iface *primary_if = NULL; 644 struct batadv_priv *bat_priv; 645 646 if (batadv_softif_is_valid(net_dev) && event == NETDEV_REGISTER) { 647 batadv_sysfs_add_meshif(net_dev); 648 bat_priv = netdev_priv(net_dev); 649 batadv_softif_create_vlan(bat_priv, BATADV_NO_FLAGS); 650 return NOTIFY_DONE; 651 } 652 653 hard_iface = batadv_hardif_get_by_netdev(net_dev); 654 if (!hard_iface && event == NETDEV_REGISTER) 655 hard_iface = batadv_hardif_add_interface(net_dev); 656 657 if (!hard_iface) 658 goto out; 659 660 switch (event) { 661 case NETDEV_UP: 662 batadv_hardif_activate_interface(hard_iface); 663 break; 664 case NETDEV_GOING_DOWN: 665 case NETDEV_DOWN: 666 batadv_hardif_deactivate_interface(hard_iface); 667 break; 668 case NETDEV_UNREGISTER: 669 list_del_rcu(&hard_iface->list); 670 671 batadv_hardif_remove_interface(hard_iface); 672 break; 673 case NETDEV_CHANGEMTU: 674 if (hard_iface->soft_iface) 675 batadv_update_min_mtu(hard_iface->soft_iface); 676 break; 677 case NETDEV_CHANGEADDR: 678 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) 679 goto hardif_put; 680 681 batadv_check_known_mac_addr(hard_iface->net_dev); 682 683 bat_priv = netdev_priv(hard_iface->soft_iface); 684 bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface); 685 686 primary_if = batadv_primary_if_get_selected(bat_priv); 687 if (!primary_if) 688 goto hardif_put; 689 690 if (hard_iface == primary_if) 691 batadv_primary_if_update_addr(bat_priv, NULL); 692 break; 693 default: 694 break; 695 } 696 697 hardif_put: 698 batadv_hardif_free_ref(hard_iface); 699 out: 700 if (primary_if) 701 batadv_hardif_free_ref(primary_if); 702 return NOTIFY_DONE; 703 } 704 705 struct notifier_block batadv_hard_if_notifier = { 706 .notifier_call = batadv_hard_if_event, 707 }; 708