1 /* Copyright (C) 2007-2013 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, write to the Free Software 16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 17 * 02110-1301, USA 18 */ 19 20 #include "main.h" 21 #include "distributed-arp-table.h" 22 #include "hard-interface.h" 23 #include "soft-interface.h" 24 #include "send.h" 25 #include "translation-table.h" 26 #include "routing.h" 27 #include "sysfs.h" 28 #include "originator.h" 29 #include "hash.h" 30 #include "bridge_loop_avoidance.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 if (parent_dev) 98 dev_put(parent_dev); 99 return ret; 100 } 101 102 static int batadv_is_valid_iface(const struct net_device *net_dev) 103 { 104 if (net_dev->flags & IFF_LOOPBACK) 105 return 0; 106 107 if (net_dev->type != ARPHRD_ETHER) 108 return 0; 109 110 if (net_dev->addr_len != ETH_ALEN) 111 return 0; 112 113 /* no batman over batman */ 114 if (batadv_is_on_batman_iface(net_dev)) 115 return 0; 116 117 return 1; 118 } 119 120 static struct batadv_hard_iface * 121 batadv_hardif_get_active(const struct net_device *soft_iface) 122 { 123 struct batadv_hard_iface *hard_iface; 124 125 rcu_read_lock(); 126 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 127 if (hard_iface->soft_iface != soft_iface) 128 continue; 129 130 if (hard_iface->if_status == BATADV_IF_ACTIVE && 131 atomic_inc_not_zero(&hard_iface->refcount)) 132 goto out; 133 } 134 135 hard_iface = NULL; 136 137 out: 138 rcu_read_unlock(); 139 return hard_iface; 140 } 141 142 static void batadv_primary_if_update_addr(struct batadv_priv *bat_priv, 143 struct batadv_hard_iface *oldif) 144 { 145 struct batadv_vis_packet *vis_packet; 146 struct batadv_hard_iface *primary_if; 147 struct sk_buff *skb; 148 149 primary_if = batadv_primary_if_get_selected(bat_priv); 150 if (!primary_if) 151 goto out; 152 153 batadv_dat_init_own_addr(bat_priv, primary_if); 154 155 skb = bat_priv->vis.my_info->skb_packet; 156 vis_packet = (struct batadv_vis_packet *)skb->data; 157 memcpy(vis_packet->vis_orig, primary_if->net_dev->dev_addr, ETH_ALEN); 158 memcpy(vis_packet->sender_orig, 159 primary_if->net_dev->dev_addr, ETH_ALEN); 160 161 batadv_bla_update_orig_address(bat_priv, primary_if, oldif); 162 out: 163 if (primary_if) 164 batadv_hardif_free_ref(primary_if); 165 } 166 167 static void batadv_primary_if_select(struct batadv_priv *bat_priv, 168 struct batadv_hard_iface *new_hard_iface) 169 { 170 struct batadv_hard_iface *curr_hard_iface; 171 172 ASSERT_RTNL(); 173 174 if (new_hard_iface && !atomic_inc_not_zero(&new_hard_iface->refcount)) 175 new_hard_iface = NULL; 176 177 curr_hard_iface = rcu_dereference_protected(bat_priv->primary_if, 1); 178 rcu_assign_pointer(bat_priv->primary_if, new_hard_iface); 179 180 if (!new_hard_iface) 181 goto out; 182 183 bat_priv->bat_algo_ops->bat_primary_iface_set(new_hard_iface); 184 batadv_primary_if_update_addr(bat_priv, curr_hard_iface); 185 186 out: 187 if (curr_hard_iface) 188 batadv_hardif_free_ref(curr_hard_iface); 189 } 190 191 static bool 192 batadv_hardif_is_iface_up(const struct batadv_hard_iface *hard_iface) 193 { 194 if (hard_iface->net_dev->flags & IFF_UP) 195 return true; 196 197 return false; 198 } 199 200 static void batadv_check_known_mac_addr(const struct net_device *net_dev) 201 { 202 const struct batadv_hard_iface *hard_iface; 203 204 rcu_read_lock(); 205 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 206 if ((hard_iface->if_status != BATADV_IF_ACTIVE) && 207 (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) 208 continue; 209 210 if (hard_iface->net_dev == net_dev) 211 continue; 212 213 if (!batadv_compare_eth(hard_iface->net_dev->dev_addr, 214 net_dev->dev_addr)) 215 continue; 216 217 pr_warn("The newly added mac address (%pM) already exists on: %s\n", 218 net_dev->dev_addr, hard_iface->net_dev->name); 219 pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n"); 220 } 221 rcu_read_unlock(); 222 } 223 224 int batadv_hardif_min_mtu(struct net_device *soft_iface) 225 { 226 const struct batadv_priv *bat_priv = netdev_priv(soft_iface); 227 const struct batadv_hard_iface *hard_iface; 228 /* allow big frames if all devices are capable to do so 229 * (have MTU > 1500 + BAT_HEADER_LEN) 230 */ 231 int min_mtu = ETH_DATA_LEN; 232 233 if (atomic_read(&bat_priv->fragmentation)) 234 goto out; 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->soft_iface != soft_iface) 243 continue; 244 245 min_mtu = min_t(int, 246 hard_iface->net_dev->mtu - BATADV_HEADER_LEN, 247 min_mtu); 248 } 249 rcu_read_unlock(); 250 out: 251 return min_mtu; 252 } 253 254 /* adjusts the MTU if a new interface with a smaller MTU appeared. */ 255 void batadv_update_min_mtu(struct net_device *soft_iface) 256 { 257 int min_mtu; 258 259 min_mtu = batadv_hardif_min_mtu(soft_iface); 260 if (soft_iface->mtu != min_mtu) 261 soft_iface->mtu = min_mtu; 262 } 263 264 static void 265 batadv_hardif_activate_interface(struct batadv_hard_iface *hard_iface) 266 { 267 struct batadv_priv *bat_priv; 268 struct batadv_hard_iface *primary_if = NULL; 269 270 if (hard_iface->if_status != BATADV_IF_INACTIVE) 271 goto out; 272 273 bat_priv = netdev_priv(hard_iface->soft_iface); 274 275 bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface); 276 hard_iface->if_status = BATADV_IF_TO_BE_ACTIVATED; 277 278 /* the first active interface becomes our primary interface or 279 * the next active interface after the old primary interface was removed 280 */ 281 primary_if = batadv_primary_if_get_selected(bat_priv); 282 if (!primary_if) 283 batadv_primary_if_select(bat_priv, hard_iface); 284 285 batadv_info(hard_iface->soft_iface, "Interface activated: %s\n", 286 hard_iface->net_dev->name); 287 288 batadv_update_min_mtu(hard_iface->soft_iface); 289 290 out: 291 if (primary_if) 292 batadv_hardif_free_ref(primary_if); 293 } 294 295 static void 296 batadv_hardif_deactivate_interface(struct batadv_hard_iface *hard_iface) 297 { 298 if ((hard_iface->if_status != BATADV_IF_ACTIVE) && 299 (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) 300 return; 301 302 hard_iface->if_status = BATADV_IF_INACTIVE; 303 304 batadv_info(hard_iface->soft_iface, "Interface deactivated: %s\n", 305 hard_iface->net_dev->name); 306 307 batadv_update_min_mtu(hard_iface->soft_iface); 308 } 309 310 /** 311 * batadv_master_del_slave - remove hard_iface from the current master interface 312 * @slave: the interface enslaved in another master 313 * @master: the master from which slave has to be removed 314 * 315 * Invoke ndo_del_slave on master passing slave as argument. In this way slave 316 * is free'd and master can correctly change its internal state. 317 * Return 0 on success, a negative value representing the error otherwise 318 */ 319 static int batadv_master_del_slave(struct batadv_hard_iface *slave, 320 struct net_device *master) 321 { 322 int ret; 323 324 if (!master) 325 return 0; 326 327 ret = -EBUSY; 328 if (master->netdev_ops->ndo_del_slave) 329 ret = master->netdev_ops->ndo_del_slave(master, slave->net_dev); 330 331 return ret; 332 } 333 334 int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, 335 const char *iface_name) 336 { 337 struct batadv_priv *bat_priv; 338 struct net_device *soft_iface, *master; 339 __be16 ethertype = __constant_htons(ETH_P_BATMAN); 340 int ret; 341 342 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 343 goto out; 344 345 if (!atomic_inc_not_zero(&hard_iface->refcount)) 346 goto out; 347 348 soft_iface = dev_get_by_name(&init_net, iface_name); 349 350 if (!soft_iface) { 351 soft_iface = batadv_softif_create(iface_name); 352 353 if (!soft_iface) { 354 ret = -ENOMEM; 355 goto err; 356 } 357 358 /* dev_get_by_name() increases the reference counter for us */ 359 dev_hold(soft_iface); 360 } 361 362 if (!batadv_softif_is_valid(soft_iface)) { 363 pr_err("Can't create batman mesh interface %s: already exists as regular interface\n", 364 soft_iface->name); 365 ret = -EINVAL; 366 goto err_dev; 367 } 368 369 /* check if the interface is enslaved in another virtual one and 370 * in that case unlink it first 371 */ 372 master = netdev_master_upper_dev_get(hard_iface->net_dev); 373 ret = batadv_master_del_slave(hard_iface, master); 374 if (ret) 375 goto err_dev; 376 377 hard_iface->soft_iface = soft_iface; 378 bat_priv = netdev_priv(hard_iface->soft_iface); 379 380 ret = netdev_master_upper_dev_link(hard_iface->net_dev, soft_iface); 381 if (ret) 382 goto err_dev; 383 384 ret = bat_priv->bat_algo_ops->bat_iface_enable(hard_iface); 385 if (ret < 0) 386 goto err_upper; 387 388 hard_iface->if_num = bat_priv->num_ifaces; 389 bat_priv->num_ifaces++; 390 hard_iface->if_status = BATADV_IF_INACTIVE; 391 ret = batadv_orig_hash_add_if(hard_iface, bat_priv->num_ifaces); 392 if (ret < 0) { 393 bat_priv->bat_algo_ops->bat_iface_disable(hard_iface); 394 bat_priv->num_ifaces--; 395 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 396 goto err_upper; 397 } 398 399 hard_iface->batman_adv_ptype.type = ethertype; 400 hard_iface->batman_adv_ptype.func = batadv_batman_skb_recv; 401 hard_iface->batman_adv_ptype.dev = hard_iface->net_dev; 402 dev_add_pack(&hard_iface->batman_adv_ptype); 403 404 atomic_set(&hard_iface->frag_seqno, 1); 405 batadv_info(hard_iface->soft_iface, "Adding interface: %s\n", 406 hard_iface->net_dev->name); 407 408 if (atomic_read(&bat_priv->fragmentation) && 409 hard_iface->net_dev->mtu < ETH_DATA_LEN + BATADV_HEADER_LEN) 410 batadv_info(hard_iface->soft_iface, 411 "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 %zi would solve the problem.\n", 412 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 413 ETH_DATA_LEN + BATADV_HEADER_LEN); 414 415 if (!atomic_read(&bat_priv->fragmentation) && 416 hard_iface->net_dev->mtu < ETH_DATA_LEN + BATADV_HEADER_LEN) 417 batadv_info(hard_iface->soft_iface, 418 "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 %zi.\n", 419 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 420 ETH_DATA_LEN + BATADV_HEADER_LEN); 421 422 if (batadv_hardif_is_iface_up(hard_iface)) 423 batadv_hardif_activate_interface(hard_iface); 424 else 425 batadv_err(hard_iface->soft_iface, 426 "Not using interface %s (retrying later): interface not active\n", 427 hard_iface->net_dev->name); 428 429 /* begin scheduling originator messages on that interface */ 430 batadv_schedule_bat_ogm(hard_iface); 431 432 out: 433 return 0; 434 435 err_upper: 436 netdev_upper_dev_unlink(hard_iface->net_dev, soft_iface); 437 err_dev: 438 hard_iface->soft_iface = NULL; 439 dev_put(soft_iface); 440 err: 441 batadv_hardif_free_ref(hard_iface); 442 return ret; 443 } 444 445 void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface, 446 enum batadv_hard_if_cleanup autodel) 447 { 448 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 449 struct batadv_hard_iface *primary_if = NULL; 450 451 if (hard_iface->if_status == BATADV_IF_ACTIVE) 452 batadv_hardif_deactivate_interface(hard_iface); 453 454 if (hard_iface->if_status != BATADV_IF_INACTIVE) 455 goto out; 456 457 batadv_info(hard_iface->soft_iface, "Removing interface: %s\n", 458 hard_iface->net_dev->name); 459 dev_remove_pack(&hard_iface->batman_adv_ptype); 460 461 bat_priv->num_ifaces--; 462 batadv_orig_hash_del_if(hard_iface, bat_priv->num_ifaces); 463 464 primary_if = batadv_primary_if_get_selected(bat_priv); 465 if (hard_iface == primary_if) { 466 struct batadv_hard_iface *new_if; 467 468 new_if = batadv_hardif_get_active(hard_iface->soft_iface); 469 batadv_primary_if_select(bat_priv, new_if); 470 471 if (new_if) 472 batadv_hardif_free_ref(new_if); 473 } 474 475 bat_priv->bat_algo_ops->bat_iface_disable(hard_iface); 476 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 477 478 /* delete all references to this hard_iface */ 479 batadv_purge_orig_ref(bat_priv); 480 batadv_purge_outstanding_packets(bat_priv, hard_iface); 481 dev_put(hard_iface->soft_iface); 482 483 /* nobody uses this interface anymore */ 484 if (!bat_priv->num_ifaces && autodel == BATADV_IF_CLEANUP_AUTO) 485 batadv_softif_destroy_sysfs(hard_iface->soft_iface); 486 487 netdev_upper_dev_unlink(hard_iface->net_dev, hard_iface->soft_iface); 488 hard_iface->soft_iface = NULL; 489 batadv_hardif_free_ref(hard_iface); 490 491 out: 492 if (primary_if) 493 batadv_hardif_free_ref(primary_if); 494 } 495 496 /** 497 * batadv_hardif_remove_interface_finish - cleans up the remains of a hardif 498 * @work: work queue item 499 * 500 * Free the parts of the hard interface which can not be removed under 501 * rtnl lock (to prevent deadlock situations). 502 */ 503 static void batadv_hardif_remove_interface_finish(struct work_struct *work) 504 { 505 struct batadv_hard_iface *hard_iface; 506 507 hard_iface = container_of(work, struct batadv_hard_iface, 508 cleanup_work); 509 510 batadv_sysfs_del_hardif(&hard_iface->hardif_obj); 511 batadv_hardif_free_ref(hard_iface); 512 } 513 514 static struct batadv_hard_iface * 515 batadv_hardif_add_interface(struct net_device *net_dev) 516 { 517 struct batadv_hard_iface *hard_iface; 518 int ret; 519 520 ASSERT_RTNL(); 521 522 ret = batadv_is_valid_iface(net_dev); 523 if (ret != 1) 524 goto out; 525 526 dev_hold(net_dev); 527 528 hard_iface = kmalloc(sizeof(*hard_iface), GFP_ATOMIC); 529 if (!hard_iface) 530 goto release_dev; 531 532 ret = batadv_sysfs_add_hardif(&hard_iface->hardif_obj, net_dev); 533 if (ret) 534 goto free_if; 535 536 hard_iface->if_num = -1; 537 hard_iface->net_dev = net_dev; 538 hard_iface->soft_iface = NULL; 539 hard_iface->if_status = BATADV_IF_NOT_IN_USE; 540 INIT_LIST_HEAD(&hard_iface->list); 541 INIT_WORK(&hard_iface->cleanup_work, 542 batadv_hardif_remove_interface_finish); 543 544 /* extra reference for return */ 545 atomic_set(&hard_iface->refcount, 2); 546 547 batadv_check_known_mac_addr(hard_iface->net_dev); 548 list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list); 549 550 /* This can't be called via a bat_priv callback because 551 * we have no bat_priv yet. 552 */ 553 atomic_set(&hard_iface->bat_iv.ogm_seqno, 1); 554 hard_iface->bat_iv.ogm_buff = NULL; 555 556 return hard_iface; 557 558 free_if: 559 kfree(hard_iface); 560 release_dev: 561 dev_put(net_dev); 562 out: 563 return NULL; 564 } 565 566 static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface) 567 { 568 ASSERT_RTNL(); 569 570 /* first deactivate interface */ 571 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 572 batadv_hardif_disable_interface(hard_iface, 573 BATADV_IF_CLEANUP_AUTO); 574 575 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) 576 return; 577 578 hard_iface->if_status = BATADV_IF_TO_BE_REMOVED; 579 queue_work(batadv_event_workqueue, &hard_iface->cleanup_work); 580 } 581 582 void batadv_hardif_remove_interfaces(void) 583 { 584 struct batadv_hard_iface *hard_iface, *hard_iface_tmp; 585 586 rtnl_lock(); 587 list_for_each_entry_safe(hard_iface, hard_iface_tmp, 588 &batadv_hardif_list, list) { 589 list_del_rcu(&hard_iface->list); 590 batadv_hardif_remove_interface(hard_iface); 591 } 592 rtnl_unlock(); 593 } 594 595 static int batadv_hard_if_event(struct notifier_block *this, 596 unsigned long event, void *ptr) 597 { 598 struct net_device *net_dev = ptr; 599 struct batadv_hard_iface *hard_iface; 600 struct batadv_hard_iface *primary_if = NULL; 601 struct batadv_priv *bat_priv; 602 603 if (batadv_softif_is_valid(net_dev) && event == NETDEV_REGISTER) { 604 batadv_sysfs_add_meshif(net_dev); 605 return NOTIFY_DONE; 606 } 607 608 hard_iface = batadv_hardif_get_by_netdev(net_dev); 609 if (!hard_iface && event == NETDEV_REGISTER) 610 hard_iface = batadv_hardif_add_interface(net_dev); 611 612 if (!hard_iface) 613 goto out; 614 615 switch (event) { 616 case NETDEV_UP: 617 batadv_hardif_activate_interface(hard_iface); 618 break; 619 case NETDEV_GOING_DOWN: 620 case NETDEV_DOWN: 621 batadv_hardif_deactivate_interface(hard_iface); 622 break; 623 case NETDEV_UNREGISTER: 624 list_del_rcu(&hard_iface->list); 625 626 batadv_hardif_remove_interface(hard_iface); 627 break; 628 case NETDEV_CHANGEMTU: 629 if (hard_iface->soft_iface) 630 batadv_update_min_mtu(hard_iface->soft_iface); 631 break; 632 case NETDEV_CHANGEADDR: 633 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) 634 goto hardif_put; 635 636 batadv_check_known_mac_addr(hard_iface->net_dev); 637 638 bat_priv = netdev_priv(hard_iface->soft_iface); 639 bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface); 640 641 primary_if = batadv_primary_if_get_selected(bat_priv); 642 if (!primary_if) 643 goto hardif_put; 644 645 if (hard_iface == primary_if) 646 batadv_primary_if_update_addr(bat_priv, NULL); 647 break; 648 default: 649 break; 650 } 651 652 hardif_put: 653 batadv_hardif_free_ref(hard_iface); 654 out: 655 if (primary_if) 656 batadv_hardif_free_ref(primary_if); 657 return NOTIFY_DONE; 658 } 659 660 /* This function returns true if the interface represented by ifindex is a 661 * 802.11 wireless device 662 */ 663 bool batadv_is_wifi_iface(int ifindex) 664 { 665 struct net_device *net_device = NULL; 666 bool ret = false; 667 668 if (ifindex == BATADV_NULL_IFINDEX) 669 goto out; 670 671 net_device = dev_get_by_index(&init_net, ifindex); 672 if (!net_device) 673 goto out; 674 675 #ifdef CONFIG_WIRELESS_EXT 676 /* pre-cfg80211 drivers have to implement WEXT, so it is possible to 677 * check for wireless_handlers != NULL 678 */ 679 if (net_device->wireless_handlers) 680 ret = true; 681 else 682 #endif 683 /* cfg80211 drivers have to set ieee80211_ptr */ 684 if (net_device->ieee80211_ptr) 685 ret = true; 686 out: 687 if (net_device) 688 dev_put(net_device); 689 return ret; 690 } 691 692 struct notifier_block batadv_hard_if_notifier = { 693 .notifier_call = batadv_hard_if_event, 694 }; 695