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