net/batman-adv/hard-interface.c

   1 /*
   2  * Copyright (C) 2007-2010 B.A.T.M.A.N. contributors:
   3  *
   4  * Marek Lindner, Simon Wunderlich
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of version 2 of the GNU General Public
   8  * License as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  * 02110-1301, USA
  19  *
  20  */
  21
  22 #include "main.h"
  23 #include "hard-interface.h"
  24 #include "soft-interface.h"
  25 #include "send.h"
  26 #include "translation-table.h"
  27 #include "routing.h"
  28 #include "bat_sysfs.h"
  29 #include "originator.h"
  30 #include "hash.h"
  31
  32 #include <linux/if_arp.h>
  33
  34 /* protect update critical side of if_list - but not the content */
  35 static DEFINE_SPINLOCK(if_list_lock);
  36
  37 static void hardif_free_rcu(struct rcu_head *rcu)
  38 {
  39         struct batman_if *batman_if;
  40
  41         batman_if = container_of(rcu, struct batman_if, rcu);
  42         dev_put(batman_if->net_dev);
  43         kref_put(&batman_if->refcount, hardif_free_ref);
  44 }
  45
  46 struct batman_if *get_batman_if_by_netdev(struct net_device *net_dev)
  47 {
  48         struct batman_if *batman_if;
  49
  50         rcu_read_lock();
  51         list_for_each_entry_rcu(batman_if, &if_list, list) {
  52                 if (batman_if->net_dev == net_dev)
  53                         goto out;
  54         }
  55
  56         batman_if = NULL;
  57
  58 out:
  59         if (batman_if)
  60                 kref_get(&batman_if->refcount);
  61
  62         rcu_read_unlock();
  63         return batman_if;
  64 }
  65
  66 static int is_valid_iface(struct net_device *net_dev)
  67 {
  68         if (net_dev->flags & IFF_LOOPBACK)
  69                 return 0;
  70
  71         if (net_dev->type != ARPHRD_ETHER)
  72                 return 0;
  73
  74         if (net_dev->addr_len != ETH_ALEN)
  75                 return 0;
  76
  77         /* no batman over batman */
  78 #ifdef HAVE_NET_DEVICE_OPS
  79         if (net_dev->netdev_ops->ndo_start_xmit == interface_tx)
  80                 return 0;
  81 #else
  82         if (net_dev->hard_start_xmit == interface_tx)
  83                 return 0;
  84 #endif
  85
  86         /* Device is being bridged */
  87         /* if (net_dev->priv_flags & IFF_BRIDGE_PORT)
  88                 return 0; */
  89
  90         return 1;
  91 }
  92
  93 static struct batman_if *get_active_batman_if(struct net_device *soft_iface)
  94 {
  95         struct batman_if *batman_if;
  96
  97         rcu_read_lock();
  98         list_for_each_entry_rcu(batman_if, &if_list, list) {
  99                 if (batman_if->soft_iface != soft_iface)
 100                         continue;
 101
 102                 if (batman_if->if_status == IF_ACTIVE)
 103                         goto out;
 104         }
 105
 106         batman_if = NULL;
 107
 108 out:
 109         if (batman_if)
 110                 kref_get(&batman_if->refcount);
 111
 112         rcu_read_unlock();
 113         return batman_if;
 114 }
 115
 116 static void update_primary_addr(struct bat_priv *bat_priv)
 117 {
 118         struct vis_packet *vis_packet;
 119
 120         vis_packet = (struct vis_packet *)
 121                                 bat_priv->my_vis_info->skb_packet->data;
 122         memcpy(vis_packet->vis_orig,
 123                bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 124         memcpy(vis_packet->sender_orig,
 125                bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN);
 126 }
 127
 128 static void set_primary_if(struct bat_priv *bat_priv,
 129                            struct batman_if *batman_if)
 130 {
 131         struct batman_packet *batman_packet;
 132         struct batman_if *old_if;
 133
 134         if (batman_if)
 135                 kref_get(&batman_if->refcount);
 136
 137         old_if = bat_priv->primary_if;
 138         bat_priv->primary_if = batman_if;
 139
 140         if (old_if)
 141                 kref_put(&old_if->refcount, hardif_free_ref);
 142
 143         if (!bat_priv->primary_if)
 144                 return;
 145
 146         batman_packet = (struct batman_packet *)(batman_if->packet_buff);
 147         batman_packet->flags = PRIMARIES_FIRST_HOP;
 148         batman_packet->ttl = TTL;
 149
 150         update_primary_addr(bat_priv);
 151
 152         /***
 153          * hacky trick to make sure that we send the HNA information via
 154          * our new primary interface
 155          */
 156         atomic_set(&bat_priv->hna_local_changed, 1);
 157 }
 158
 159 static bool hardif_is_iface_up(struct batman_if *batman_if)
 160 {
 161         if (batman_if->net_dev->flags & IFF_UP)
 162                 return true;
 163
 164         return false;
 165 }
 166
 167 static void update_mac_addresses(struct batman_if *batman_if)
 168 {
 169         memcpy(((struct batman_packet *)(batman_if->packet_buff))->orig,
 170                batman_if->net_dev->dev_addr, ETH_ALEN);
 171         memcpy(((struct batman_packet *)(batman_if->packet_buff))->prev_sender,
 172                batman_if->net_dev->dev_addr, ETH_ALEN);
 173 }
 174
 175 static void check_known_mac_addr(struct net_device *net_dev)
 176 {
 177         struct batman_if *batman_if;
 178
 179         rcu_read_lock();
 180         list_for_each_entry_rcu(batman_if, &if_list, list) {
 181                 if ((batman_if->if_status != IF_ACTIVE) &&
 182                     (batman_if->if_status != IF_TO_BE_ACTIVATED))
 183                         continue;
 184
 185                 if (batman_if->net_dev == net_dev)
 186                         continue;
 187
 188                 if (!compare_orig(batman_if->net_dev->dev_addr,
 189                                   net_dev->dev_addr))
 190                         continue;
 191
 192                 pr_warning("The newly added mac address (%pM) already exists "
 193                            "on: %s\n", net_dev->dev_addr,
 194                            batman_if->net_dev->name);
 195                 pr_warning("It is strongly recommended to keep mac addresses "
 196                            "unique to avoid problems!\n");
 197         }
 198         rcu_read_unlock();
 199 }
 200
 201 int hardif_min_mtu(struct net_device *soft_iface)
 202 {
 203         struct bat_priv *bat_priv = netdev_priv(soft_iface);
 204         struct batman_if *batman_if;
 205         /* allow big frames if all devices are capable to do so
 206          * (have MTU > 1500 + BAT_HEADER_LEN) */
 207         int min_mtu = ETH_DATA_LEN;
 208
 209         if (atomic_read(&bat_priv->fragmentation))
 210                 goto out;
 211
 212         rcu_read_lock();
 213         list_for_each_entry_rcu(batman_if, &if_list, list) {
 214                 if ((batman_if->if_status != IF_ACTIVE) &&
 215                     (batman_if->if_status != IF_TO_BE_ACTIVATED))
 216                         continue;
 217
 218                 if (batman_if->soft_iface != soft_iface)
 219                         continue;
 220
 221                 min_mtu = min_t(int, batman_if->net_dev->mtu - BAT_HEADER_LEN,
 222                                 min_mtu);
 223         }
 224         rcu_read_unlock();
 225 out:
 226         return min_mtu;
 227 }
 228
 229 /* adjusts the MTU if a new interface with a smaller MTU appeared. */
 230 void update_min_mtu(struct net_device *soft_iface)
 231 {
 232         int min_mtu;
 233
 234         min_mtu = hardif_min_mtu(soft_iface);
 235         if (soft_iface->mtu != min_mtu)
 236                 soft_iface->mtu = min_mtu;
 237 }
 238
 239 static void hardif_activate_interface(struct batman_if *batman_if)
 240 {
 241         struct bat_priv *bat_priv;
 242
 243         if (batman_if->if_status != IF_INACTIVE)
 244                 return;
 245
 246         bat_priv = netdev_priv(batman_if->soft_iface);
 247
 248         update_mac_addresses(batman_if);
 249         batman_if->if_status = IF_TO_BE_ACTIVATED;
 250
 251         /**
 252          * the first active interface becomes our primary interface or
 253          * the next active interface after the old primay interface was removed
 254          */
 255         if (!bat_priv->primary_if)
 256                 set_primary_if(bat_priv, batman_if);
 257
 258         bat_info(batman_if->soft_iface, "Interface activated: %s\n",
 259                  batman_if->net_dev->name);
 260
 261         update_min_mtu(batman_if->soft_iface);
 262         return;
 263 }
 264
 265 static void hardif_deactivate_interface(struct batman_if *batman_if)
 266 {
 267         if ((batman_if->if_status != IF_ACTIVE) &&
 268            (batman_if->if_status != IF_TO_BE_ACTIVATED))
 269                 return;
 270
 271         batman_if->if_status = IF_INACTIVE;
 272
 273         bat_info(batman_if->soft_iface, "Interface deactivated: %s\n",
 274                  batman_if->net_dev->name);
 275
 276         update_min_mtu(batman_if->soft_iface);
 277 }
 278
 279 int hardif_enable_interface(struct batman_if *batman_if, char *iface_name)
 280 {
 281         struct bat_priv *bat_priv;
 282         struct batman_packet *batman_packet;
 283
 284         if (batman_if->if_status != IF_NOT_IN_USE)
 285                 goto out;
 286
 287         batman_if->soft_iface = dev_get_by_name(&init_net, iface_name);
 288
 289         if (!batman_if->soft_iface) {
 290                 batman_if->soft_iface = softif_create(iface_name);
 291
 292                 if (!batman_if->soft_iface)
 293                         goto err;
 294
 295                 /* dev_get_by_name() increases the reference counter for us */
 296                 dev_hold(batman_if->soft_iface);
 297         }
 298
 299         bat_priv = netdev_priv(batman_if->soft_iface);
 300         batman_if->packet_len = BAT_PACKET_LEN;
 301         batman_if->packet_buff = kmalloc(batman_if->packet_len, GFP_ATOMIC);
 302
 303         if (!batman_if->packet_buff) {
 304                 bat_err(batman_if->soft_iface, "Can't add interface packet "
 305                         "(%s): out of memory\n", batman_if->net_dev->name);
 306                 goto err;
 307         }
 308
 309         batman_packet = (struct batman_packet *)(batman_if->packet_buff);
 310         batman_packet->packet_type = BAT_PACKET;
 311         batman_packet->version = COMPAT_VERSION;
 312         batman_packet->flags = 0;
 313         batman_packet->ttl = 2;
 314         batman_packet->tq = TQ_MAX_VALUE;
 315         batman_packet->num_hna = 0;
 316
 317         batman_if->if_num = bat_priv->num_ifaces;
 318         bat_priv->num_ifaces++;
 319         batman_if->if_status = IF_INACTIVE;
 320         orig_hash_add_if(batman_if, bat_priv->num_ifaces);
 321
 322         batman_if->batman_adv_ptype.type = __constant_htons(ETH_P_BATMAN);
 323         batman_if->batman_adv_ptype.func = batman_skb_recv;
 324         batman_if->batman_adv_ptype.dev = batman_if->net_dev;
 325         kref_get(&batman_if->refcount);
 326         dev_add_pack(&batman_if->batman_adv_ptype);
 327
 328         atomic_set(&batman_if->seqno, 1);
 329         atomic_set(&batman_if->frag_seqno, 1);
 330         bat_info(batman_if->soft_iface, "Adding interface: %s\n",
 331                  batman_if->net_dev->name);
 332
 333         if (atomic_read(&bat_priv->fragmentation) && batman_if->net_dev->mtu <
 334                 ETH_DATA_LEN + BAT_HEADER_LEN)
 335                 bat_info(batman_if->soft_iface,
 336                         "The MTU of interface %s is too small (%i) to handle "
 337                         "the transport of batman-adv packets. Packets going "
 338                         "over this interface will be fragmented on layer2 "
 339                         "which could impact the performance. Setting the MTU "
 340                         "to %zi would solve the problem.\n",
 341                         batman_if->net_dev->name, batman_if->net_dev->mtu,
 342                         ETH_DATA_LEN + BAT_HEADER_LEN);
 343
 344         if (!atomic_read(&bat_priv->fragmentation) && batman_if->net_dev->mtu <
 345                 ETH_DATA_LEN + BAT_HEADER_LEN)
 346                 bat_info(batman_if->soft_iface,
 347                         "The MTU of interface %s is too small (%i) to handle "
 348                         "the transport of batman-adv packets. If you experience"
 349                         " problems getting traffic through try increasing the "
 350                         "MTU to %zi.\n",
 351                         batman_if->net_dev->name, batman_if->net_dev->mtu,
 352                         ETH_DATA_LEN + BAT_HEADER_LEN);
 353
 354         if (hardif_is_iface_up(batman_if))
 355                 hardif_activate_interface(batman_if);
 356         else
 357                 bat_err(batman_if->soft_iface, "Not using interface %s "
 358                         "(retrying later): interface not active\n",
 359                         batman_if->net_dev->name);
 360
 361         /* begin scheduling originator messages on that interface */
 362         schedule_own_packet(batman_if);
 363
 364 out:
 365         return 0;
 366
 367 err:
 368         return -ENOMEM;
 369 }
 370
 371 void hardif_disable_interface(struct batman_if *batman_if)
 372 {
 373         struct bat_priv *bat_priv = netdev_priv(batman_if->soft_iface);
 374
 375         if (batman_if->if_status == IF_ACTIVE)
 376                 hardif_deactivate_interface(batman_if);
 377
 378         if (batman_if->if_status != IF_INACTIVE)
 379                 return;
 380
 381         bat_info(batman_if->soft_iface, "Removing interface: %s\n",
 382                  batman_if->net_dev->name);
 383         dev_remove_pack(&batman_if->batman_adv_ptype);
 384         kref_put(&batman_if->refcount, hardif_free_ref);
 385
 386         bat_priv->num_ifaces--;
 387         orig_hash_del_if(batman_if, bat_priv->num_ifaces);
 388
 389         if (batman_if == bat_priv->primary_if) {
 390                 struct batman_if *new_if;
 391
 392                 new_if = get_active_batman_if(batman_if->soft_iface);
 393                 set_primary_if(bat_priv, new_if);
 394
 395                 if (new_if)
 396                         kref_put(&new_if->refcount, hardif_free_ref);
 397         }
 398
 399         kfree(batman_if->packet_buff);
 400         batman_if->packet_buff = NULL;
 401         batman_if->if_status = IF_NOT_IN_USE;
 402
 403         /* delete all references to this batman_if */
 404         purge_orig_ref(bat_priv);
 405         purge_outstanding_packets(bat_priv, batman_if);
 406         dev_put(batman_if->soft_iface);
 407
 408         /* nobody uses this interface anymore */
 409         if (!bat_priv->num_ifaces)
 410                 softif_destroy(batman_if->soft_iface);
 411
 412         batman_if->soft_iface = NULL;
 413 }
 414
 415 static struct batman_if *hardif_add_interface(struct net_device *net_dev)
 416 {
 417         struct batman_if *batman_if;
 418         int ret;
 419
 420         ret = is_valid_iface(net_dev);
 421         if (ret != 1)
 422                 goto out;
 423
 424         dev_hold(net_dev);
 425
 426         batman_if = kmalloc(sizeof(struct batman_if), GFP_ATOMIC);
 427         if (!batman_if) {
 428                 pr_err("Can't add interface (%s): out of memory\n",
 429                        net_dev->name);
 430                 goto release_dev;
 431         }
 432
 433         ret = sysfs_add_hardif(&batman_if->hardif_obj, net_dev);
 434         if (ret)
 435                 goto free_if;
 436
 437         batman_if->if_num = -1;
 438         batman_if->net_dev = net_dev;
 439         batman_if->soft_iface = NULL;
 440         batman_if->if_status = IF_NOT_IN_USE;
 441         INIT_LIST_HEAD(&batman_if->list);
 442         kref_init(&batman_if->refcount);
 443
 444         check_known_mac_addr(batman_if->net_dev);
 445
 446         spin_lock(&if_list_lock);
 447         list_add_tail_rcu(&batman_if->list, &if_list);
 448         spin_unlock(&if_list_lock);
 449
 450         /* extra reference for return */
 451         kref_get(&batman_if->refcount);
 452         return batman_if;
 453
 454 free_if:
 455         kfree(batman_if);
 456 release_dev:
 457         dev_put(net_dev);
 458 out:
 459         return NULL;
 460 }
 461
 462 static void hardif_remove_interface(struct batman_if *batman_if)
 463 {
 464         /* first deactivate interface */
 465         if (batman_if->if_status != IF_NOT_IN_USE)
 466                 hardif_disable_interface(batman_if);
 467
 468         if (batman_if->if_status != IF_NOT_IN_USE)
 469                 return;
 470
 471         batman_if->if_status = IF_TO_BE_REMOVED;
 472         sysfs_del_hardif(&batman_if->hardif_obj);
 473         call_rcu(&batman_if->rcu, hardif_free_rcu);
 474 }
 475
 476 void hardif_remove_interfaces(void)
 477 {
 478         struct batman_if *batman_if, *batman_if_tmp;
 479         struct list_head if_queue;
 480
 481         INIT_LIST_HEAD(&if_queue);
 482
 483         spin_lock(&if_list_lock);
 484         list_for_each_entry_safe(batman_if, batman_if_tmp, &if_list, list) {
 485                 list_del_rcu(&batman_if->list);
 486                 list_add_tail(&batman_if->list, &if_queue);
 487         }
 488         spin_unlock(&if_list_lock);
 489
 490         rtnl_lock();
 491         list_for_each_entry_safe(batman_if, batman_if_tmp, &if_queue, list) {
 492                 hardif_remove_interface(batman_if);
 493         }
 494         rtnl_unlock();
 495 }
 496
 497 static int hard_if_event(struct notifier_block *this,
 498                          unsigned long event, void *ptr)
 499 {
 500         struct net_device *net_dev = (struct net_device *)ptr;
 501         struct batman_if *batman_if = get_batman_if_by_netdev(net_dev);
 502         struct bat_priv *bat_priv;
 503
 504         if (!batman_if && event == NETDEV_REGISTER)
 505                 batman_if = hardif_add_interface(net_dev);
 506
 507         if (!batman_if)
 508                 goto out;
 509
 510         switch (event) {
 511         case NETDEV_UP:
 512                 hardif_activate_interface(batman_if);
 513                 break;
 514         case NETDEV_GOING_DOWN:
 515         case NETDEV_DOWN:
 516                 hardif_deactivate_interface(batman_if);
 517                 break;
 518         case NETDEV_UNREGISTER:
 519                 spin_lock(&if_list_lock);
 520                 list_del_rcu(&batman_if->list);
 521                 spin_unlock(&if_list_lock);
 522
 523                 hardif_remove_interface(batman_if);
 524                 break;
 525         case NETDEV_CHANGEMTU:
 526                 if (batman_if->soft_iface)
 527                         update_min_mtu(batman_if->soft_iface);
 528                 break;
 529         case NETDEV_CHANGEADDR:
 530                 if (batman_if->if_status == IF_NOT_IN_USE)
 531                         goto hardif_put;
 532
 533                 check_known_mac_addr(batman_if->net_dev);
 534                 update_mac_addresses(batman_if);
 535
 536                 bat_priv = netdev_priv(batman_if->soft_iface);
 537                 if (batman_if == bat_priv->primary_if)
 538                         update_primary_addr(bat_priv);
 539                 break;
 540         default:
 541                 break;
 542         };
 543
 544 hardif_put:
 545         kref_put(&batman_if->refcount, hardif_free_ref);
 546 out:
 547         return NOTIFY_DONE;
 548 }
 549
 550 /* receive a packet with the batman ethertype coming on a hard
 551  * interface */
 552 int batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
 553         struct packet_type *ptype, struct net_device *orig_dev)
 554 {
 555         struct bat_priv *bat_priv;
 556         struct batman_packet *batman_packet;
 557         struct batman_if *batman_if;
 558         int ret;
 559
 560         batman_if = container_of(ptype, struct batman_if, batman_adv_ptype);
 561         skb = skb_share_check(skb, GFP_ATOMIC);
 562
 563         /* skb was released by skb_share_check() */
 564         if (!skb)
 565                 goto err_out;
 566
 567         /* packet should hold at least type and version */
 568         if (unlikely(!pskb_may_pull(skb, 2)))
 569                 goto err_free;
 570
 571         /* expect a valid ethernet header here. */
 572         if (unlikely(skb->mac_len != sizeof(struct ethhdr)
 573                                 || !skb_mac_header(skb)))
 574                 goto err_free;
 575
 576         if (!batman_if->soft_iface)
 577                 goto err_free;
 578
 579         bat_priv = netdev_priv(batman_if->soft_iface);
 580
 581         if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE)
 582                 goto err_free;
 583
 584         /* discard frames on not active interfaces */
 585         if (batman_if->if_status != IF_ACTIVE)
 586                 goto err_free;
 587
 588         batman_packet = (struct batman_packet *)skb->data;
 589
 590         if (batman_packet->version != COMPAT_VERSION) {
 591                 bat_dbg(DBG_BATMAN, bat_priv,
 592                         "Drop packet: incompatible batman version (%i)\n",
 593                         batman_packet->version);
 594                 goto err_free;
 595         }
 596
 597         /* all receive handlers return whether they received or reused
 598          * the supplied skb. if not, we have to free the skb. */
 599
 600         switch (batman_packet->packet_type) {
 601                 /* batman originator packet */
 602         case BAT_PACKET:
 603                 ret = recv_bat_packet(skb, batman_if);
 604                 break;
 605
 606                 /* batman icmp packet */
 607         case BAT_ICMP:
 608                 ret = recv_icmp_packet(skb, batman_if);
 609                 break;
 610
 611                 /* unicast packet */
 612         case BAT_UNICAST:
 613                 ret = recv_unicast_packet(skb, batman_if);
 614                 break;
 615
 616                 /* fragmented unicast packet */
 617         case BAT_UNICAST_FRAG:
 618                 ret = recv_ucast_frag_packet(skb, batman_if);
 619                 break;
 620
 621                 /* broadcast packet */
 622         case BAT_BCAST:
 623                 ret = recv_bcast_packet(skb, batman_if);
 624                 break;
 625
 626                 /* vis packet */
 627         case BAT_VIS:
 628                 ret = recv_vis_packet(skb, batman_if);
 629                 break;
 630         default:
 631                 ret = NET_RX_DROP;
 632         }
 633
 634         if (ret == NET_RX_DROP)
 635                 kfree_skb(skb);
 636
 637         /* return NET_RX_SUCCESS in any case as we
 638          * most probably dropped the packet for
 639          * routing-logical reasons. */
 640
 641         return NET_RX_SUCCESS;
 642
 643 err_free:
 644         kfree_skb(skb);
 645 err_out:
 646         return NET_RX_DROP;
 647 }
 648
 649 struct notifier_block hard_if_notifier = {
 650         .notifier_call = hard_if_event,
 651 };