net/batman-adv/bridge_loop_avoidance.c

   1 /* Copyright (C) 2011-2016  B.A.T.M.A.N. contributors:
   2  *
   3  * 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 "bridge_loop_avoidance.h"
  19 #include "main.h"
  20
  21 #include <linux/atomic.h>
  22 #include <linux/byteorder/generic.h>
  23 #include <linux/compiler.h>
  24 #include <linux/crc16.h>
  25 #include <linux/errno.h>
  26 #include <linux/etherdevice.h>
  27 #include <linux/fs.h>
  28 #include <linux/if_arp.h>
  29 #include <linux/if_ether.h>
  30 #include <linux/if_vlan.h>
  31 #include <linux/jhash.h>
  32 #include <linux/jiffies.h>
  33 #include <linux/kernel.h>
  34 #include <linux/kref.h>
  35 #include <linux/list.h>
  36 #include <linux/lockdep.h>
  37 #include <linux/netdevice.h>
  38 #include <linux/rculist.h>
  39 #include <linux/rcupdate.h>
  40 #include <linux/seq_file.h>
  41 #include <linux/skbuff.h>
  42 #include <linux/slab.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/stddef.h>
  45 #include <linux/string.h>
  46 #include <linux/workqueue.h>
  47 #include <net/arp.h>
  48
  49 #include "hard-interface.h"
  50 #include "hash.h"
  51 #include "originator.h"
  52 #include "packet.h"
  53 #include "translation-table.h"
  54
  55 static const u8 batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05};
  56
  57 static void batadv_bla_periodic_work(struct work_struct *work);
  58 static void
  59 batadv_bla_send_announce(struct batadv_priv *bat_priv,
  60                          struct batadv_bla_backbone_gw *backbone_gw);
  61
  62 /**
  63  * batadv_choose_claim - choose the right bucket for a claim.
  64  * @data: data to hash
  65  * @size: size of the hash table
  66  *
  67  * Return: the hash index of the claim
  68  */
  69 static inline u32 batadv_choose_claim(const void *data, u32 size)
  70 {
  71         struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
  72         u32 hash = 0;
  73
  74         hash = jhash(&claim->addr, sizeof(claim->addr), hash);
  75         hash = jhash(&claim->vid, sizeof(claim->vid), hash);
  76
  77         return hash % size;
  78 }
  79
  80 /**
  81  * batadv_choose_backbone_gw - choose the right bucket for a backbone gateway.
  82  * @data: data to hash
  83  * @size: size of the hash table
  84  *
  85  * Return: the hash index of the backbone gateway
  86  */
  87 static inline u32 batadv_choose_backbone_gw(const void *data, u32 size)
  88 {
  89         const struct batadv_bla_claim *claim = (struct batadv_bla_claim *)data;
  90         u32 hash = 0;
  91
  92         hash = jhash(&claim->addr, sizeof(claim->addr), hash);
  93         hash = jhash(&claim->vid, sizeof(claim->vid), hash);
  94
  95         return hash % size;
  96 }
  97
  98 /**
  99  * batadv_compare_backbone_gw - compare address and vid of two backbone gws
 100  * @node: list node of the first entry to compare
 101  * @data2: pointer to the second backbone gateway
 102  *
 103  * Return: 1 if the backbones have the same data, 0 otherwise
 104  */
 105 static int batadv_compare_backbone_gw(const struct hlist_node *node,
 106                                       const void *data2)
 107 {
 108         const void *data1 = container_of(node, struct batadv_bla_backbone_gw,
 109                                          hash_entry);
 110         const struct batadv_bla_backbone_gw *gw1 = data1;
 111         const struct batadv_bla_backbone_gw *gw2 = data2;
 112
 113         if (!batadv_compare_eth(gw1->orig, gw2->orig))
 114                 return 0;
 115
 116         if (gw1->vid != gw2->vid)
 117                 return 0;
 118
 119         return 1;
 120 }
 121
 122 /**
 123  * batadv_compare_backbone_gw - compare address and vid of two claims
 124  * @node: list node of the first entry to compare
 125  * @data2: pointer to the second claims
 126  *
 127  * Return: 1 if the claim have the same data, 0 otherwise
 128  */
 129 static int batadv_compare_claim(const struct hlist_node *node,
 130                                 const void *data2)
 131 {
 132         const void *data1 = container_of(node, struct batadv_bla_claim,
 133                                          hash_entry);
 134         const struct batadv_bla_claim *cl1 = data1;
 135         const struct batadv_bla_claim *cl2 = data2;
 136
 137         if (!batadv_compare_eth(cl1->addr, cl2->addr))
 138                 return 0;
 139
 140         if (cl1->vid != cl2->vid)
 141                 return 0;
 142
 143         return 1;
 144 }
 145
 146 /**
 147  * batadv_backbone_gw_release - release backbone gw from lists and queue for
 148  *  free after rcu grace period
 149  * @ref: kref pointer of the backbone gw
 150  */
 151 static void batadv_backbone_gw_release(struct kref *ref)
 152 {
 153         struct batadv_bla_backbone_gw *backbone_gw;
 154
 155         backbone_gw = container_of(ref, struct batadv_bla_backbone_gw,
 156                                    refcount);
 157
 158         kfree_rcu(backbone_gw, rcu);
 159 }
 160
 161 /**
 162  * batadv_backbone_gw_free_ref - decrement the backbone gw refcounter and
 163  *  possibly release it
 164  * @backbone_gw: backbone gateway to be free'd
 165  */
 166 static void
 167 batadv_backbone_gw_free_ref(struct batadv_bla_backbone_gw *backbone_gw)
 168 {
 169         kref_put(&backbone_gw->refcount, batadv_backbone_gw_release);
 170 }
 171
 172 /**
 173  * batadv_claim_release - release claim from lists and queue for free after rcu
 174  *  grace period
 175  * @ref: kref pointer of the claim
 176  */
 177 static void batadv_claim_release(struct batadv_bla_claim *claim)
 178 {
 179         batadv_backbone_gw_free_ref(claim->backbone_gw);
 180         kfree_rcu(claim, rcu);
 181 }
 182
 183 /**
 184  * batadv_claim_free_ref - decrement the claim refcounter and possibly
 185  *  release it
 186  * @claim: claim to be free'd
 187  */
 188 static void batadv_claim_free_ref(struct batadv_bla_claim *claim)
 189 {
 190         if (atomic_dec_and_test(&claim->refcount))
 191                 batadv_claim_release(claim);
 192 }
 193
 194 /**
 195  * batadv_claim_hash_find - looks for a claim in the claim hash
 196  * @bat_priv: the bat priv with all the soft interface information
 197  * @data: search data (may be local/static data)
 198  *
 199  * Return: claim if found or NULL otherwise.
 200  */
 201 static struct batadv_bla_claim
 202 *batadv_claim_hash_find(struct batadv_priv *bat_priv,
 203                         struct batadv_bla_claim *data)
 204 {
 205         struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
 206         struct hlist_head *head;
 207         struct batadv_bla_claim *claim;
 208         struct batadv_bla_claim *claim_tmp = NULL;
 209         int index;
 210
 211         if (!hash)
 212                 return NULL;
 213
 214         index = batadv_choose_claim(data, hash->size);
 215         head = &hash->table[index];
 216
 217         rcu_read_lock();
 218         hlist_for_each_entry_rcu(claim, head, hash_entry) {
 219                 if (!batadv_compare_claim(&claim->hash_entry, data))
 220                         continue;
 221
 222                 if (!atomic_inc_not_zero(&claim->refcount))
 223                         continue;
 224
 225                 claim_tmp = claim;
 226                 break;
 227         }
 228         rcu_read_unlock();
 229
 230         return claim_tmp;
 231 }
 232
 233 /**
 234  * batadv_backbone_hash_find - looks for a backbone gateway in the hash
 235  * @bat_priv: the bat priv with all the soft interface information
 236  * @addr: the address of the originator
 237  * @vid: the VLAN ID
 238  *
 239  * Return: backbone gateway if found or NULL otherwise
 240  */
 241 static struct batadv_bla_backbone_gw *
 242 batadv_backbone_hash_find(struct batadv_priv *bat_priv, u8 *addr,
 243                           unsigned short vid)
 244 {
 245         struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
 246         struct hlist_head *head;
 247         struct batadv_bla_backbone_gw search_entry, *backbone_gw;
 248         struct batadv_bla_backbone_gw *backbone_gw_tmp = NULL;
 249         int index;
 250
 251         if (!hash)
 252                 return NULL;
 253
 254         ether_addr_copy(search_entry.orig, addr);
 255         search_entry.vid = vid;
 256
 257         index = batadv_choose_backbone_gw(&search_entry, hash->size);
 258         head = &hash->table[index];
 259
 260         rcu_read_lock();
 261         hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
 262                 if (!batadv_compare_backbone_gw(&backbone_gw->hash_entry,
 263                                                 &search_entry))
 264                         continue;
 265
 266                 if (!kref_get_unless_zero(&backbone_gw->refcount))
 267                         continue;
 268
 269                 backbone_gw_tmp = backbone_gw;
 270                 break;
 271         }
 272         rcu_read_unlock();
 273
 274         return backbone_gw_tmp;
 275 }
 276
 277 /**
 278  * batadv_bla_del_backbone_claims - delete all claims for a backbone
 279  * @backbone_gw: backbone gateway where the claims should be removed
 280  */
 281 static void
 282 batadv_bla_del_backbone_claims(struct batadv_bla_backbone_gw *backbone_gw)
 283 {
 284         struct batadv_hashtable *hash;
 285         struct hlist_node *node_tmp;
 286         struct hlist_head *head;
 287         struct batadv_bla_claim *claim;
 288         int i;
 289         spinlock_t *list_lock;  /* protects write access to the hash lists */
 290
 291         hash = backbone_gw->bat_priv->bla.claim_hash;
 292         if (!hash)
 293                 return;
 294
 295         for (i = 0; i < hash->size; i++) {
 296                 head = &hash->table[i];
 297                 list_lock = &hash->list_locks[i];
 298
 299                 spin_lock_bh(list_lock);
 300                 hlist_for_each_entry_safe(claim, node_tmp,
 301                                           head, hash_entry) {
 302                         if (claim->backbone_gw != backbone_gw)
 303                                 continue;
 304
 305                         batadv_claim_free_ref(claim);
 306                         hlist_del_rcu(&claim->hash_entry);
 307                 }
 308                 spin_unlock_bh(list_lock);
 309         }
 310
 311         /* all claims gone, initialize CRC */
 312         spin_lock_bh(&backbone_gw->crc_lock);
 313         backbone_gw->crc = BATADV_BLA_CRC_INIT;
 314         spin_unlock_bh(&backbone_gw->crc_lock);
 315 }
 316
 317 /**
 318  * batadv_bla_send_claim - sends a claim frame according to the provided info
 319  * @bat_priv: the bat priv with all the soft interface information
 320  * @mac: the mac address to be announced within the claim
 321  * @vid: the VLAN ID
 322  * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...)
 323  */
 324 static void batadv_bla_send_claim(struct batadv_priv *bat_priv, u8 *mac,
 325                                   unsigned short vid, int claimtype)
 326 {
 327         struct sk_buff *skb;
 328         struct ethhdr *ethhdr;
 329         struct batadv_hard_iface *primary_if;
 330         struct net_device *soft_iface;
 331         u8 *hw_src;
 332         struct batadv_bla_claim_dst local_claim_dest;
 333         __be32 zeroip = 0;
 334
 335         primary_if = batadv_primary_if_get_selected(bat_priv);
 336         if (!primary_if)
 337                 return;
 338
 339         memcpy(&local_claim_dest, &bat_priv->bla.claim_dest,
 340                sizeof(local_claim_dest));
 341         local_claim_dest.type = claimtype;
 342
 343         soft_iface = primary_if->soft_iface;
 344
 345         skb = arp_create(ARPOP_REPLY, ETH_P_ARP,
 346                          /* IP DST: 0.0.0.0 */
 347                          zeroip,
 348                          primary_if->soft_iface,
 349                          /* IP SRC: 0.0.0.0 */
 350                          zeroip,
 351                          /* Ethernet DST: Broadcast */
 352                          NULL,
 353                          /* Ethernet SRC/HW SRC:  originator mac */
 354                          primary_if->net_dev->dev_addr,
 355                          /* HW DST: FF:43:05:XX:YY:YY
 356                           * with XX   = claim type
 357                           * and YY:YY = group id
 358                           */
 359                          (u8 *)&local_claim_dest);
 360
 361         if (!skb)
 362                 goto out;
 363
 364         ethhdr = (struct ethhdr *)skb->data;
 365         hw_src = (u8 *)ethhdr + ETH_HLEN + sizeof(struct arphdr);
 366
 367         /* now we pretend that the client would have sent this ... */
 368         switch (claimtype) {
 369         case BATADV_CLAIM_TYPE_CLAIM:
 370                 /* normal claim frame
 371                  * set Ethernet SRC to the clients mac
 372                  */
 373                 ether_addr_copy(ethhdr->h_source, mac);
 374                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 375                            "bla_send_claim(): CLAIM %pM on vid %d\n", mac,
 376                            BATADV_PRINT_VID(vid));
 377                 break;
 378         case BATADV_CLAIM_TYPE_UNCLAIM:
 379                 /* unclaim frame
 380                  * set HW SRC to the clients mac
 381                  */
 382                 ether_addr_copy(hw_src, mac);
 383                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 384                            "bla_send_claim(): UNCLAIM %pM on vid %d\n", mac,
 385                            BATADV_PRINT_VID(vid));
 386                 break;
 387         case BATADV_CLAIM_TYPE_ANNOUNCE:
 388                 /* announcement frame
 389                  * set HW SRC to the special mac containg the crc
 390                  */
 391                 ether_addr_copy(hw_src, mac);
 392                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 393                            "bla_send_claim(): ANNOUNCE of %pM on vid %d\n",
 394                            ethhdr->h_source, BATADV_PRINT_VID(vid));
 395                 break;
 396         case BATADV_CLAIM_TYPE_REQUEST:
 397                 /* request frame
 398                  * set HW SRC and header destination to the receiving backbone
 399                  * gws mac
 400                  */
 401                 ether_addr_copy(hw_src, mac);
 402                 ether_addr_copy(ethhdr->h_dest, mac);
 403                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 404                            "bla_send_claim(): REQUEST of %pM to %pM on vid %d\n",
 405                            ethhdr->h_source, ethhdr->h_dest,
 406                            BATADV_PRINT_VID(vid));
 407                 break;
 408         }
 409
 410         if (vid & BATADV_VLAN_HAS_TAG)
 411                 skb = vlan_insert_tag(skb, htons(ETH_P_8021Q),
 412                                       vid & VLAN_VID_MASK);
 413
 414         skb_reset_mac_header(skb);
 415         skb->protocol = eth_type_trans(skb, soft_iface);
 416         batadv_inc_counter(bat_priv, BATADV_CNT_RX);
 417         batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
 418                            skb->len + ETH_HLEN);
 419         soft_iface->last_rx = jiffies;
 420
 421         netif_rx(skb);
 422 out:
 423         if (primary_if)
 424                 batadv_hardif_free_ref(primary_if);
 425 }
 426
 427 /**
 428  * batadv_bla_get_backbone_gw - finds or creates a backbone gateway
 429  * @bat_priv: the bat priv with all the soft interface information
 430  * @orig: the mac address of the originator
 431  * @vid: the VLAN ID
 432  * @own_backbone: set if the requested backbone is local
 433  *
 434  * Return: the (possibly created) backbone gateway or NULL on error
 435  */
 436 static struct batadv_bla_backbone_gw *
 437 batadv_bla_get_backbone_gw(struct batadv_priv *bat_priv, u8 *orig,
 438                            unsigned short vid, bool own_backbone)
 439 {
 440         struct batadv_bla_backbone_gw *entry;
 441         struct batadv_orig_node *orig_node;
 442         int hash_added;
 443
 444         entry = batadv_backbone_hash_find(bat_priv, orig, vid);
 445
 446         if (entry)
 447                 return entry;
 448
 449         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 450                    "bla_get_backbone_gw(): not found (%pM, %d), creating new entry\n",
 451                    orig, BATADV_PRINT_VID(vid));
 452
 453         entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
 454         if (!entry)
 455                 return NULL;
 456
 457         entry->vid = vid;
 458         entry->lasttime = jiffies;
 459         entry->crc = BATADV_BLA_CRC_INIT;
 460         entry->bat_priv = bat_priv;
 461         spin_lock_init(&entry->crc_lock);
 462         atomic_set(&entry->request_sent, 0);
 463         atomic_set(&entry->wait_periods, 0);
 464         ether_addr_copy(entry->orig, orig);
 465
 466         /* one for the hash, one for returning */
 467         kref_init(&entry->refcount);
 468         kref_get(&entry->refcount);
 469
 470         hash_added = batadv_hash_add(bat_priv->bla.backbone_hash,
 471                                      batadv_compare_backbone_gw,
 472                                      batadv_choose_backbone_gw, entry,
 473                                      &entry->hash_entry);
 474
 475         if (unlikely(hash_added != 0)) {
 476                 /* hash failed, free the structure */
 477                 kfree(entry);
 478                 return NULL;
 479         }
 480
 481         /* this is a gateway now, remove any TT entry on this VLAN */
 482         orig_node = batadv_orig_hash_find(bat_priv, orig);
 483         if (orig_node) {
 484                 batadv_tt_global_del_orig(bat_priv, orig_node, vid,
 485                                           "became a backbone gateway");
 486                 batadv_orig_node_free_ref(orig_node);
 487         }
 488
 489         if (own_backbone) {
 490                 batadv_bla_send_announce(bat_priv, entry);
 491
 492                 /* this will be decreased in the worker thread */
 493                 atomic_inc(&entry->request_sent);
 494                 atomic_set(&entry->wait_periods, BATADV_BLA_WAIT_PERIODS);
 495                 atomic_inc(&bat_priv->bla.num_requests);
 496         }
 497
 498         return entry;
 499 }
 500
 501 /**
 502  * batadv_bla_update_own_backbone_gw - updates the own backbone gw for a VLAN
 503  * @bat_priv: the bat priv with all the soft interface information
 504  * @primary_if: the selected primary interface
 505  * @vid: VLAN identifier
 506  *
 507  * update or add the own backbone gw to make sure we announce
 508  * where we receive other backbone gws
 509  */
 510 static void
 511 batadv_bla_update_own_backbone_gw(struct batadv_priv *bat_priv,
 512                                   struct batadv_hard_iface *primary_if,
 513                                   unsigned short vid)
 514 {
 515         struct batadv_bla_backbone_gw *backbone_gw;
 516
 517         backbone_gw = batadv_bla_get_backbone_gw(bat_priv,
 518                                                  primary_if->net_dev->dev_addr,
 519                                                  vid, true);
 520         if (unlikely(!backbone_gw))
 521                 return;
 522
 523         backbone_gw->lasttime = jiffies;
 524         batadv_backbone_gw_free_ref(backbone_gw);
 525 }
 526
 527 /**
 528  * batadv_bla_answer_request - answer a bla request by sending own claims
 529  * @bat_priv: the bat priv with all the soft interface information
 530  * @primary_if: interface where the request came on
 531  * @vid: the vid where the request came on
 532  *
 533  * Repeat all of our own claims, and finally send an ANNOUNCE frame
 534  * to allow the requester another check if the CRC is correct now.
 535  */
 536 static void batadv_bla_answer_request(struct batadv_priv *bat_priv,
 537                                       struct batadv_hard_iface *primary_if,
 538                                       unsigned short vid)
 539 {
 540         struct hlist_head *head;
 541         struct batadv_hashtable *hash;
 542         struct batadv_bla_claim *claim;
 543         struct batadv_bla_backbone_gw *backbone_gw;
 544         int i;
 545
 546         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 547                    "bla_answer_request(): received a claim request, send all of our own claims again\n");
 548
 549         backbone_gw = batadv_backbone_hash_find(bat_priv,
 550                                                 primary_if->net_dev->dev_addr,
 551                                                 vid);
 552         if (!backbone_gw)
 553                 return;
 554
 555         hash = bat_priv->bla.claim_hash;
 556         for (i = 0; i < hash->size; i++) {
 557                 head = &hash->table[i];
 558
 559                 rcu_read_lock();
 560                 hlist_for_each_entry_rcu(claim, head, hash_entry) {
 561                         /* only own claims are interesting */
 562                         if (claim->backbone_gw != backbone_gw)
 563                                 continue;
 564
 565                         batadv_bla_send_claim(bat_priv, claim->addr, claim->vid,
 566                                               BATADV_CLAIM_TYPE_CLAIM);
 567                 }
 568                 rcu_read_unlock();
 569         }
 570
 571         /* finally, send an announcement frame */
 572         batadv_bla_send_announce(bat_priv, backbone_gw);
 573         batadv_backbone_gw_free_ref(backbone_gw);
 574 }
 575
 576 /**
 577  * batadv_bla_send_request - send a request to repeat claims
 578  * @backbone_gw: the backbone gateway from whom we are out of sync
 579  *
 580  * When the crc is wrong, ask the backbone gateway for a full table update.
 581  * After the request, it will repeat all of his own claims and finally
 582  * send an announcement claim with which we can check again.
 583  */
 584 static void batadv_bla_send_request(struct batadv_bla_backbone_gw *backbone_gw)
 585 {
 586         /* first, remove all old entries */
 587         batadv_bla_del_backbone_claims(backbone_gw);
 588
 589         batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
 590                    "Sending REQUEST to %pM\n", backbone_gw->orig);
 591
 592         /* send request */
 593         batadv_bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
 594                               backbone_gw->vid, BATADV_CLAIM_TYPE_REQUEST);
 595
 596         /* no local broadcasts should be sent or received, for now. */
 597         if (!atomic_read(&backbone_gw->request_sent)) {
 598                 atomic_inc(&backbone_gw->bat_priv->bla.num_requests);
 599                 atomic_set(&backbone_gw->request_sent, 1);
 600         }
 601 }
 602
 603 /**
 604  * batadv_bla_send_announce - Send an announcement frame
 605  * @bat_priv: the bat priv with all the soft interface information
 606  * @backbone_gw: our backbone gateway which should be announced
 607  */
 608 static void batadv_bla_send_announce(struct batadv_priv *bat_priv,
 609                                      struct batadv_bla_backbone_gw *backbone_gw)
 610 {
 611         u8 mac[ETH_ALEN];
 612         __be16 crc;
 613
 614         memcpy(mac, batadv_announce_mac, 4);
 615         spin_lock_bh(&backbone_gw->crc_lock);
 616         crc = htons(backbone_gw->crc);
 617         spin_unlock_bh(&backbone_gw->crc_lock);
 618         memcpy(&mac[4], &crc, 2);
 619
 620         batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid,
 621                               BATADV_CLAIM_TYPE_ANNOUNCE);
 622 }
 623
 624 /**
 625  * batadv_bla_add_claim - Adds a claim in the claim hash
 626  * @bat_priv: the bat priv with all the soft interface information
 627  * @mac: the mac address of the claim
 628  * @vid: the VLAN ID of the frame
 629  * @backbone_gw: the backbone gateway which claims it
 630  */
 631 static void batadv_bla_add_claim(struct batadv_priv *bat_priv,
 632                                  const u8 *mac, const unsigned short vid,
 633                                  struct batadv_bla_backbone_gw *backbone_gw)
 634 {
 635         struct batadv_bla_claim *claim;
 636         struct batadv_bla_claim search_claim;
 637         int hash_added;
 638
 639         ether_addr_copy(search_claim.addr, mac);
 640         search_claim.vid = vid;
 641         claim = batadv_claim_hash_find(bat_priv, &search_claim);
 642
 643         /* create a new claim entry if it does not exist yet. */
 644         if (!claim) {
 645                 claim = kzalloc(sizeof(*claim), GFP_ATOMIC);
 646                 if (!claim)
 647                         return;
 648
 649                 ether_addr_copy(claim->addr, mac);
 650                 claim->vid = vid;
 651                 claim->lasttime = jiffies;
 652                 claim->backbone_gw = backbone_gw;
 653
 654                 atomic_set(&claim->refcount, 2);
 655                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 656                            "bla_add_claim(): adding new entry %pM, vid %d to hash ...\n",
 657                            mac, BATADV_PRINT_VID(vid));
 658                 hash_added = batadv_hash_add(bat_priv->bla.claim_hash,
 659                                              batadv_compare_claim,
 660                                              batadv_choose_claim, claim,
 661                                              &claim->hash_entry);
 662
 663                 if (unlikely(hash_added != 0)) {
 664                         /* only local changes happened. */
 665                         kfree(claim);
 666                         return;
 667                 }
 668         } else {
 669                 claim->lasttime = jiffies;
 670                 if (claim->backbone_gw == backbone_gw)
 671                         /* no need to register a new backbone */
 672                         goto claim_free_ref;
 673
 674                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 675                            "bla_add_claim(): changing ownership for %pM, vid %d\n",
 676                            mac, BATADV_PRINT_VID(vid));
 677
 678                 spin_lock_bh(&claim->backbone_gw->crc_lock);
 679                 claim->backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 680                 spin_unlock_bh(&claim->backbone_gw->crc_lock);
 681                 batadv_backbone_gw_free_ref(claim->backbone_gw);
 682         }
 683         /* set (new) backbone gw */
 684         kref_get(&backbone_gw->refcount);
 685         claim->backbone_gw = backbone_gw;
 686
 687         spin_lock_bh(&backbone_gw->crc_lock);
 688         backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 689         spin_unlock_bh(&backbone_gw->crc_lock);
 690         backbone_gw->lasttime = jiffies;
 691
 692 claim_free_ref:
 693         batadv_claim_free_ref(claim);
 694 }
 695
 696 /**
 697  * batadv_bla_del_claim - delete a claim from the claim hash
 698  * @bat_priv: the bat priv with all the soft interface information
 699  * @mac: mac address of the claim to be removed
 700  * @vid: VLAN id for the claim to be removed
 701  */
 702 static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
 703                                  const u8 *mac, const unsigned short vid)
 704 {
 705         struct batadv_bla_claim search_claim, *claim;
 706
 707         ether_addr_copy(search_claim.addr, mac);
 708         search_claim.vid = vid;
 709         claim = batadv_claim_hash_find(bat_priv, &search_claim);
 710         if (!claim)
 711                 return;
 712
 713         batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla_del_claim(): %pM, vid %d\n",
 714                    mac, BATADV_PRINT_VID(vid));
 715
 716         batadv_hash_remove(bat_priv->bla.claim_hash, batadv_compare_claim,
 717                            batadv_choose_claim, claim);
 718         batadv_claim_free_ref(claim); /* reference from the hash is gone */
 719
 720         spin_lock_bh(&claim->backbone_gw->crc_lock);
 721         claim->backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN);
 722         spin_unlock_bh(&claim->backbone_gw->crc_lock);
 723
 724         /* don't need the reference from hash_find() anymore */
 725         batadv_claim_free_ref(claim);
 726 }
 727
 728 /**
 729  * batadv_handle_announce - check for ANNOUNCE frame
 730  * @bat_priv: the bat priv with all the soft interface information
 731  * @an_addr: announcement mac address (ARP Sender HW address)
 732  * @backbone_addr: originator address of the sender (Ethernet source MAC)
 733  * @vid: the VLAN ID of the frame
 734  *
 735  * Return: 1 if handled
 736  */
 737 static int batadv_handle_announce(struct batadv_priv *bat_priv, u8 *an_addr,
 738                                   u8 *backbone_addr, unsigned short vid)
 739 {
 740         struct batadv_bla_backbone_gw *backbone_gw;
 741         u16 backbone_crc, crc;
 742
 743         if (memcmp(an_addr, batadv_announce_mac, 4) != 0)
 744                 return 0;
 745
 746         backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
 747                                                  false);
 748
 749         if (unlikely(!backbone_gw))
 750                 return 1;
 751
 752         /* handle as ANNOUNCE frame */
 753         backbone_gw->lasttime = jiffies;
 754         crc = ntohs(*((__be16 *)(&an_addr[4])));
 755
 756         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 757                    "handle_announce(): ANNOUNCE vid %d (sent by %pM)... CRC = %#.4x\n",
 758                    BATADV_PRINT_VID(vid), backbone_gw->orig, crc);
 759
 760         spin_lock_bh(&backbone_gw->crc_lock);
 761         backbone_crc = backbone_gw->crc;
 762         spin_unlock_bh(&backbone_gw->crc_lock);
 763
 764         if (backbone_crc != crc) {
 765                 batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
 766                            "handle_announce(): CRC FAILED for %pM/%d (my = %#.4x, sent = %#.4x)\n",
 767                            backbone_gw->orig,
 768                            BATADV_PRINT_VID(backbone_gw->vid),
 769                            backbone_crc, crc);
 770
 771                 batadv_bla_send_request(backbone_gw);
 772         } else {
 773                 /* if we have sent a request and the crc was OK,
 774                  * we can allow traffic again.
 775                  */
 776                 if (atomic_read(&backbone_gw->request_sent)) {
 777                         atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
 778                         atomic_set(&backbone_gw->request_sent, 0);
 779                 }
 780         }
 781
 782         batadv_backbone_gw_free_ref(backbone_gw);
 783         return 1;
 784 }
 785
 786 /**
 787  * batadv_handle_request - check for REQUEST frame
 788  * @bat_priv: the bat priv with all the soft interface information
 789  * @primary_if: the primary hard interface of this batman soft interface
 790  * @backbone_addr: backbone address to be requested (ARP sender HW MAC)
 791  * @ethhdr: ethernet header of a packet
 792  * @vid: the VLAN ID of the frame
 793  *
 794  * Return: 1 if handled
 795  */
 796 static int batadv_handle_request(struct batadv_priv *bat_priv,
 797                                  struct batadv_hard_iface *primary_if,
 798                                  u8 *backbone_addr, struct ethhdr *ethhdr,
 799                                  unsigned short vid)
 800 {
 801         /* check for REQUEST frame */
 802         if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
 803                 return 0;
 804
 805         /* sanity check, this should not happen on a normal switch,
 806          * we ignore it in this case.
 807          */
 808         if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
 809                 return 1;
 810
 811         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 812                    "handle_request(): REQUEST vid %d (sent by %pM)...\n",
 813                    BATADV_PRINT_VID(vid), ethhdr->h_source);
 814
 815         batadv_bla_answer_request(bat_priv, primary_if, vid);
 816         return 1;
 817 }
 818
 819 /**
 820  * batadv_handle_unclaim - check for UNCLAIM frame
 821  * @bat_priv: the bat priv with all the soft interface information
 822  * @primary_if: the primary hard interface of this batman soft interface
 823  * @backbone_addr: originator address of the backbone (Ethernet source)
 824  * @claim_addr: Client to be unclaimed (ARP sender HW MAC)
 825  * @vid: the VLAN ID of the frame
 826  *
 827  * Return: 1 if handled
 828  */
 829 static int batadv_handle_unclaim(struct batadv_priv *bat_priv,
 830                                  struct batadv_hard_iface *primary_if,
 831                                  u8 *backbone_addr, u8 *claim_addr,
 832                                  unsigned short vid)
 833 {
 834         struct batadv_bla_backbone_gw *backbone_gw;
 835
 836         /* unclaim in any case if it is our own */
 837         if (primary_if && batadv_compare_eth(backbone_addr,
 838                                              primary_if->net_dev->dev_addr))
 839                 batadv_bla_send_claim(bat_priv, claim_addr, vid,
 840                                       BATADV_CLAIM_TYPE_UNCLAIM);
 841
 842         backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid);
 843
 844         if (!backbone_gw)
 845                 return 1;
 846
 847         /* this must be an UNCLAIM frame */
 848         batadv_dbg(BATADV_DBG_BLA, bat_priv,
 849                    "handle_unclaim(): UNCLAIM %pM on vid %d (sent by %pM)...\n",
 850                    claim_addr, BATADV_PRINT_VID(vid), backbone_gw->orig);
 851
 852         batadv_bla_del_claim(bat_priv, claim_addr, vid);
 853         batadv_backbone_gw_free_ref(backbone_gw);
 854         return 1;
 855 }
 856
 857 /**
 858  * batadv_handle_claim - check for CLAIM frame
 859  * @bat_priv: the bat priv with all the soft interface information
 860  * @primary_if: the primary hard interface of this batman soft interface
 861  * @backbone_addr: originator address of the backbone (Ethernet Source)
 862  * @claim_addr: client mac address to be claimed (ARP sender HW MAC)
 863  * @vid: the VLAN ID of the frame
 864  *
 865  * Return: 1 if handled
 866  */
 867 static int batadv_handle_claim(struct batadv_priv *bat_priv,
 868                                struct batadv_hard_iface *primary_if,
 869                                u8 *backbone_addr, u8 *claim_addr,
 870                                unsigned short vid)
 871 {
 872         struct batadv_bla_backbone_gw *backbone_gw;
 873
 874         /* register the gateway if not yet available, and add the claim. */
 875
 876         backbone_gw = batadv_bla_get_backbone_gw(bat_priv, backbone_addr, vid,
 877                                                  false);
 878
 879         if (unlikely(!backbone_gw))
 880                 return 1;
 881
 882         /* this must be a CLAIM frame */
 883         batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
 884         if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
 885                 batadv_bla_send_claim(bat_priv, claim_addr, vid,
 886                                       BATADV_CLAIM_TYPE_CLAIM);
 887
 888         /* TODO: we could call something like tt_local_del() here. */
 889
 890         batadv_backbone_gw_free_ref(backbone_gw);
 891         return 1;
 892 }
 893
 894 /**
 895  * batadv_check_claim_group - check for claim group membership
 896  * @bat_priv: the bat priv with all the soft interface information
 897  * @primary_if: the primary interface of this batman interface
 898  * @hw_src: the Hardware source in the ARP Header
 899  * @hw_dst: the Hardware destination in the ARP Header
 900  * @ethhdr: pointer to the Ethernet header of the claim frame
 901  *
 902  * checks if it is a claim packet and if its on the same group.
 903  * This function also applies the group ID of the sender
 904  * if it is in the same mesh.
 905  *
 906  * Return:
 907  *      2  - if it is a claim packet and on the same group
 908  *      1  - if is a claim packet from another group
 909  *      0  - if it is not a claim packet
 910  */
 911 static int batadv_check_claim_group(struct batadv_priv *bat_priv,
 912                                     struct batadv_hard_iface *primary_if,
 913                                     u8 *hw_src, u8 *hw_dst,
 914                                     struct ethhdr *ethhdr)
 915 {
 916         u8 *backbone_addr;
 917         struct batadv_orig_node *orig_node;
 918         struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
 919
 920         bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
 921         bla_dst_own = &bat_priv->bla.claim_dest;
 922
 923         /* if announcement packet, use the source,
 924          * otherwise assume it is in the hw_src
 925          */
 926         switch (bla_dst->type) {
 927         case BATADV_CLAIM_TYPE_CLAIM:
 928                 backbone_addr = hw_src;
 929                 break;
 930         case BATADV_CLAIM_TYPE_REQUEST:
 931         case BATADV_CLAIM_TYPE_ANNOUNCE:
 932         case BATADV_CLAIM_TYPE_UNCLAIM:
 933                 backbone_addr = ethhdr->h_source;
 934                 break;
 935         default:
 936                 return 0;
 937         }
 938
 939         /* don't accept claim frames from ourselves */
 940         if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
 941                 return 0;
 942
 943         /* if its already the same group, it is fine. */
 944         if (bla_dst->group == bla_dst_own->group)
 945                 return 2;
 946
 947         /* lets see if this originator is in our mesh */
 948         orig_node = batadv_orig_hash_find(bat_priv, backbone_addr);
 949
 950         /* dont accept claims from gateways which are not in
 951          * the same mesh or group.
 952          */
 953         if (!orig_node)
 954                 return 1;
 955
 956         /* if our mesh friends mac is bigger, use it for ourselves. */
 957         if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
 958                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
 959                            "taking other backbones claim group: %#.4x\n",
 960                            ntohs(bla_dst->group));
 961                 bla_dst_own->group = bla_dst->group;
 962         }
 963
 964         batadv_orig_node_free_ref(orig_node);
 965
 966         return 2;
 967 }
 968
 969 /**
 970  * batadv_bla_process_claim - Check if this is a claim frame, and process it
 971  * @bat_priv: the bat priv with all the soft interface information
 972  * @primary_if: the primary hard interface of this batman soft interface
 973  * @skb: the frame to be checked
 974  *
 975  * Return: 1 if it was a claim frame, otherwise return 0 to
 976  * tell the callee that it can use the frame on its own.
 977  */
 978 static int batadv_bla_process_claim(struct batadv_priv *bat_priv,
 979                                     struct batadv_hard_iface *primary_if,
 980                                     struct sk_buff *skb)
 981 {
 982         struct batadv_bla_claim_dst *bla_dst, *bla_dst_own;
 983         u8 *hw_src, *hw_dst;
 984         struct vlan_hdr *vhdr, vhdr_buf;
 985         struct ethhdr *ethhdr;
 986         struct arphdr *arphdr;
 987         unsigned short vid;
 988         int vlan_depth = 0;
 989         __be16 proto;
 990         int headlen;
 991         int ret;
 992
 993         vid = batadv_get_vid(skb, 0);
 994         ethhdr = eth_hdr(skb);
 995
 996         proto = ethhdr->h_proto;
 997         headlen = ETH_HLEN;
 998         if (vid & BATADV_VLAN_HAS_TAG) {
 999                 /* Traverse the VLAN/Ethertypes.
1000                  *
1001                  * At this point it is known that the first protocol is a VLAN
1002                  * header, so start checking at the encapsulated protocol.
1003                  *
1004                  * The depth of the VLAN headers is recorded to drop BLA claim
1005                  * frames encapsulated into multiple VLAN headers (QinQ).
1006                  */
1007                 do {
1008                         vhdr = skb_header_pointer(skb, headlen, VLAN_HLEN,
1009                                                   &vhdr_buf);
1010                         if (!vhdr)
1011                                 return 0;
1012
1013                         proto = vhdr->h_vlan_encapsulated_proto;
1014                         headlen += VLAN_HLEN;
1015                         vlan_depth++;
1016                 } while (proto == htons(ETH_P_8021Q));
1017         }
1018
1019         if (proto != htons(ETH_P_ARP))
1020                 return 0; /* not a claim frame */
1021
1022         /* this must be a ARP frame. check if it is a claim. */
1023
1024         if (unlikely(!pskb_may_pull(skb, headlen + arp_hdr_len(skb->dev))))
1025                 return 0;
1026
1027         /* pskb_may_pull() may have modified the pointers, get ethhdr again */
1028         ethhdr = eth_hdr(skb);
1029         arphdr = (struct arphdr *)((u8 *)ethhdr + headlen);
1030
1031         /* Check whether the ARP frame carries a valid
1032          * IP information
1033          */
1034         if (arphdr->ar_hrd != htons(ARPHRD_ETHER))
1035                 return 0;
1036         if (arphdr->ar_pro != htons(ETH_P_IP))
1037                 return 0;
1038         if (arphdr->ar_hln != ETH_ALEN)
1039                 return 0;
1040         if (arphdr->ar_pln != 4)
1041                 return 0;
1042
1043         hw_src = (u8 *)arphdr + sizeof(struct arphdr);
1044         hw_dst = hw_src + ETH_ALEN + 4;
1045         bla_dst = (struct batadv_bla_claim_dst *)hw_dst;
1046         bla_dst_own = &bat_priv->bla.claim_dest;
1047
1048         /* check if it is a claim frame in general */
1049         if (memcmp(bla_dst->magic, bla_dst_own->magic,
1050                    sizeof(bla_dst->magic)) != 0)
1051                 return 0;
1052
1053         /* check if there is a claim frame encapsulated deeper in (QinQ) and
1054          * drop that, as this is not supported by BLA but should also not be
1055          * sent via the mesh.
1056          */
1057         if (vlan_depth > 1)
1058                 return 1;
1059
1060         /* check if it is a claim frame. */
1061         ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,
1062                                        ethhdr);
1063         if (ret == 1)
1064                 batadv_dbg(BATADV_DBG_BLA, bat_priv,
1065                            "bla_process_claim(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
1066                            ethhdr->h_source, BATADV_PRINT_VID(vid), hw_src,
1067                            hw_dst);
1068
1069         if (ret < 2)
1070                 return ret;
1071
1072         /* become a backbone gw ourselves on this vlan if not happened yet */
1073         batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1074
1075         /* check for the different types of claim frames ... */
1076         switch (bla_dst->type) {
1077         case BATADV_CLAIM_TYPE_CLAIM:
1078                 if (batadv_handle_claim(bat_priv, primary_if, hw_src,
1079                                         ethhdr->h_source, vid))
1080                         return 1;
1081                 break;
1082         case BATADV_CLAIM_TYPE_UNCLAIM:
1083                 if (batadv_handle_unclaim(bat_priv, primary_if,
1084                                           ethhdr->h_source, hw_src, vid))
1085                         return 1;
1086                 break;
1087
1088         case BATADV_CLAIM_TYPE_ANNOUNCE:
1089                 if (batadv_handle_announce(bat_priv, hw_src, ethhdr->h_source,
1090                                            vid))
1091                         return 1;
1092                 break;
1093         case BATADV_CLAIM_TYPE_REQUEST:
1094                 if (batadv_handle_request(bat_priv, primary_if, hw_src, ethhdr,
1095                                           vid))
1096                         return 1;
1097                 break;
1098         }
1099
1100         batadv_dbg(BATADV_DBG_BLA, bat_priv,
1101                    "bla_process_claim(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
1102                    ethhdr->h_source, BATADV_PRINT_VID(vid), hw_src, hw_dst);
1103         return 1;
1104 }
1105
1106 /**
1107  * batadv_bla_purge_backbone_gw - Remove backbone gateways after a timeout or
1108  *  immediately
1109  * @bat_priv: the bat priv with all the soft interface information
1110  * @now: whether the whole hash shall be wiped now
1111  *
1112  * Check when we last heard from other nodes, and remove them in case of
1113  * a time out, or clean all backbone gws if now is set.
1114  */
1115 static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now)
1116 {
1117         struct batadv_bla_backbone_gw *backbone_gw;
1118         struct hlist_node *node_tmp;
1119         struct hlist_head *head;
1120         struct batadv_hashtable *hash;
1121         spinlock_t *list_lock;  /* protects write access to the hash lists */
1122         int i;
1123
1124         hash = bat_priv->bla.backbone_hash;
1125         if (!hash)
1126                 return;
1127
1128         for (i = 0; i < hash->size; i++) {
1129                 head = &hash->table[i];
1130                 list_lock = &hash->list_locks[i];
1131
1132                 spin_lock_bh(list_lock);
1133                 hlist_for_each_entry_safe(backbone_gw, node_tmp,
1134                                           head, hash_entry) {
1135                         if (now)
1136                                 goto purge_now;
1137                         if (!batadv_has_timed_out(backbone_gw->lasttime,
1138                                                   BATADV_BLA_BACKBONE_TIMEOUT))
1139                                 continue;
1140
1141                         batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
1142                                    "bla_purge_backbone_gw(): backbone gw %pM timed out\n",
1143                                    backbone_gw->orig);
1144
1145 purge_now:
1146                         /* don't wait for the pending request anymore */
1147                         if (atomic_read(&backbone_gw->request_sent))
1148                                 atomic_dec(&bat_priv->bla.num_requests);
1149
1150                         batadv_bla_del_backbone_claims(backbone_gw);
1151
1152                         hlist_del_rcu(&backbone_gw->hash_entry);
1153                         batadv_backbone_gw_free_ref(backbone_gw);
1154                 }
1155                 spin_unlock_bh(list_lock);
1156         }
1157 }
1158
1159 /**
1160  * batadv_bla_purge_claims - Remove claims after a timeout or immediately
1161  * @bat_priv: the bat priv with all the soft interface information
1162  * @primary_if: the selected primary interface, may be NULL if now is set
1163  * @now: whether the whole hash shall be wiped now
1164  *
1165  * Check when we heard last time from our own claims, and remove them in case of
1166  * a time out, or clean all claims if now is set
1167  */
1168 static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
1169                                     struct batadv_hard_iface *primary_if,
1170                                     int now)
1171 {
1172         struct batadv_bla_claim *claim;
1173         struct hlist_head *head;
1174         struct batadv_hashtable *hash;
1175         int i;
1176
1177         hash = bat_priv->bla.claim_hash;
1178         if (!hash)
1179                 return;
1180
1181         for (i = 0; i < hash->size; i++) {
1182                 head = &hash->table[i];
1183
1184                 rcu_read_lock();
1185                 hlist_for_each_entry_rcu(claim, head, hash_entry) {
1186                         if (now)
1187                                 goto purge_now;
1188                         if (!batadv_compare_eth(claim->backbone_gw->orig,
1189                                                 primary_if->net_dev->dev_addr))
1190                                 continue;
1191                         if (!batadv_has_timed_out(claim->lasttime,
1192                                                   BATADV_BLA_CLAIM_TIMEOUT))
1193                                 continue;
1194
1195                         batadv_dbg(BATADV_DBG_BLA, bat_priv,
1196                                    "bla_purge_claims(): %pM, vid %d, time out\n",
1197                                    claim->addr, claim->vid);
1198
1199 purge_now:
1200                         batadv_handle_unclaim(bat_priv, primary_if,
1201                                               claim->backbone_gw->orig,
1202                                               claim->addr, claim->vid);
1203                 }
1204                 rcu_read_unlock();
1205         }
1206 }
1207
1208 /**
1209  * batadv_bla_update_orig_address - Update the backbone gateways when the own
1210  *  originator address changes
1211  * @bat_priv: the bat priv with all the soft interface information
1212  * @primary_if: the new selected primary_if
1213  * @oldif: the old primary interface, may be NULL
1214  */
1215 void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
1216                                     struct batadv_hard_iface *primary_if,
1217                                     struct batadv_hard_iface *oldif)
1218 {
1219         struct batadv_bla_backbone_gw *backbone_gw;
1220         struct hlist_head *head;
1221         struct batadv_hashtable *hash;
1222         __be16 group;
1223         int i;
1224
1225         /* reset bridge loop avoidance group id */
1226         group = htons(crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN));
1227         bat_priv->bla.claim_dest.group = group;
1228
1229         /* purge everything when bridge loop avoidance is turned off */
1230         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1231                 oldif = NULL;
1232
1233         if (!oldif) {
1234                 batadv_bla_purge_claims(bat_priv, NULL, 1);
1235                 batadv_bla_purge_backbone_gw(bat_priv, 1);
1236                 return;
1237         }
1238
1239         hash = bat_priv->bla.backbone_hash;
1240         if (!hash)
1241                 return;
1242
1243         for (i = 0; i < hash->size; i++) {
1244                 head = &hash->table[i];
1245
1246                 rcu_read_lock();
1247                 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1248                         /* own orig still holds the old value. */
1249                         if (!batadv_compare_eth(backbone_gw->orig,
1250                                                 oldif->net_dev->dev_addr))
1251                                 continue;
1252
1253                         ether_addr_copy(backbone_gw->orig,
1254                                         primary_if->net_dev->dev_addr);
1255                         /* send an announce frame so others will ask for our
1256                          * claims and update their tables.
1257                          */
1258                         batadv_bla_send_announce(bat_priv, backbone_gw);
1259                 }
1260                 rcu_read_unlock();
1261         }
1262 }
1263
1264 /**
1265  * batadv_bla_status_update - purge bla interfaces if necessary
1266  * @net_dev: the soft interface net device
1267  */
1268 void batadv_bla_status_update(struct net_device *net_dev)
1269 {
1270         struct batadv_priv *bat_priv = netdev_priv(net_dev);
1271         struct batadv_hard_iface *primary_if;
1272
1273         primary_if = batadv_primary_if_get_selected(bat_priv);
1274         if (!primary_if)
1275                 return;
1276
1277         /* this function already purges everything when bla is disabled,
1278          * so just call that one.
1279          */
1280         batadv_bla_update_orig_address(bat_priv, primary_if, primary_if);
1281         batadv_hardif_free_ref(primary_if);
1282 }
1283
1284 /**
1285  * batadv_bla_periodic_work - performs periodic bla work
1286  * @work: kernel work struct
1287  *
1288  * periodic work to do:
1289  *  * purge structures when they are too old
1290  *  * send announcements
1291  */
1292 static void batadv_bla_periodic_work(struct work_struct *work)
1293 {
1294         struct delayed_work *delayed_work;
1295         struct batadv_priv *bat_priv;
1296         struct batadv_priv_bla *priv_bla;
1297         struct hlist_head *head;
1298         struct batadv_bla_backbone_gw *backbone_gw;
1299         struct batadv_hashtable *hash;
1300         struct batadv_hard_iface *primary_if;
1301         int i;
1302
1303         delayed_work = container_of(work, struct delayed_work, work);
1304         priv_bla = container_of(delayed_work, struct batadv_priv_bla, work);
1305         bat_priv = container_of(priv_bla, struct batadv_priv, bla);
1306         primary_if = batadv_primary_if_get_selected(bat_priv);
1307         if (!primary_if)
1308                 goto out;
1309
1310         batadv_bla_purge_claims(bat_priv, primary_if, 0);
1311         batadv_bla_purge_backbone_gw(bat_priv, 0);
1312
1313         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1314                 goto out;
1315
1316         hash = bat_priv->bla.backbone_hash;
1317         if (!hash)
1318                 goto out;
1319
1320         for (i = 0; i < hash->size; i++) {
1321                 head = &hash->table[i];
1322
1323                 rcu_read_lock();
1324                 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1325                         if (!batadv_compare_eth(backbone_gw->orig,
1326                                                 primary_if->net_dev->dev_addr))
1327                                 continue;
1328
1329                         backbone_gw->lasttime = jiffies;
1330
1331                         batadv_bla_send_announce(bat_priv, backbone_gw);
1332
1333                         /* request_sent is only set after creation to avoid
1334                          * problems when we are not yet known as backbone gw
1335                          * in the backbone.
1336                          *
1337                          * We can reset this now after we waited some periods
1338                          * to give bridge forward delays and bla group forming
1339                          * some grace time.
1340                          */
1341
1342                         if (atomic_read(&backbone_gw->request_sent) == 0)
1343                                 continue;
1344
1345                         if (!atomic_dec_and_test(&backbone_gw->wait_periods))
1346                                 continue;
1347
1348                         atomic_dec(&backbone_gw->bat_priv->bla.num_requests);
1349                         atomic_set(&backbone_gw->request_sent, 0);
1350                 }
1351                 rcu_read_unlock();
1352         }
1353 out:
1354         if (primary_if)
1355                 batadv_hardif_free_ref(primary_if);
1356
1357         queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
1358                            msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
1359 }
1360
1361 /* The hash for claim and backbone hash receive the same key because they
1362  * are getting initialized by hash_new with the same key. Reinitializing
1363  * them with to different keys to allow nested locking without generating
1364  * lockdep warnings
1365  */
1366 static struct lock_class_key batadv_claim_hash_lock_class_key;
1367 static struct lock_class_key batadv_backbone_hash_lock_class_key;
1368
1369 /**
1370  * batadv_bla_init - initialize all bla structures
1371  * @bat_priv: the bat priv with all the soft interface information
1372  *
1373  * Return: 0 on success, < 0 on error.
1374  */
1375 int batadv_bla_init(struct batadv_priv *bat_priv)
1376 {
1377         int i;
1378         u8 claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
1379         struct batadv_hard_iface *primary_if;
1380         u16 crc;
1381         unsigned long entrytime;
1382
1383         spin_lock_init(&bat_priv->bla.bcast_duplist_lock);
1384
1385         batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hash registering\n");
1386
1387         /* setting claim destination address */
1388         memcpy(&bat_priv->bla.claim_dest.magic, claim_dest, 3);
1389         bat_priv->bla.claim_dest.type = 0;
1390         primary_if = batadv_primary_if_get_selected(bat_priv);
1391         if (primary_if) {
1392                 crc = crc16(0, primary_if->net_dev->dev_addr, ETH_ALEN);
1393                 bat_priv->bla.claim_dest.group = htons(crc);
1394                 batadv_hardif_free_ref(primary_if);
1395         } else {
1396                 bat_priv->bla.claim_dest.group = 0; /* will be set later */
1397         }
1398
1399         /* initialize the duplicate list */
1400         entrytime = jiffies - msecs_to_jiffies(BATADV_DUPLIST_TIMEOUT);
1401         for (i = 0; i < BATADV_DUPLIST_SIZE; i++)
1402                 bat_priv->bla.bcast_duplist[i].entrytime = entrytime;
1403         bat_priv->bla.bcast_duplist_curr = 0;
1404
1405         if (bat_priv->bla.claim_hash)
1406                 return 0;
1407
1408         bat_priv->bla.claim_hash = batadv_hash_new(128);
1409         bat_priv->bla.backbone_hash = batadv_hash_new(32);
1410
1411         if (!bat_priv->bla.claim_hash || !bat_priv->bla.backbone_hash)
1412                 return -ENOMEM;
1413
1414         batadv_hash_set_lock_class(bat_priv->bla.claim_hash,
1415                                    &batadv_claim_hash_lock_class_key);
1416         batadv_hash_set_lock_class(bat_priv->bla.backbone_hash,
1417                                    &batadv_backbone_hash_lock_class_key);
1418
1419         batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla hashes initialized\n");
1420
1421         INIT_DELAYED_WORK(&bat_priv->bla.work, batadv_bla_periodic_work);
1422
1423         queue_delayed_work(batadv_event_workqueue, &bat_priv->bla.work,
1424                            msecs_to_jiffies(BATADV_BLA_PERIOD_LENGTH));
1425         return 0;
1426 }
1427
1428 /**
1429  * batadv_bla_check_bcast_duplist - Check if a frame is in the broadcast dup.
1430  * @bat_priv: the bat priv with all the soft interface information
1431  * @skb: contains the bcast_packet to be checked
1432  *
1433  * check if it is on our broadcast list. Another gateway might
1434  * have sent the same packet because it is connected to the same backbone,
1435  * so we have to remove this duplicate.
1436  *
1437  * This is performed by checking the CRC, which will tell us
1438  * with a good chance that it is the same packet. If it is furthermore
1439  * sent by another host, drop it. We allow equal packets from
1440  * the same host however as this might be intended.
1441  *
1442  * Return: 1 if a packet is in the duplicate list, 0 otherwise.
1443  */
1444 int batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv,
1445                                    struct sk_buff *skb)
1446 {
1447         int i, curr, ret = 0;
1448         __be32 crc;
1449         struct batadv_bcast_packet *bcast_packet;
1450         struct batadv_bcast_duplist_entry *entry;
1451
1452         bcast_packet = (struct batadv_bcast_packet *)skb->data;
1453
1454         /* calculate the crc ... */
1455         crc = batadv_skb_crc32(skb, (u8 *)(bcast_packet + 1));
1456
1457         spin_lock_bh(&bat_priv->bla.bcast_duplist_lock);
1458
1459         for (i = 0; i < BATADV_DUPLIST_SIZE; i++) {
1460                 curr = (bat_priv->bla.bcast_duplist_curr + i);
1461                 curr %= BATADV_DUPLIST_SIZE;
1462                 entry = &bat_priv->bla.bcast_duplist[curr];
1463
1464                 /* we can stop searching if the entry is too old ;
1465                  * later entries will be even older
1466                  */
1467                 if (batadv_has_timed_out(entry->entrytime,
1468                                          BATADV_DUPLIST_TIMEOUT))
1469                         break;
1470
1471                 if (entry->crc != crc)
1472                         continue;
1473
1474                 if (batadv_compare_eth(entry->orig, bcast_packet->orig))
1475                         continue;
1476
1477                 /* this entry seems to match: same crc, not too old,
1478                  * and from another gw. therefore return 1 to forbid it.
1479                  */
1480                 ret = 1;
1481                 goto out;
1482         }
1483         /* not found, add a new entry (overwrite the oldest entry)
1484          * and allow it, its the first occurrence.
1485          */
1486         curr = (bat_priv->bla.bcast_duplist_curr + BATADV_DUPLIST_SIZE - 1);
1487         curr %= BATADV_DUPLIST_SIZE;
1488         entry = &bat_priv->bla.bcast_duplist[curr];
1489         entry->crc = crc;
1490         entry->entrytime = jiffies;
1491         ether_addr_copy(entry->orig, bcast_packet->orig);
1492         bat_priv->bla.bcast_duplist_curr = curr;
1493
1494 out:
1495         spin_unlock_bh(&bat_priv->bla.bcast_duplist_lock);
1496
1497         return ret;
1498 }
1499
1500 /**
1501  * batadv_bla_is_backbone_gw_orig - Check if the originator is a gateway for
1502  *  the VLAN identified by vid.
1503  * @bat_priv: the bat priv with all the soft interface information
1504  * @orig: originator mac address
1505  * @vid: VLAN identifier
1506  *
1507  * Return: true if orig is a backbone for this vid, false otherwise.
1508  */
1509 bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
1510                                     unsigned short vid)
1511 {
1512         struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
1513         struct hlist_head *head;
1514         struct batadv_bla_backbone_gw *backbone_gw;
1515         int i;
1516
1517         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1518                 return false;
1519
1520         if (!hash)
1521                 return false;
1522
1523         for (i = 0; i < hash->size; i++) {
1524                 head = &hash->table[i];
1525
1526                 rcu_read_lock();
1527                 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1528                         if (batadv_compare_eth(backbone_gw->orig, orig) &&
1529                             backbone_gw->vid == vid) {
1530                                 rcu_read_unlock();
1531                                 return true;
1532                         }
1533                 }
1534                 rcu_read_unlock();
1535         }
1536
1537         return false;
1538 }
1539
1540 /**
1541  * batadv_bla_is_backbone_gw - check if originator is a backbone gw for a VLAN.
1542  * @skb: the frame to be checked
1543  * @orig_node: the orig_node of the frame
1544  * @hdr_size: maximum length of the frame
1545  *
1546  * Return: 1 if the orig_node is also a gateway on the soft interface, otherwise
1547  * it returns 0.
1548  */
1549 int batadv_bla_is_backbone_gw(struct sk_buff *skb,
1550                               struct batadv_orig_node *orig_node, int hdr_size)
1551 {
1552         struct batadv_bla_backbone_gw *backbone_gw;
1553         unsigned short vid;
1554
1555         if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance))
1556                 return 0;
1557
1558         /* first, find out the vid. */
1559         if (!pskb_may_pull(skb, hdr_size + ETH_HLEN))
1560                 return 0;
1561
1562         vid = batadv_get_vid(skb, hdr_size);
1563
1564         /* see if this originator is a backbone gw for this VLAN */
1565         backbone_gw = batadv_backbone_hash_find(orig_node->bat_priv,
1566                                                 orig_node->orig, vid);
1567         if (!backbone_gw)
1568                 return 0;
1569
1570         batadv_backbone_gw_free_ref(backbone_gw);
1571         return 1;
1572 }
1573
1574 /**
1575  * batadv_bla_init - free all bla structures
1576  * @bat_priv: the bat priv with all the soft interface information
1577  *
1578  * for softinterface free or module unload
1579  */
1580 void batadv_bla_free(struct batadv_priv *bat_priv)
1581 {
1582         struct batadv_hard_iface *primary_if;
1583
1584         cancel_delayed_work_sync(&bat_priv->bla.work);
1585         primary_if = batadv_primary_if_get_selected(bat_priv);
1586
1587         if (bat_priv->bla.claim_hash) {
1588                 batadv_bla_purge_claims(bat_priv, primary_if, 1);
1589                 batadv_hash_destroy(bat_priv->bla.claim_hash);
1590                 bat_priv->bla.claim_hash = NULL;
1591         }
1592         if (bat_priv->bla.backbone_hash) {
1593                 batadv_bla_purge_backbone_gw(bat_priv, 1);
1594                 batadv_hash_destroy(bat_priv->bla.backbone_hash);
1595                 bat_priv->bla.backbone_hash = NULL;
1596         }
1597         if (primary_if)
1598                 batadv_hardif_free_ref(primary_if);
1599 }
1600
1601 /**
1602  * batadv_bla_rx - check packets coming from the mesh.
1603  * @bat_priv: the bat priv with all the soft interface information
1604  * @skb: the frame to be checked
1605  * @vid: the VLAN ID of the frame
1606  * @is_bcast: the packet came in a broadcast packet type.
1607  *
1608  * batadv_bla_rx avoidance checks if:
1609  *  * we have to race for a claim
1610  *  * if the frame is allowed on the LAN
1611  *
1612  * in these cases, the skb is further handled by this function
1613  *
1614  * Return: 1 if handled, otherwise it returns 0 and the caller shall further
1615  * process the skb.
1616  */
1617 int batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1618                   unsigned short vid, bool is_bcast)
1619 {
1620         struct ethhdr *ethhdr;
1621         struct batadv_bla_claim search_claim, *claim = NULL;
1622         struct batadv_hard_iface *primary_if;
1623         int ret;
1624
1625         ethhdr = eth_hdr(skb);
1626
1627         primary_if = batadv_primary_if_get_selected(bat_priv);
1628         if (!primary_if)
1629                 goto handled;
1630
1631         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1632                 goto allow;
1633
1634         if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1635                 /* don't allow broadcasts while requests are in flight */
1636                 if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast)
1637                         goto handled;
1638
1639         ether_addr_copy(search_claim.addr, ethhdr->h_source);
1640         search_claim.vid = vid;
1641         claim = batadv_claim_hash_find(bat_priv, &search_claim);
1642
1643         if (!claim) {
1644                 /* possible optimization: race for a claim */
1645                 /* No claim exists yet, claim it for us!
1646                  */
1647                 batadv_handle_claim(bat_priv, primary_if,
1648                                     primary_if->net_dev->dev_addr,
1649                                     ethhdr->h_source, vid);
1650                 goto allow;
1651         }
1652
1653         /* if it is our own claim ... */
1654         if (batadv_compare_eth(claim->backbone_gw->orig,
1655                                primary_if->net_dev->dev_addr)) {
1656                 /* ... allow it in any case */
1657                 claim->lasttime = jiffies;
1658                 goto allow;
1659         }
1660
1661         /* if it is a broadcast ... */
1662         if (is_multicast_ether_addr(ethhdr->h_dest) && is_bcast) {
1663                 /* ... drop it. the responsible gateway is in charge.
1664                  *
1665                  * We need to check is_bcast because with the gateway
1666                  * feature, broadcasts (like DHCP requests) may be sent
1667                  * using a unicast packet type.
1668                  */
1669                 goto handled;
1670         } else {
1671                 /* seems the client considers us as its best gateway.
1672                  * send a claim and update the claim table
1673                  * immediately.
1674                  */
1675                 batadv_handle_claim(bat_priv, primary_if,
1676                                     primary_if->net_dev->dev_addr,
1677                                     ethhdr->h_source, vid);
1678                 goto allow;
1679         }
1680 allow:
1681         batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1682         ret = 0;
1683         goto out;
1684
1685 handled:
1686         kfree_skb(skb);
1687         ret = 1;
1688
1689 out:
1690         if (primary_if)
1691                 batadv_hardif_free_ref(primary_if);
1692         if (claim)
1693                 batadv_claim_free_ref(claim);
1694         return ret;
1695 }
1696
1697 /**
1698  * batadv_bla_tx - check packets going into the mesh
1699  * @bat_priv: the bat priv with all the soft interface information
1700  * @skb: the frame to be checked
1701  * @vid: the VLAN ID of the frame
1702  *
1703  * batadv_bla_tx checks if:
1704  *  * a claim was received which has to be processed
1705  *  * the frame is allowed on the mesh
1706  *
1707  * in these cases, the skb is further handled by this function.
1708  *
1709  * This call might reallocate skb data.
1710  *
1711  * Return: 1 if handled, otherwise it returns 0 and the caller shall further
1712  * process the skb.
1713  */
1714 int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb,
1715                   unsigned short vid)
1716 {
1717         struct ethhdr *ethhdr;
1718         struct batadv_bla_claim search_claim, *claim = NULL;
1719         struct batadv_hard_iface *primary_if;
1720         int ret = 0;
1721
1722         primary_if = batadv_primary_if_get_selected(bat_priv);
1723         if (!primary_if)
1724                 goto out;
1725
1726         if (!atomic_read(&bat_priv->bridge_loop_avoidance))
1727                 goto allow;
1728
1729         if (batadv_bla_process_claim(bat_priv, primary_if, skb))
1730                 goto handled;
1731
1732         ethhdr = eth_hdr(skb);
1733
1734         if (unlikely(atomic_read(&bat_priv->bla.num_requests)))
1735                 /* don't allow broadcasts while requests are in flight */
1736                 if (is_multicast_ether_addr(ethhdr->h_dest))
1737                         goto handled;
1738
1739         ether_addr_copy(search_claim.addr, ethhdr->h_source);
1740         search_claim.vid = vid;
1741
1742         claim = batadv_claim_hash_find(bat_priv, &search_claim);
1743
1744         /* if no claim exists, allow it. */
1745         if (!claim)
1746                 goto allow;
1747
1748         /* check if we are responsible. */
1749         if (batadv_compare_eth(claim->backbone_gw->orig,
1750                                primary_if->net_dev->dev_addr)) {
1751                 /* if yes, the client has roamed and we have
1752                  * to unclaim it.
1753                  */
1754                 batadv_handle_unclaim(bat_priv, primary_if,
1755                                       primary_if->net_dev->dev_addr,
1756                                       ethhdr->h_source, vid);
1757                 goto allow;
1758         }
1759
1760         /* check if it is a multicast/broadcast frame */
1761         if (is_multicast_ether_addr(ethhdr->h_dest)) {
1762                 /* drop it. the responsible gateway has forwarded it into
1763                  * the backbone network.
1764                  */
1765                 goto handled;
1766         } else {
1767                 /* we must allow it. at least if we are
1768                  * responsible for the DESTINATION.
1769                  */
1770                 goto allow;
1771         }
1772 allow:
1773         batadv_bla_update_own_backbone_gw(bat_priv, primary_if, vid);
1774         ret = 0;
1775         goto out;
1776 handled:
1777         ret = 1;
1778 out:
1779         if (primary_if)
1780                 batadv_hardif_free_ref(primary_if);
1781         if (claim)
1782                 batadv_claim_free_ref(claim);
1783         return ret;
1784 }
1785
1786 /**
1787  * batadv_bla_claim_table_seq_print_text - print the claim table in a seq file
1788  * @seq: seq file to print on
1789  * @offset: not used
1790  *
1791  * Return: always 0
1792  */
1793 int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset)
1794 {
1795         struct net_device *net_dev = (struct net_device *)seq->private;
1796         struct batadv_priv *bat_priv = netdev_priv(net_dev);
1797         struct batadv_hashtable *hash = bat_priv->bla.claim_hash;
1798         struct batadv_bla_claim *claim;
1799         struct batadv_hard_iface *primary_if;
1800         struct hlist_head *head;
1801         u16 backbone_crc;
1802         u32 i;
1803         bool is_own;
1804         u8 *primary_addr;
1805
1806         primary_if = batadv_seq_print_text_primary_if_get(seq);
1807         if (!primary_if)
1808                 goto out;
1809
1810         primary_addr = primary_if->net_dev->dev_addr;
1811         seq_printf(seq,
1812                    "Claims announced for the mesh %s (orig %pM, group id %#.4x)\n",
1813                    net_dev->name, primary_addr,
1814                    ntohs(bat_priv->bla.claim_dest.group));
1815         seq_printf(seq, "   %-17s    %-5s    %-17s [o] (%-6s)\n",
1816                    "Client", "VID", "Originator", "CRC");
1817         for (i = 0; i < hash->size; i++) {
1818                 head = &hash->table[i];
1819
1820                 rcu_read_lock();
1821                 hlist_for_each_entry_rcu(claim, head, hash_entry) {
1822                         is_own = batadv_compare_eth(claim->backbone_gw->orig,
1823                                                     primary_addr);
1824
1825                         spin_lock_bh(&claim->backbone_gw->crc_lock);
1826                         backbone_crc = claim->backbone_gw->crc;
1827                         spin_unlock_bh(&claim->backbone_gw->crc_lock);
1828                         seq_printf(seq, " * %pM on %5d by %pM [%c] (%#.4x)\n",
1829                                    claim->addr, BATADV_PRINT_VID(claim->vid),
1830                                    claim->backbone_gw->orig,
1831                                    (is_own ? 'x' : ' '),
1832                                    backbone_crc);
1833                 }
1834                 rcu_read_unlock();
1835         }
1836 out:
1837         if (primary_if)
1838                 batadv_hardif_free_ref(primary_if);
1839         return 0;
1840 }
1841
1842 /**
1843  * batadv_bla_backbone_table_seq_print_text - print the backbone table in a seq
1844  *  file
1845  * @seq: seq file to print on
1846  * @offset: not used
1847  *
1848  * Return: always 0
1849  */
1850 int batadv_bla_backbone_table_seq_print_text(struct seq_file *seq, void *offset)
1851 {
1852         struct net_device *net_dev = (struct net_device *)seq->private;
1853         struct batadv_priv *bat_priv = netdev_priv(net_dev);
1854         struct batadv_hashtable *hash = bat_priv->bla.backbone_hash;
1855         struct batadv_bla_backbone_gw *backbone_gw;
1856         struct batadv_hard_iface *primary_if;
1857         struct hlist_head *head;
1858         int secs, msecs;
1859         u16 backbone_crc;
1860         u32 i;
1861         bool is_own;
1862         u8 *primary_addr;
1863
1864         primary_if = batadv_seq_print_text_primary_if_get(seq);
1865         if (!primary_if)
1866                 goto out;
1867
1868         primary_addr = primary_if->net_dev->dev_addr;
1869         seq_printf(seq,
1870                    "Backbones announced for the mesh %s (orig %pM, group id %#.4x)\n",
1871                    net_dev->name, primary_addr,
1872                    ntohs(bat_priv->bla.claim_dest.group));
1873         seq_printf(seq, "   %-17s    %-5s %-9s (%-6s)\n",
1874                    "Originator", "VID", "last seen", "CRC");
1875         for (i = 0; i < hash->size; i++) {
1876                 head = &hash->table[i];
1877
1878                 rcu_read_lock();
1879                 hlist_for_each_entry_rcu(backbone_gw, head, hash_entry) {
1880                         msecs = jiffies_to_msecs(jiffies -
1881                                                  backbone_gw->lasttime);
1882                         secs = msecs / 1000;
1883                         msecs = msecs % 1000;
1884
1885                         is_own = batadv_compare_eth(backbone_gw->orig,
1886                                                     primary_addr);
1887                         if (is_own)
1888                                 continue;
1889
1890                         spin_lock_bh(&backbone_gw->crc_lock);
1891                         backbone_crc = backbone_gw->crc;
1892                         spin_unlock_bh(&backbone_gw->crc_lock);
1893
1894                         seq_printf(seq, " * %pM on %5d %4i.%03is (%#.4x)\n",
1895                                    backbone_gw->orig,
1896                                    BATADV_PRINT_VID(backbone_gw->vid), secs,
1897                                    msecs, backbone_crc);
1898                 }
1899                 rcu_read_unlock();
1900         }
1901 out:
1902         if (primary_if)
1903                 batadv_hardif_free_ref(primary_if);
1904         return 0;
1905 }