net/batman-adv/hard-interface.c

   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 };