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