net/batman-adv/hard-interface.c

   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/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  * Return: 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  * Return: 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  *
 405  * Return: 0 on success, a negative value representing the error otherwise
 406  */
 407 static int batadv_master_del_slave(struct batadv_hard_iface *slave,
 408                                    struct net_device *master)
 409 {
 410         int ret;
 411
 412         if (!master)
 413                 return 0;
 414
 415         ret = -EBUSY;
 416         if (master->netdev_ops->ndo_del_slave)
 417                 ret = master->netdev_ops->ndo_del_slave(master, slave->net_dev);
 418
 419         return ret;
 420 }
 421
 422 int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface,
 423                                    const char *iface_name)
 424 {
 425         struct batadv_priv *bat_priv;
 426         struct net_device *soft_iface, *master;
 427         __be16 ethertype = htons(ETH_P_BATMAN);
 428         int max_header_len = batadv_max_header_len();
 429         int ret;
 430
 431         if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
 432                 goto out;
 433
 434         if (!atomic_inc_not_zero(&hard_iface->refcount))
 435                 goto out;
 436
 437         soft_iface = dev_get_by_name(&init_net, iface_name);
 438
 439         if (!soft_iface) {
 440                 soft_iface = batadv_softif_create(iface_name);
 441
 442                 if (!soft_iface) {
 443                         ret = -ENOMEM;
 444                         goto err;
 445                 }
 446
 447                 /* dev_get_by_name() increases the reference counter for us */
 448                 dev_hold(soft_iface);
 449         }
 450
 451         if (!batadv_softif_is_valid(soft_iface)) {
 452                 pr_err("Can't create batman mesh interface %s: already exists as regular interface\n",
 453                        soft_iface->name);
 454                 ret = -EINVAL;
 455                 goto err_dev;
 456         }
 457
 458         /* check if the interface is enslaved in another virtual one and
 459          * in that case unlink it first
 460          */
 461         master = netdev_master_upper_dev_get(hard_iface->net_dev);
 462         ret = batadv_master_del_slave(hard_iface, master);
 463         if (ret)
 464                 goto err_dev;
 465
 466         hard_iface->soft_iface = soft_iface;
 467         bat_priv = netdev_priv(hard_iface->soft_iface);
 468
 469         ret = netdev_master_upper_dev_link(hard_iface->net_dev,
 470                                            soft_iface, NULL, NULL);
 471         if (ret)
 472                 goto err_dev;
 473
 474         ret = bat_priv->bat_algo_ops->bat_iface_enable(hard_iface);
 475         if (ret < 0)
 476                 goto err_upper;
 477
 478         hard_iface->if_num = bat_priv->num_ifaces;
 479         bat_priv->num_ifaces++;
 480         hard_iface->if_status = BATADV_IF_INACTIVE;
 481         ret = batadv_orig_hash_add_if(hard_iface, bat_priv->num_ifaces);
 482         if (ret < 0) {
 483                 bat_priv->bat_algo_ops->bat_iface_disable(hard_iface);
 484                 bat_priv->num_ifaces--;
 485                 hard_iface->if_status = BATADV_IF_NOT_IN_USE;
 486                 goto err_upper;
 487         }
 488
 489         hard_iface->batman_adv_ptype.type = ethertype;
 490         hard_iface->batman_adv_ptype.func = batadv_batman_skb_recv;
 491         hard_iface->batman_adv_ptype.dev = hard_iface->net_dev;
 492         dev_add_pack(&hard_iface->batman_adv_ptype);
 493
 494         batadv_info(hard_iface->soft_iface, "Adding interface: %s\n",
 495                     hard_iface->net_dev->name);
 496
 497         if (atomic_read(&bat_priv->fragmentation) &&
 498             hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len)
 499                 batadv_info(hard_iface->soft_iface,
 500                             "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",
 501                             hard_iface->net_dev->name, hard_iface->net_dev->mtu,
 502                             ETH_DATA_LEN + max_header_len);
 503
 504         if (!atomic_read(&bat_priv->fragmentation) &&
 505             hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len)
 506                 batadv_info(hard_iface->soft_iface,
 507                             "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",
 508                             hard_iface->net_dev->name, hard_iface->net_dev->mtu,
 509                             ETH_DATA_LEN + max_header_len);
 510
 511         if (batadv_hardif_is_iface_up(hard_iface))
 512                 batadv_hardif_activate_interface(hard_iface);
 513         else
 514                 batadv_err(hard_iface->soft_iface,
 515                            "Not using interface %s (retrying later): interface not active\n",
 516                            hard_iface->net_dev->name);
 517
 518         batadv_hardif_recalc_extra_skbroom(soft_iface);
 519
 520         /* begin scheduling originator messages on that interface */
 521         batadv_schedule_bat_ogm(hard_iface);
 522
 523 out:
 524         return 0;
 525
 526 err_upper:
 527         netdev_upper_dev_unlink(hard_iface->net_dev, soft_iface);
 528 err_dev:
 529         hard_iface->soft_iface = NULL;
 530         dev_put(soft_iface);
 531 err:
 532         batadv_hardif_free_ref(hard_iface);
 533         return ret;
 534 }
 535
 536 void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface,
 537                                      enum batadv_hard_if_cleanup autodel)
 538 {
 539         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 540         struct batadv_hard_iface *primary_if = NULL;
 541
 542         if (hard_iface->if_status == BATADV_IF_ACTIVE)
 543                 batadv_hardif_deactivate_interface(hard_iface);
 544
 545         if (hard_iface->if_status != BATADV_IF_INACTIVE)
 546                 goto out;
 547
 548         batadv_info(hard_iface->soft_iface, "Removing interface: %s\n",
 549                     hard_iface->net_dev->name);
 550         dev_remove_pack(&hard_iface->batman_adv_ptype);
 551
 552         bat_priv->num_ifaces--;
 553         batadv_orig_hash_del_if(hard_iface, bat_priv->num_ifaces);
 554
 555         primary_if = batadv_primary_if_get_selected(bat_priv);
 556         if (hard_iface == primary_if) {
 557                 struct batadv_hard_iface *new_if;
 558
 559                 new_if = batadv_hardif_get_active(hard_iface->soft_iface);
 560                 batadv_primary_if_select(bat_priv, new_if);
 561
 562                 if (new_if)
 563                         batadv_hardif_free_ref(new_if);
 564         }
 565
 566         bat_priv->bat_algo_ops->bat_iface_disable(hard_iface);
 567         hard_iface->if_status = BATADV_IF_NOT_IN_USE;
 568
 569         /* delete all references to this hard_iface */
 570         batadv_purge_orig_ref(bat_priv);
 571         batadv_purge_outstanding_packets(bat_priv, hard_iface);
 572         dev_put(hard_iface->soft_iface);
 573
 574         netdev_upper_dev_unlink(hard_iface->net_dev, hard_iface->soft_iface);
 575         batadv_hardif_recalc_extra_skbroom(hard_iface->soft_iface);
 576
 577         /* nobody uses this interface anymore */
 578         if (!bat_priv->num_ifaces) {
 579                 batadv_gw_check_client_stop(bat_priv);
 580
 581                 if (autodel == BATADV_IF_CLEANUP_AUTO)
 582                         batadv_softif_destroy_sysfs(hard_iface->soft_iface);
 583         }
 584
 585         hard_iface->soft_iface = NULL;
 586         batadv_hardif_free_ref(hard_iface);
 587
 588 out:
 589         if (primary_if)
 590                 batadv_hardif_free_ref(primary_if);
 591 }
 592
 593 /**
 594  * batadv_hardif_remove_interface_finish - cleans up the remains of a hardif
 595  * @work: work queue item
 596  *
 597  * Free the parts of the hard interface which can not be removed under
 598  * rtnl lock (to prevent deadlock situations).
 599  */
 600 static void batadv_hardif_remove_interface_finish(struct work_struct *work)
 601 {
 602         struct batadv_hard_iface *hard_iface;
 603
 604         hard_iface = container_of(work, struct batadv_hard_iface,
 605                                   cleanup_work);
 606
 607         batadv_debugfs_del_hardif(hard_iface);
 608         batadv_sysfs_del_hardif(&hard_iface->hardif_obj);
 609         batadv_hardif_free_ref(hard_iface);
 610 }
 611
 612 static struct batadv_hard_iface *
 613 batadv_hardif_add_interface(struct net_device *net_dev)
 614 {
 615         struct batadv_hard_iface *hard_iface;
 616         int ret;
 617
 618         ASSERT_RTNL();
 619
 620         ret = batadv_is_valid_iface(net_dev);
 621         if (ret != 1)
 622                 goto out;
 623
 624         dev_hold(net_dev);
 625
 626         hard_iface = kzalloc(sizeof(*hard_iface), GFP_ATOMIC);
 627         if (!hard_iface)
 628                 goto release_dev;
 629
 630         ret = batadv_sysfs_add_hardif(&hard_iface->hardif_obj, net_dev);
 631         if (ret)
 632                 goto free_if;
 633
 634         hard_iface->if_num = -1;
 635         hard_iface->net_dev = net_dev;
 636         hard_iface->soft_iface = NULL;
 637         hard_iface->if_status = BATADV_IF_NOT_IN_USE;
 638
 639         ret = batadv_debugfs_add_hardif(hard_iface);
 640         if (ret)
 641                 goto free_sysfs;
 642
 643         INIT_LIST_HEAD(&hard_iface->list);
 644         INIT_HLIST_HEAD(&hard_iface->neigh_list);
 645         INIT_WORK(&hard_iface->cleanup_work,
 646                   batadv_hardif_remove_interface_finish);
 647
 648         spin_lock_init(&hard_iface->neigh_list_lock);
 649
 650         hard_iface->num_bcasts = BATADV_NUM_BCASTS_DEFAULT;
 651         if (batadv_is_wifi_netdev(net_dev))
 652                 hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS;
 653
 654         /* extra reference for return */
 655         atomic_set(&hard_iface->refcount, 2);
 656
 657         batadv_check_known_mac_addr(hard_iface->net_dev);
 658         list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list);
 659
 660         return hard_iface;
 661
 662 free_sysfs:
 663         batadv_sysfs_del_hardif(&hard_iface->hardif_obj);
 664 free_if:
 665         kfree(hard_iface);
 666 release_dev:
 667         dev_put(net_dev);
 668 out:
 669         return NULL;
 670 }
 671
 672 static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface)
 673 {
 674         ASSERT_RTNL();
 675
 676         /* first deactivate interface */
 677         if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
 678                 batadv_hardif_disable_interface(hard_iface,
 679                                                 BATADV_IF_CLEANUP_AUTO);
 680
 681         if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
 682                 return;
 683
 684         hard_iface->if_status = BATADV_IF_TO_BE_REMOVED;
 685         queue_work(batadv_event_workqueue, &hard_iface->cleanup_work);
 686 }
 687
 688 void batadv_hardif_remove_interfaces(void)
 689 {
 690         struct batadv_hard_iface *hard_iface, *hard_iface_tmp;
 691
 692         rtnl_lock();
 693         list_for_each_entry_safe(hard_iface, hard_iface_tmp,
 694                                  &batadv_hardif_list, list) {
 695                 list_del_rcu(&hard_iface->list);
 696                 batadv_hardif_remove_interface(hard_iface);
 697         }
 698         rtnl_unlock();
 699 }
 700
 701 static int batadv_hard_if_event(struct notifier_block *this,
 702                                 unsigned long event, void *ptr)
 703 {
 704         struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
 705         struct batadv_hard_iface *hard_iface;
 706         struct batadv_hard_iface *primary_if = NULL;
 707         struct batadv_priv *bat_priv;
 708
 709         if (batadv_softif_is_valid(net_dev) && event == NETDEV_REGISTER) {
 710                 batadv_sysfs_add_meshif(net_dev);
 711                 bat_priv = netdev_priv(net_dev);
 712                 batadv_softif_create_vlan(bat_priv, BATADV_NO_FLAGS);
 713                 return NOTIFY_DONE;
 714         }
 715
 716         hard_iface = batadv_hardif_get_by_netdev(net_dev);
 717         if (!hard_iface && (event == NETDEV_REGISTER ||
 718                             event == NETDEV_POST_TYPE_CHANGE))
 719                 hard_iface = batadv_hardif_add_interface(net_dev);
 720
 721         if (!hard_iface)
 722                 goto out;
 723
 724         switch (event) {
 725         case NETDEV_UP:
 726                 batadv_hardif_activate_interface(hard_iface);
 727                 break;
 728         case NETDEV_GOING_DOWN:
 729         case NETDEV_DOWN:
 730                 batadv_hardif_deactivate_interface(hard_iface);
 731                 break;
 732         case NETDEV_UNREGISTER:
 733         case NETDEV_PRE_TYPE_CHANGE:
 734                 list_del_rcu(&hard_iface->list);
 735
 736                 batadv_hardif_remove_interface(hard_iface);
 737                 break;
 738         case NETDEV_CHANGEMTU:
 739                 if (hard_iface->soft_iface)
 740                         batadv_update_min_mtu(hard_iface->soft_iface);
 741                 break;
 742         case NETDEV_CHANGEADDR:
 743                 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
 744                         goto hardif_put;
 745
 746                 batadv_check_known_mac_addr(hard_iface->net_dev);
 747
 748                 bat_priv = netdev_priv(hard_iface->soft_iface);
 749                 bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface);
 750
 751                 primary_if = batadv_primary_if_get_selected(bat_priv);
 752                 if (!primary_if)
 753                         goto hardif_put;
 754
 755                 if (hard_iface == primary_if)
 756                         batadv_primary_if_update_addr(bat_priv, NULL);
 757                 break;
 758         default:
 759                 break;
 760         }
 761
 762 hardif_put:
 763         batadv_hardif_free_ref(hard_iface);
 764 out:
 765         if (primary_if)
 766                 batadv_hardif_free_ref(primary_if);
 767         return NOTIFY_DONE;
 768 }
 769
 770 struct notifier_block batadv_hard_if_notifier = {
 771         .notifier_call = batadv_hard_if_event,
 772 };