kernel/net/batman-adv/soft-interface.c

   1 /* Copyright (C) 2007-2014 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 "main.h"
  19 #include "soft-interface.h"
  20 #include "hard-interface.h"
  21 #include "distributed-arp-table.h"
  22 #include "routing.h"
  23 #include "send.h"
  24 #include "debugfs.h"
  25 #include "translation-table.h"
  26 #include "hash.h"
  27 #include "gateway_common.h"
  28 #include "gateway_client.h"
  29 #include "sysfs.h"
  30 #include "originator.h"
  31 #include <linux/slab.h>
  32 #include <linux/ethtool.h>
  33 #include <linux/etherdevice.h>
  34 #include <linux/if_vlan.h>
  35 #include "multicast.h"
  36 #include "bridge_loop_avoidance.h"
  37 #include "network-coding.h"
  38
  39 static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
  40 static void batadv_get_drvinfo(struct net_device *dev,
  41                                struct ethtool_drvinfo *info);
  42 static u32 batadv_get_msglevel(struct net_device *dev);
  43 static void batadv_set_msglevel(struct net_device *dev, u32 value);
  44 static u32 batadv_get_link(struct net_device *dev);
  45 static void batadv_get_strings(struct net_device *dev, u32 stringset, u8 *data);
  46 static void batadv_get_ethtool_stats(struct net_device *dev,
  47                                      struct ethtool_stats *stats, u64 *data);
  48 static int batadv_get_sset_count(struct net_device *dev, int stringset);
  49
  50 static const struct ethtool_ops batadv_ethtool_ops = {
  51         .get_settings = batadv_get_settings,
  52         .get_drvinfo = batadv_get_drvinfo,
  53         .get_msglevel = batadv_get_msglevel,
  54         .set_msglevel = batadv_set_msglevel,
  55         .get_link = batadv_get_link,
  56         .get_strings = batadv_get_strings,
  57         .get_ethtool_stats = batadv_get_ethtool_stats,
  58         .get_sset_count = batadv_get_sset_count,
  59 };
  60
  61 int batadv_skb_head_push(struct sk_buff *skb, unsigned int len)
  62 {
  63         int result;
  64
  65         /* TODO: We must check if we can release all references to non-payload
  66          * data using skb_header_release in our skbs to allow skb_cow_header to
  67          * work optimally. This means that those skbs are not allowed to read
  68          * or write any data which is before the current position of skb->data
  69          * after that call and thus allow other skbs with the same data buffer
  70          * to write freely in that area.
  71          */
  72         result = skb_cow_head(skb, len);
  73         if (result < 0)
  74                 return result;
  75
  76         skb_push(skb, len);
  77         return 0;
  78 }
  79
  80 static int batadv_interface_open(struct net_device *dev)
  81 {
  82         netif_start_queue(dev);
  83         return 0;
  84 }
  85
  86 static int batadv_interface_release(struct net_device *dev)
  87 {
  88         netif_stop_queue(dev);
  89         return 0;
  90 }
  91
  92 static struct net_device_stats *batadv_interface_stats(struct net_device *dev)
  93 {
  94         struct batadv_priv *bat_priv = netdev_priv(dev);
  95         struct net_device_stats *stats = &bat_priv->stats;
  96
  97         stats->tx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_TX);
  98         stats->tx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_TX_BYTES);
  99         stats->tx_dropped = batadv_sum_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 100         stats->rx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_RX);
 101         stats->rx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_RX_BYTES);
 102         return stats;
 103 }
 104
 105 static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)
 106 {
 107         struct batadv_priv *bat_priv = netdev_priv(dev);
 108         struct sockaddr *addr = p;
 109         uint8_t old_addr[ETH_ALEN];
 110
 111         if (!is_valid_ether_addr(addr->sa_data))
 112                 return -EADDRNOTAVAIL;
 113
 114         ether_addr_copy(old_addr, dev->dev_addr);
 115         ether_addr_copy(dev->dev_addr, addr->sa_data);
 116
 117         /* only modify transtable if it has been initialized before */
 118         if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) {
 119                 batadv_tt_local_remove(bat_priv, old_addr, BATADV_NO_FLAGS,
 120                                        "mac address changed", false);
 121                 batadv_tt_local_add(dev, addr->sa_data, BATADV_NO_FLAGS,
 122                                     BATADV_NULL_IFINDEX, BATADV_NO_MARK);
 123         }
 124
 125         return 0;
 126 }
 127
 128 static int batadv_interface_change_mtu(struct net_device *dev, int new_mtu)
 129 {
 130         /* check ranges */
 131         if ((new_mtu < 68) || (new_mtu > batadv_hardif_min_mtu(dev)))
 132                 return -EINVAL;
 133
 134         dev->mtu = new_mtu;
 135
 136         return 0;
 137 }
 138
 139 /**
 140  * batadv_interface_set_rx_mode - set the rx mode of a device
 141  * @dev: registered network device to modify
 142  *
 143  * We do not actually need to set any rx filters for the virtual batman
 144  * soft interface. However a dummy handler enables a user to set static
 145  * multicast listeners for instance.
 146  */
 147 static void batadv_interface_set_rx_mode(struct net_device *dev)
 148 {
 149 }
 150
 151 static int batadv_interface_tx(struct sk_buff *skb,
 152                                struct net_device *soft_iface)
 153 {
 154         struct ethhdr *ethhdr;
 155         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 156         struct batadv_hard_iface *primary_if = NULL;
 157         struct batadv_bcast_packet *bcast_packet;
 158         __be16 ethertype = htons(ETH_P_BATMAN);
 159         static const uint8_t stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00,
 160                                                    0x00, 0x00};
 161         static const uint8_t ectp_addr[ETH_ALEN] = {0xCF, 0x00, 0x00, 0x00,
 162                                                     0x00, 0x00};
 163         enum batadv_dhcp_recipient dhcp_rcp = BATADV_DHCP_NO;
 164         uint8_t *dst_hint = NULL, chaddr[ETH_ALEN];
 165         struct vlan_ethhdr *vhdr;
 166         unsigned int header_len = 0;
 167         int data_len = skb->len, ret;
 168         unsigned long brd_delay = 1;
 169         bool do_bcast = false, client_added;
 170         unsigned short vid;
 171         uint32_t seqno;
 172         int gw_mode;
 173         enum batadv_forw_mode forw_mode;
 174         struct batadv_orig_node *mcast_single_orig = NULL;
 175
 176         if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 177                 goto dropped;
 178
 179         soft_iface->trans_start = jiffies;
 180         vid = batadv_get_vid(skb, 0);
 181         ethhdr = eth_hdr(skb);
 182
 183         switch (ntohs(ethhdr->h_proto)) {
 184         case ETH_P_8021Q:
 185                 vhdr = vlan_eth_hdr(skb);
 186
 187                 if (vhdr->h_vlan_encapsulated_proto != ethertype)
 188                         break;
 189
 190                 /* fall through */
 191         case ETH_P_BATMAN:
 192                 goto dropped;
 193         }
 194
 195         if (batadv_bla_tx(bat_priv, skb, vid))
 196                 goto dropped;
 197
 198         /* skb->data might have been reallocated by batadv_bla_tx() */
 199         ethhdr = eth_hdr(skb);
 200
 201         /* Register the client MAC in the transtable */
 202         if (!is_multicast_ether_addr(ethhdr->h_source)) {
 203                 client_added = batadv_tt_local_add(soft_iface, ethhdr->h_source,
 204                                                    vid, skb->skb_iif,
 205                                                    skb->mark);
 206                 if (!client_added)
 207                         goto dropped;
 208         }
 209
 210         /* don't accept stp packets. STP does not help in meshes.
 211          * better use the bridge loop avoidance ...
 212          *
 213          * The same goes for ECTP sent at least by some Cisco Switches,
 214          * it might confuse the mesh when used with bridge loop avoidance.
 215          */
 216         if (batadv_compare_eth(ethhdr->h_dest, stp_addr))
 217                 goto dropped;
 218
 219         if (batadv_compare_eth(ethhdr->h_dest, ectp_addr))
 220                 goto dropped;
 221
 222         gw_mode = atomic_read(&bat_priv->gw_mode);
 223         if (is_multicast_ether_addr(ethhdr->h_dest)) {
 224                 /* if gw mode is off, broadcast every packet */
 225                 if (gw_mode == BATADV_GW_MODE_OFF) {
 226                         do_bcast = true;
 227                         goto send;
 228                 }
 229
 230                 dhcp_rcp = batadv_gw_dhcp_recipient_get(skb, &header_len,
 231                                                         chaddr);
 232                 /* skb->data may have been modified by
 233                  * batadv_gw_dhcp_recipient_get()
 234                  */
 235                 ethhdr = eth_hdr(skb);
 236                 /* if gw_mode is on, broadcast any non-DHCP message.
 237                  * All the DHCP packets are going to be sent as unicast
 238                  */
 239                 if (dhcp_rcp == BATADV_DHCP_NO) {
 240                         do_bcast = true;
 241                         goto send;
 242                 }
 243
 244                 if (dhcp_rcp == BATADV_DHCP_TO_CLIENT)
 245                         dst_hint = chaddr;
 246                 else if ((gw_mode == BATADV_GW_MODE_SERVER) &&
 247                          (dhcp_rcp == BATADV_DHCP_TO_SERVER))
 248                         /* gateways should not forward any DHCP message if
 249                          * directed to a DHCP server
 250                          */
 251                         goto dropped;
 252
 253 send:
 254                 if (do_bcast && !is_broadcast_ether_addr(ethhdr->h_dest)) {
 255                         forw_mode = batadv_mcast_forw_mode(bat_priv, skb,
 256                                                            &mcast_single_orig);
 257                         if (forw_mode == BATADV_FORW_NONE)
 258                                 goto dropped;
 259
 260                         if (forw_mode == BATADV_FORW_SINGLE)
 261                                 do_bcast = false;
 262                 }
 263         }
 264
 265         batadv_skb_set_priority(skb, 0);
 266
 267         /* ethernet packet should be broadcasted */
 268         if (do_bcast) {
 269                 primary_if = batadv_primary_if_get_selected(bat_priv);
 270                 if (!primary_if)
 271                         goto dropped;
 272
 273                 /* in case of ARP request, we do not immediately broadcasti the
 274                  * packet, instead we first wait for DAT to try to retrieve the
 275                  * correct ARP entry
 276                  */
 277                 if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
 278                         brd_delay = msecs_to_jiffies(ARP_REQ_DELAY);
 279
 280                 if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
 281                         goto dropped;
 282
 283                 bcast_packet = (struct batadv_bcast_packet *)skb->data;
 284                 bcast_packet->version = BATADV_COMPAT_VERSION;
 285                 bcast_packet->ttl = BATADV_TTL;
 286
 287                 /* batman packet type: broadcast */
 288                 bcast_packet->packet_type = BATADV_BCAST;
 289                 bcast_packet->reserved = 0;
 290
 291                 /* hw address of first interface is the orig mac because only
 292                  * this mac is known throughout the mesh
 293                  */
 294                 ether_addr_copy(bcast_packet->orig,
 295                                 primary_if->net_dev->dev_addr);
 296
 297                 /* set broadcast sequence number */
 298                 seqno = atomic_inc_return(&bat_priv->bcast_seqno);
 299                 bcast_packet->seqno = htonl(seqno);
 300
 301                 batadv_add_bcast_packet_to_list(bat_priv, skb, brd_delay);
 302
 303                 /* a copy is stored in the bcast list, therefore removing
 304                  * the original skb.
 305                  */
 306                 kfree_skb(skb);
 307
 308         /* unicast packet */
 309         } else {
 310                 /* DHCP packets going to a server will use the GW feature */
 311                 if (dhcp_rcp == BATADV_DHCP_TO_SERVER) {
 312                         ret = batadv_gw_out_of_range(bat_priv, skb);
 313                         if (ret)
 314                                 goto dropped;
 315                         ret = batadv_send_skb_via_gw(bat_priv, skb, vid);
 316                 } else if (mcast_single_orig) {
 317                         ret = batadv_send_skb_unicast(bat_priv, skb,
 318                                                       BATADV_UNICAST, 0,
 319                                                       mcast_single_orig, vid);
 320                 } else {
 321                         if (batadv_dat_snoop_outgoing_arp_request(bat_priv,
 322                                                                   skb))
 323                                 goto dropped;
 324
 325                         batadv_dat_snoop_outgoing_arp_reply(bat_priv, skb);
 326
 327                         ret = batadv_send_skb_via_tt(bat_priv, skb, dst_hint,
 328                                                      vid);
 329                 }
 330                 if (ret == NET_XMIT_DROP)
 331                         goto dropped_freed;
 332         }
 333
 334         batadv_inc_counter(bat_priv, BATADV_CNT_TX);
 335         batadv_add_counter(bat_priv, BATADV_CNT_TX_BYTES, data_len);
 336         goto end;
 337
 338 dropped:
 339         kfree_skb(skb);
 340 dropped_freed:
 341         batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 342 end:
 343         if (primary_if)
 344                 batadv_hardif_free_ref(primary_if);
 345         return NETDEV_TX_OK;
 346 }
 347
 348 void batadv_interface_rx(struct net_device *soft_iface,
 349                          struct sk_buff *skb, struct batadv_hard_iface *recv_if,
 350                          int hdr_size, struct batadv_orig_node *orig_node)
 351 {
 352         struct batadv_bcast_packet *batadv_bcast_packet;
 353         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 354         __be16 ethertype = htons(ETH_P_BATMAN);
 355         struct vlan_ethhdr *vhdr;
 356         struct ethhdr *ethhdr;
 357         unsigned short vid;
 358         bool is_bcast;
 359
 360         batadv_bcast_packet = (struct batadv_bcast_packet *)skb->data;
 361         is_bcast = (batadv_bcast_packet->packet_type == BATADV_BCAST);
 362
 363         /* check if enough space is available for pulling, and pull */
 364         if (!pskb_may_pull(skb, hdr_size))
 365                 goto dropped;
 366
 367         skb_pull_rcsum(skb, hdr_size);
 368         skb_reset_mac_header(skb);
 369
 370         /* clean the netfilter state now that the batman-adv header has been
 371          * removed
 372          */
 373         nf_reset(skb);
 374
 375         vid = batadv_get_vid(skb, 0);
 376         ethhdr = eth_hdr(skb);
 377
 378         switch (ntohs(ethhdr->h_proto)) {
 379         case ETH_P_8021Q:
 380                 vhdr = (struct vlan_ethhdr *)skb->data;
 381
 382                 if (vhdr->h_vlan_encapsulated_proto != ethertype)
 383                         break;
 384
 385                 /* fall through */
 386         case ETH_P_BATMAN:
 387                 goto dropped;
 388         }
 389
 390         /* skb->dev & skb->pkt_type are set here */
 391         if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
 392                 goto dropped;
 393         skb->protocol = eth_type_trans(skb, soft_iface);
 394
 395         /* should not be necessary anymore as we use skb_pull_rcsum()
 396          * TODO: please verify this and remove this TODO
 397          * -- Dec 21st 2009, Simon Wunderlich
 398          */
 399
 400         /* skb->ip_summed = CHECKSUM_UNNECESSARY; */
 401
 402         batadv_inc_counter(bat_priv, BATADV_CNT_RX);
 403         batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
 404                            skb->len + ETH_HLEN);
 405
 406         soft_iface->last_rx = jiffies;
 407
 408         /* Let the bridge loop avoidance check the packet. If will
 409          * not handle it, we can safely push it up.
 410          */
 411         if (batadv_bla_rx(bat_priv, skb, vid, is_bcast))
 412                 goto out;
 413
 414         if (orig_node)
 415                 batadv_tt_add_temporary_global_entry(bat_priv, orig_node,
 416                                                      ethhdr->h_source, vid);
 417
 418         if (is_multicast_ether_addr(ethhdr->h_dest)) {
 419                 /* set the mark on broadcast packets if AP isolation is ON and
 420                  * the packet is coming from an "isolated" client
 421                  */
 422                 if (batadv_vlan_ap_isola_get(bat_priv, vid) &&
 423                     batadv_tt_global_is_isolated(bat_priv, ethhdr->h_source,
 424                                                  vid)) {
 425                         /* save bits in skb->mark not covered by the mask and
 426                          * apply the mark on the rest
 427                          */
 428                         skb->mark &= ~bat_priv->isolation_mark_mask;
 429                         skb->mark |= bat_priv->isolation_mark;
 430                 }
 431         } else if (batadv_is_ap_isolated(bat_priv, ethhdr->h_source,
 432                                          ethhdr->h_dest, vid)) {
 433                 goto dropped;
 434         }
 435
 436         netif_rx(skb);
 437         goto out;
 438
 439 dropped:
 440         kfree_skb(skb);
 441 out:
 442         return;
 443 }
 444
 445 /**
 446  * batadv_softif_vlan_free_ref - decrease the vlan object refcounter and
 447  *  possibly free it
 448  * @softif_vlan: the vlan object to release
 449  */
 450 void batadv_softif_vlan_free_ref(struct batadv_softif_vlan *vlan)
 451 {
 452         if (atomic_dec_and_test(&vlan->refcount)) {
 453                 spin_lock_bh(&vlan->bat_priv->softif_vlan_list_lock);
 454                 hlist_del_rcu(&vlan->list);
 455                 spin_unlock_bh(&vlan->bat_priv->softif_vlan_list_lock);
 456
 457                 kfree_rcu(vlan, rcu);
 458         }
 459 }
 460
 461 /**
 462  * batadv_softif_vlan_get - get the vlan object for a specific vid
 463  * @bat_priv: the bat priv with all the soft interface information
 464  * @vid: the identifier of the vlan object to retrieve
 465  *
 466  * Returns the private data of the vlan matching the vid passed as argument or
 467  * NULL otherwise. The refcounter of the returned object is incremented by 1.
 468  */
 469 struct batadv_softif_vlan *batadv_softif_vlan_get(struct batadv_priv *bat_priv,
 470                                                   unsigned short vid)
 471 {
 472         struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
 473
 474         rcu_read_lock();
 475         hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
 476                 if (vlan_tmp->vid != vid)
 477                         continue;
 478
 479                 if (!atomic_inc_not_zero(&vlan_tmp->refcount))
 480                         continue;
 481
 482                 vlan = vlan_tmp;
 483                 break;
 484         }
 485         rcu_read_unlock();
 486
 487         return vlan;
 488 }
 489
 490 /**
 491  * batadv_create_vlan - allocate the needed resources for a new vlan
 492  * @bat_priv: the bat priv with all the soft interface information
 493  * @vid: the VLAN identifier
 494  *
 495  * Returns 0 on success, a negative error otherwise.
 496  */
 497 int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid)
 498 {
 499         struct batadv_softif_vlan *vlan;
 500         int err;
 501
 502         vlan = batadv_softif_vlan_get(bat_priv, vid);
 503         if (vlan) {
 504                 batadv_softif_vlan_free_ref(vlan);
 505                 return -EEXIST;
 506         }
 507
 508         vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC);
 509         if (!vlan)
 510                 return -ENOMEM;
 511
 512         vlan->bat_priv = bat_priv;
 513         vlan->vid = vid;
 514         atomic_set(&vlan->refcount, 1);
 515
 516         atomic_set(&vlan->ap_isolation, 0);
 517
 518         err = batadv_sysfs_add_vlan(bat_priv->soft_iface, vlan);
 519         if (err) {
 520                 kfree(vlan);
 521                 return err;
 522         }
 523
 524         spin_lock_bh(&bat_priv->softif_vlan_list_lock);
 525         hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list);
 526         spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
 527
 528         /* add a new TT local entry. This one will be marked with the NOPURGE
 529          * flag
 530          */
 531         batadv_tt_local_add(bat_priv->soft_iface,
 532                             bat_priv->soft_iface->dev_addr, vid,
 533                             BATADV_NULL_IFINDEX, BATADV_NO_MARK);
 534
 535         return 0;
 536 }
 537
 538 /**
 539  * batadv_softif_destroy_vlan - remove and destroy a softif_vlan object
 540  * @bat_priv: the bat priv with all the soft interface information
 541  * @vlan: the object to remove
 542  */
 543 static void batadv_softif_destroy_vlan(struct batadv_priv *bat_priv,
 544                                        struct batadv_softif_vlan *vlan)
 545 {
 546         /* explicitly remove the associated TT local entry because it is marked
 547          * with the NOPURGE flag
 548          */
 549         batadv_tt_local_remove(bat_priv, bat_priv->soft_iface->dev_addr,
 550                                vlan->vid, "vlan interface destroyed", false);
 551
 552         batadv_sysfs_del_vlan(bat_priv, vlan);
 553         batadv_softif_vlan_free_ref(vlan);
 554 }
 555
 556 /**
 557  * batadv_interface_add_vid - ndo_add_vid API implementation
 558  * @dev: the netdev of the mesh interface
 559  * @vid: identifier of the new vlan
 560  *
 561  * Set up all the internal structures for handling the new vlan on top of the
 562  * mesh interface
 563  *
 564  * Returns 0 on success or a negative error code in case of failure.
 565  */
 566 static int batadv_interface_add_vid(struct net_device *dev, __be16 proto,
 567                                     unsigned short vid)
 568 {
 569         struct batadv_priv *bat_priv = netdev_priv(dev);
 570         struct batadv_softif_vlan *vlan;
 571         int ret;
 572
 573         /* only 802.1Q vlans are supported.
 574          * batman-adv does not know how to handle other types
 575          */
 576         if (proto != htons(ETH_P_8021Q))
 577                 return -EINVAL;
 578
 579         vid |= BATADV_VLAN_HAS_TAG;
 580
 581         /* if a new vlan is getting created and it already exists, it means that
 582          * it was not deleted yet. batadv_softif_vlan_get() increases the
 583          * refcount in order to revive the object.
 584          *
 585          * if it does not exist then create it.
 586          */
 587         vlan = batadv_softif_vlan_get(bat_priv, vid);
 588         if (!vlan)
 589                 return batadv_softif_create_vlan(bat_priv, vid);
 590
 591         /* recreate the sysfs object if it was already destroyed (and it should
 592          * be since we received a kill_vid() for this vlan
 593          */
 594         if (!vlan->kobj) {
 595                 ret = batadv_sysfs_add_vlan(bat_priv->soft_iface, vlan);
 596                 if (ret) {
 597                         batadv_softif_vlan_free_ref(vlan);
 598                         return ret;
 599                 }
 600         }
 601
 602         /* add a new TT local entry. This one will be marked with the NOPURGE
 603          * flag. This must be added again, even if the vlan object already
 604          * exists, because the entry was deleted by kill_vid()
 605          */
 606         batadv_tt_local_add(bat_priv->soft_iface,
 607                             bat_priv->soft_iface->dev_addr, vid,
 608                             BATADV_NULL_IFINDEX, BATADV_NO_MARK);
 609
 610         return 0;
 611 }
 612
 613 /**
 614  * batadv_interface_kill_vid - ndo_kill_vid API implementation
 615  * @dev: the netdev of the mesh interface
 616  * @vid: identifier of the deleted vlan
 617  *
 618  * Destroy all the internal structures used to handle the vlan identified by vid
 619  * on top of the mesh interface
 620  *
 621  * Returns 0 on success, -EINVAL if the specified prototype is not ETH_P_8021Q
 622  * or -ENOENT if the specified vlan id wasn't registered.
 623  */
 624 static int batadv_interface_kill_vid(struct net_device *dev, __be16 proto,
 625                                      unsigned short vid)
 626 {
 627         struct batadv_priv *bat_priv = netdev_priv(dev);
 628         struct batadv_softif_vlan *vlan;
 629
 630         /* only 802.1Q vlans are supported. batman-adv does not know how to
 631          * handle other types
 632          */
 633         if (proto != htons(ETH_P_8021Q))
 634                 return -EINVAL;
 635
 636         vlan = batadv_softif_vlan_get(bat_priv, vid | BATADV_VLAN_HAS_TAG);
 637         if (!vlan)
 638                 return -ENOENT;
 639
 640         batadv_softif_destroy_vlan(bat_priv, vlan);
 641
 642         /* finally free the vlan object */
 643         batadv_softif_vlan_free_ref(vlan);
 644
 645         return 0;
 646 }
 647
 648 /* batman-adv network devices have devices nesting below it and are a special
 649  * "super class" of normal network devices; split their locks off into a
 650  * separate class since they always nest.
 651  */
 652 static struct lock_class_key batadv_netdev_xmit_lock_key;
 653 static struct lock_class_key batadv_netdev_addr_lock_key;
 654
 655 /**
 656  * batadv_set_lockdep_class_one - Set lockdep class for a single tx queue
 657  * @dev: device which owns the tx queue
 658  * @txq: tx queue to modify
 659  * @_unused: always NULL
 660  */
 661 static void batadv_set_lockdep_class_one(struct net_device *dev,
 662                                          struct netdev_queue *txq,
 663                                          void *_unused)
 664 {
 665         lockdep_set_class(&txq->_xmit_lock, &batadv_netdev_xmit_lock_key);
 666 }
 667
 668 /**
 669  * batadv_set_lockdep_class - Set txq and addr_list lockdep class
 670  * @dev: network device to modify
 671  */
 672 static void batadv_set_lockdep_class(struct net_device *dev)
 673 {
 674         lockdep_set_class(&dev->addr_list_lock, &batadv_netdev_addr_lock_key);
 675         netdev_for_each_tx_queue(dev, batadv_set_lockdep_class_one, NULL);
 676 }
 677
 678 /**
 679  * batadv_softif_destroy_finish - cleans up the remains of a softif
 680  * @work: work queue item
 681  *
 682  * Free the parts of the soft interface which can not be removed under
 683  * rtnl lock (to prevent deadlock situations).
 684  */
 685 static void batadv_softif_destroy_finish(struct work_struct *work)
 686 {
 687         struct batadv_softif_vlan *vlan;
 688         struct batadv_priv *bat_priv;
 689         struct net_device *soft_iface;
 690
 691         bat_priv = container_of(work, struct batadv_priv,
 692                                 cleanup_work);
 693         soft_iface = bat_priv->soft_iface;
 694
 695         /* destroy the "untagged" VLAN */
 696         vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
 697         if (vlan) {
 698                 batadv_softif_destroy_vlan(bat_priv, vlan);
 699                 batadv_softif_vlan_free_ref(vlan);
 700         }
 701
 702         batadv_sysfs_del_meshif(soft_iface);
 703         unregister_netdev(soft_iface);
 704 }
 705
 706 /**
 707  * batadv_softif_init_late - late stage initialization of soft interface
 708  * @dev: registered network device to modify
 709  *
 710  * Returns error code on failures
 711  */
 712 static int batadv_softif_init_late(struct net_device *dev)
 713 {
 714         struct batadv_priv *bat_priv;
 715         uint32_t random_seqno;
 716         int ret;
 717         size_t cnt_len = sizeof(uint64_t) * BATADV_CNT_NUM;
 718
 719         batadv_set_lockdep_class(dev);
 720
 721         bat_priv = netdev_priv(dev);
 722         bat_priv->soft_iface = dev;
 723         INIT_WORK(&bat_priv->cleanup_work, batadv_softif_destroy_finish);
 724
 725         /* batadv_interface_stats() needs to be available as soon as
 726          * register_netdevice() has been called
 727          */
 728         bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(uint64_t));
 729         if (!bat_priv->bat_counters)
 730                 return -ENOMEM;
 731
 732         atomic_set(&bat_priv->aggregated_ogms, 1);
 733         atomic_set(&bat_priv->bonding, 0);
 734 #ifdef CONFIG_BATMAN_ADV_BLA
 735         atomic_set(&bat_priv->bridge_loop_avoidance, 0);
 736 #endif
 737 #ifdef CONFIG_BATMAN_ADV_DAT
 738         atomic_set(&bat_priv->distributed_arp_table, 1);
 739 #endif
 740 #ifdef CONFIG_BATMAN_ADV_MCAST
 741         bat_priv->mcast.flags = BATADV_NO_FLAGS;
 742         atomic_set(&bat_priv->multicast_mode, 1);
 743         atomic_set(&bat_priv->mcast.num_disabled, 0);
 744         atomic_set(&bat_priv->mcast.num_want_all_unsnoopables, 0);
 745         atomic_set(&bat_priv->mcast.num_want_all_ipv4, 0);
 746         atomic_set(&bat_priv->mcast.num_want_all_ipv6, 0);
 747 #endif
 748         atomic_set(&bat_priv->gw_mode, BATADV_GW_MODE_OFF);
 749         atomic_set(&bat_priv->gw_sel_class, 20);
 750         atomic_set(&bat_priv->gw.bandwidth_down, 100);
 751         atomic_set(&bat_priv->gw.bandwidth_up, 20);
 752         atomic_set(&bat_priv->orig_interval, 1000);
 753         atomic_set(&bat_priv->hop_penalty, 30);
 754 #ifdef CONFIG_BATMAN_ADV_DEBUG
 755         atomic_set(&bat_priv->log_level, 0);
 756 #endif
 757         atomic_set(&bat_priv->fragmentation, 1);
 758         atomic_set(&bat_priv->packet_size_max, ETH_DATA_LEN);
 759         atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN);
 760         atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN);
 761
 762         atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
 763         atomic_set(&bat_priv->bcast_seqno, 1);
 764         atomic_set(&bat_priv->tt.vn, 0);
 765         atomic_set(&bat_priv->tt.local_changes, 0);
 766         atomic_set(&bat_priv->tt.ogm_append_cnt, 0);
 767 #ifdef CONFIG_BATMAN_ADV_BLA
 768         atomic_set(&bat_priv->bla.num_requests, 0);
 769 #endif
 770         bat_priv->tt.last_changeset = NULL;
 771         bat_priv->tt.last_changeset_len = 0;
 772         bat_priv->isolation_mark = 0;
 773         bat_priv->isolation_mark_mask = 0;
 774
 775         /* randomize initial seqno to avoid collision */
 776         get_random_bytes(&random_seqno, sizeof(random_seqno));
 777         atomic_set(&bat_priv->frag_seqno, random_seqno);
 778
 779         bat_priv->primary_if = NULL;
 780         bat_priv->num_ifaces = 0;
 781
 782         batadv_nc_init_bat_priv(bat_priv);
 783
 784         ret = batadv_algo_select(bat_priv, batadv_routing_algo);
 785         if (ret < 0)
 786                 goto free_bat_counters;
 787
 788         ret = batadv_debugfs_add_meshif(dev);
 789         if (ret < 0)
 790                 goto free_bat_counters;
 791
 792         ret = batadv_mesh_init(dev);
 793         if (ret < 0)
 794                 goto unreg_debugfs;
 795
 796         return 0;
 797
 798 unreg_debugfs:
 799         batadv_debugfs_del_meshif(dev);
 800 free_bat_counters:
 801         free_percpu(bat_priv->bat_counters);
 802         bat_priv->bat_counters = NULL;
 803
 804         return ret;
 805 }
 806
 807 /**
 808  * batadv_softif_slave_add - Add a slave interface to a batadv_soft_interface
 809  * @dev: batadv_soft_interface used as master interface
 810  * @slave_dev: net_device which should become the slave interface
 811  *
 812  * Return 0 if successful or error otherwise.
 813  */
 814 static int batadv_softif_slave_add(struct net_device *dev,
 815                                    struct net_device *slave_dev)
 816 {
 817         struct batadv_hard_iface *hard_iface;
 818         int ret = -EINVAL;
 819
 820         hard_iface = batadv_hardif_get_by_netdev(slave_dev);
 821         if (!hard_iface || hard_iface->soft_iface != NULL)
 822                 goto out;
 823
 824         ret = batadv_hardif_enable_interface(hard_iface, dev->name);
 825
 826 out:
 827         if (hard_iface)
 828                 batadv_hardif_free_ref(hard_iface);
 829         return ret;
 830 }
 831
 832 /**
 833  * batadv_softif_slave_del - Delete a slave iface from a batadv_soft_interface
 834  * @dev: batadv_soft_interface used as master interface
 835  * @slave_dev: net_device which should be removed from the master interface
 836  *
 837  * Return 0 if successful or error otherwise.
 838  */
 839 static int batadv_softif_slave_del(struct net_device *dev,
 840                                    struct net_device *slave_dev)
 841 {
 842         struct batadv_hard_iface *hard_iface;
 843         int ret = -EINVAL;
 844
 845         hard_iface = batadv_hardif_get_by_netdev(slave_dev);
 846
 847         if (!hard_iface || hard_iface->soft_iface != dev)
 848                 goto out;
 849
 850         batadv_hardif_disable_interface(hard_iface, BATADV_IF_CLEANUP_KEEP);
 851         ret = 0;
 852
 853 out:
 854         if (hard_iface)
 855                 batadv_hardif_free_ref(hard_iface);
 856         return ret;
 857 }
 858
 859 static const struct net_device_ops batadv_netdev_ops = {
 860         .ndo_init = batadv_softif_init_late,
 861         .ndo_open = batadv_interface_open,
 862         .ndo_stop = batadv_interface_release,
 863         .ndo_get_stats = batadv_interface_stats,
 864         .ndo_vlan_rx_add_vid = batadv_interface_add_vid,
 865         .ndo_vlan_rx_kill_vid = batadv_interface_kill_vid,
 866         .ndo_set_mac_address = batadv_interface_set_mac_addr,
 867         .ndo_change_mtu = batadv_interface_change_mtu,
 868         .ndo_set_rx_mode = batadv_interface_set_rx_mode,
 869         .ndo_start_xmit = batadv_interface_tx,
 870         .ndo_validate_addr = eth_validate_addr,
 871         .ndo_add_slave = batadv_softif_slave_add,
 872         .ndo_del_slave = batadv_softif_slave_del,
 873 };
 874
 875 /**
 876  * batadv_softif_free - Deconstructor of batadv_soft_interface
 877  * @dev: Device to cleanup and remove
 878  */
 879 static void batadv_softif_free(struct net_device *dev)
 880 {
 881         batadv_debugfs_del_meshif(dev);
 882         batadv_mesh_free(dev);
 883
 884         /* some scheduled RCU callbacks need the bat_priv struct to accomplish
 885          * their tasks. Wait for them all to be finished before freeing the
 886          * netdev and its private data (bat_priv)
 887          */
 888         rcu_barrier();
 889
 890         free_netdev(dev);
 891 }
 892
 893 /**
 894  * batadv_softif_init_early - early stage initialization of soft interface
 895  * @dev: registered network device to modify
 896  */
 897 static void batadv_softif_init_early(struct net_device *dev)
 898 {
 899         struct batadv_priv *priv = netdev_priv(dev);
 900
 901         ether_setup(dev);
 902
 903         dev->netdev_ops = &batadv_netdev_ops;
 904         dev->destructor = batadv_softif_free;
 905         dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 906         dev->tx_queue_len = 0;
 907
 908         /* can't call min_mtu, because the needed variables
 909          * have not been initialized yet
 910          */
 911         dev->mtu = ETH_DATA_LEN;
 912         /* reserve more space in the skbuff for our header */
 913         dev->hard_header_len = batadv_max_header_len();
 914
 915         /* generate random address */
 916         eth_hw_addr_random(dev);
 917
 918         dev->ethtool_ops = &batadv_ethtool_ops;
 919
 920         memset(priv, 0, sizeof(*priv));
 921 }
 922
 923 struct net_device *batadv_softif_create(const char *name)
 924 {
 925         struct net_device *soft_iface;
 926         int ret;
 927
 928         soft_iface = alloc_netdev(sizeof(struct batadv_priv), name,
 929                                   NET_NAME_UNKNOWN, batadv_softif_init_early);
 930         if (!soft_iface)
 931                 return NULL;
 932
 933         soft_iface->rtnl_link_ops = &batadv_link_ops;
 934
 935         ret = register_netdevice(soft_iface);
 936         if (ret < 0) {
 937                 pr_err("Unable to register the batman interface '%s': %i\n",
 938                        name, ret);
 939                 free_netdev(soft_iface);
 940                 return NULL;
 941         }
 942
 943         return soft_iface;
 944 }
 945
 946 /**
 947  * batadv_softif_destroy_sysfs - deletion of batadv_soft_interface via sysfs
 948  * @soft_iface: the to-be-removed batman-adv interface
 949  */
 950 void batadv_softif_destroy_sysfs(struct net_device *soft_iface)
 951 {
 952         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 953
 954         queue_work(batadv_event_workqueue, &bat_priv->cleanup_work);
 955 }
 956
 957 /**
 958  * batadv_softif_destroy_netlink - deletion of batadv_soft_interface via netlink
 959  * @soft_iface: the to-be-removed batman-adv interface
 960  * @head: list pointer
 961  */
 962 static void batadv_softif_destroy_netlink(struct net_device *soft_iface,
 963                                           struct list_head *head)
 964 {
 965         struct batadv_hard_iface *hard_iface;
 966
 967         list_for_each_entry(hard_iface, &batadv_hardif_list, list) {
 968                 if (hard_iface->soft_iface == soft_iface)
 969                         batadv_hardif_disable_interface(hard_iface,
 970                                                         BATADV_IF_CLEANUP_KEEP);
 971         }
 972
 973         batadv_sysfs_del_meshif(soft_iface);
 974         unregister_netdevice_queue(soft_iface, head);
 975 }
 976
 977 int batadv_softif_is_valid(const struct net_device *net_dev)
 978 {
 979         if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)
 980                 return 1;
 981
 982         return 0;
 983 }
 984
 985 struct rtnl_link_ops batadv_link_ops __read_mostly = {
 986         .kind           = "batadv",
 987         .priv_size      = sizeof(struct batadv_priv),
 988         .setup          = batadv_softif_init_early,
 989         .dellink        = batadv_softif_destroy_netlink,
 990 };
 991
 992 /* ethtool */
 993 static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 994 {
 995         cmd->supported = 0;
 996         cmd->advertising = 0;
 997         ethtool_cmd_speed_set(cmd, SPEED_10);
 998         cmd->duplex = DUPLEX_FULL;
 999         cmd->port = PORT_TP;
1000         cmd->phy_address = 0;
1001         cmd->transceiver = XCVR_INTERNAL;
1002         cmd->autoneg = AUTONEG_DISABLE;
1003         cmd->maxtxpkt = 0;
1004         cmd->maxrxpkt = 0;
1005
1006         return 0;
1007 }
1008
1009 static void batadv_get_drvinfo(struct net_device *dev,
1010                                struct ethtool_drvinfo *info)
1011 {
1012         strlcpy(info->driver, "B.A.T.M.A.N. advanced", sizeof(info->driver));
1013         strlcpy(info->version, BATADV_SOURCE_VERSION, sizeof(info->version));
1014         strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
1015         strlcpy(info->bus_info, "batman", sizeof(info->bus_info));
1016 }
1017
1018 static u32 batadv_get_msglevel(struct net_device *dev)
1019 {
1020         return -EOPNOTSUPP;
1021 }
1022
1023 static void batadv_set_msglevel(struct net_device *dev, u32 value)
1024 {
1025 }
1026
1027 static u32 batadv_get_link(struct net_device *dev)
1028 {
1029         return 1;
1030 }
1031
1032 /* Inspired by drivers/net/ethernet/dlink/sundance.c:1702
1033  * Declare each description string in struct.name[] to get fixed sized buffer
1034  * and compile time checking for strings longer than ETH_GSTRING_LEN.
1035  */
1036 static const struct {
1037         const char name[ETH_GSTRING_LEN];
1038 } batadv_counters_strings[] = {
1039         { "tx" },
1040         { "tx_bytes" },
1041         { "tx_dropped" },
1042         { "rx" },
1043         { "rx_bytes" },
1044         { "forward" },
1045         { "forward_bytes" },
1046         { "mgmt_tx" },
1047         { "mgmt_tx_bytes" },
1048         { "mgmt_rx" },
1049         { "mgmt_rx_bytes" },
1050         { "frag_tx" },
1051         { "frag_tx_bytes" },
1052         { "frag_rx" },
1053         { "frag_rx_bytes" },
1054         { "frag_fwd" },
1055         { "frag_fwd_bytes" },
1056         { "tt_request_tx" },
1057         { "tt_request_rx" },
1058         { "tt_response_tx" },
1059         { "tt_response_rx" },
1060         { "tt_roam_adv_tx" },
1061         { "tt_roam_adv_rx" },
1062 #ifdef CONFIG_BATMAN_ADV_DAT
1063         { "dat_get_tx" },
1064         { "dat_get_rx" },
1065         { "dat_put_tx" },
1066         { "dat_put_rx" },
1067         { "dat_cached_reply_tx" },
1068 #endif
1069 #ifdef CONFIG_BATMAN_ADV_NC
1070         { "nc_code" },
1071         { "nc_code_bytes" },
1072         { "nc_recode" },
1073         { "nc_recode_bytes" },
1074         { "nc_buffer" },
1075         { "nc_decode" },
1076         { "nc_decode_bytes" },
1077         { "nc_decode_failed" },
1078         { "nc_sniffed" },
1079 #endif
1080 };
1081
1082 static void batadv_get_strings(struct net_device *dev, uint32_t stringset,
1083                                uint8_t *data)
1084 {
1085         if (stringset == ETH_SS_STATS)
1086                 memcpy(data, batadv_counters_strings,
1087                        sizeof(batadv_counters_strings));
1088 }
1089
1090 static void batadv_get_ethtool_stats(struct net_device *dev,
1091                                      struct ethtool_stats *stats,
1092                                      uint64_t *data)
1093 {
1094         struct batadv_priv *bat_priv = netdev_priv(dev);
1095         int i;
1096
1097         for (i = 0; i < BATADV_CNT_NUM; i++)
1098                 data[i] = batadv_sum_counter(bat_priv, i);
1099 }
1100
1101 static int batadv_get_sset_count(struct net_device *dev, int stringset)
1102 {
1103         if (stringset == ETH_SS_STATS)
1104                 return BATADV_CNT_NUM;
1105
1106         return -EOPNOTSUPP;
1107 }