net/batman-adv/translation-table.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) B.A.T.M.A.N. contributors:
   3  *
   4  * Marek Lindner, Simon Wunderlich, Antonio Quartulli
   5  */
   6
   7 #include "translation-table.h"
   8 #include "main.h"
   9
  10 #include <linux/atomic.h>
  11 #include <linux/bitops.h>
  12 #include <linux/build_bug.h>
  13 #include <linux/byteorder/generic.h>
  14 #include <linux/cache.h>
  15 #include <linux/compiler.h>
  16 #include <linux/container_of.h>
  17 #include <linux/crc32c.h>
  18 #include <linux/errno.h>
  19 #include <linux/etherdevice.h>
  20 #include <linux/gfp.h>
  21 #include <linux/if_ether.h>
  22 #include <linux/init.h>
  23 #include <linux/jhash.h>
  24 #include <linux/jiffies.h>
  25 #include <linux/kref.h>
  26 #include <linux/list.h>
  27 #include <linux/lockdep.h>
  28 #include <linux/net.h>
  29 #include <linux/netdevice.h>
  30 #include <linux/netlink.h>
  31 #include <linux/rculist.h>
  32 #include <linux/rcupdate.h>
  33 #include <linux/skbuff.h>
  34 #include <linux/slab.h>
  35 #include <linux/spinlock.h>
  36 #include <linux/stddef.h>
  37 #include <linux/string.h>
  38 #include <linux/workqueue.h>
  39 #include <net/genetlink.h>
  40 #include <net/netlink.h>
  41 #include <net/sock.h>
  42 #include <uapi/linux/batadv_packet.h>
  43 #include <uapi/linux/batman_adv.h>
  44
  45 #include "bridge_loop_avoidance.h"
  46 #include "hard-interface.h"
  47 #include "hash.h"
  48 #include "log.h"
  49 #include "netlink.h"
  50 #include "originator.h"
  51 #include "soft-interface.h"
  52 #include "tvlv.h"
  53
  54 static struct kmem_cache *batadv_tl_cache __read_mostly;
  55 static struct kmem_cache *batadv_tg_cache __read_mostly;
  56 static struct kmem_cache *batadv_tt_orig_cache __read_mostly;
  57 static struct kmem_cache *batadv_tt_change_cache __read_mostly;
  58 static struct kmem_cache *batadv_tt_req_cache __read_mostly;
  59 static struct kmem_cache *batadv_tt_roam_cache __read_mostly;
  60
  61 /* hash class keys */
  62 static struct lock_class_key batadv_tt_local_hash_lock_class_key;
  63 static struct lock_class_key batadv_tt_global_hash_lock_class_key;
  64
  65 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
  66                                  unsigned short vid,
  67                                  struct batadv_orig_node *orig_node);
  68 static void batadv_tt_purge(struct work_struct *work);
  69 static void
  70 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);
  71 static void batadv_tt_global_del(struct batadv_priv *bat_priv,
  72                                  struct batadv_orig_node *orig_node,
  73                                  const unsigned char *addr,
  74                                  unsigned short vid, const char *message,
  75                                  bool roaming);
  76
  77 /**
  78  * batadv_compare_tt() - check if two TT entries are the same
  79  * @node: the list element pointer of the first TT entry
  80  * @data2: pointer to the tt_common_entry of the second TT entry
  81  *
  82  * Compare the MAC address and the VLAN ID of the two TT entries and check if
  83  * they are the same TT client.
  84  * Return: true if the two TT clients are the same, false otherwise
  85  */
  86 static bool batadv_compare_tt(const struct hlist_node *node, const void *data2)
  87 {
  88         const void *data1 = container_of(node, struct batadv_tt_common_entry,
  89                                          hash_entry);
  90         const struct batadv_tt_common_entry *tt1 = data1;
  91         const struct batadv_tt_common_entry *tt2 = data2;
  92
  93         return (tt1->vid == tt2->vid) && batadv_compare_eth(data1, data2);
  94 }
  95
  96 /**
  97  * batadv_choose_tt() - return the index of the tt entry in the hash table
  98  * @data: pointer to the tt_common_entry object to map
  99  * @size: the size of the hash table
 100  *
 101  * Return: the hash index where the object represented by 'data' should be
 102  * stored at.
 103  */
 104 static inline u32 batadv_choose_tt(const void *data, u32 size)
 105 {
 106         const struct batadv_tt_common_entry *tt;
 107         u32 hash = 0;
 108
 109         tt = data;
 110         hash = jhash(&tt->addr, ETH_ALEN, hash);
 111         hash = jhash(&tt->vid, sizeof(tt->vid), hash);
 112
 113         return hash % size;
 114 }
 115
 116 /**
 117  * batadv_tt_hash_find() - look for a client in the given hash table
 118  * @hash: the hash table to search
 119  * @addr: the mac address of the client to look for
 120  * @vid: VLAN identifier
 121  *
 122  * Return: a pointer to the tt_common struct belonging to the searched client if
 123  * found, NULL otherwise.
 124  */
 125 static struct batadv_tt_common_entry *
 126 batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr,
 127                     unsigned short vid)
 128 {
 129         struct hlist_head *head;
 130         struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;
 131         u32 index;
 132
 133         if (!hash)
 134                 return NULL;
 135
 136         ether_addr_copy(to_search.addr, addr);
 137         to_search.vid = vid;
 138
 139         index = batadv_choose_tt(&to_search, hash->size);
 140         head = &hash->table[index];
 141
 142         rcu_read_lock();
 143         hlist_for_each_entry_rcu(tt, head, hash_entry) {
 144                 if (!batadv_compare_eth(tt, addr))
 145                         continue;
 146
 147                 if (tt->vid != vid)
 148                         continue;
 149
 150                 if (!kref_get_unless_zero(&tt->refcount))
 151                         continue;
 152
 153                 tt_tmp = tt;
 154                 break;
 155         }
 156         rcu_read_unlock();
 157
 158         return tt_tmp;
 159 }
 160
 161 /**
 162  * batadv_tt_local_hash_find() - search the local table for a given client
 163  * @bat_priv: the bat priv with all the soft interface information
 164  * @addr: the mac address of the client to look for
 165  * @vid: VLAN identifier
 166  *
 167  * Return: a pointer to the corresponding tt_local_entry struct if the client is
 168  * found, NULL otherwise.
 169  */
 170 static struct batadv_tt_local_entry *
 171 batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
 172                           unsigned short vid)
 173 {
 174         struct batadv_tt_common_entry *tt_common_entry;
 175         struct batadv_tt_local_entry *tt_local_entry = NULL;
 176
 177         tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,
 178                                               vid);
 179         if (tt_common_entry)
 180                 tt_local_entry = container_of(tt_common_entry,
 181                                               struct batadv_tt_local_entry,
 182                                               common);
 183         return tt_local_entry;
 184 }
 185
 186 /**
 187  * batadv_tt_global_hash_find() - search the global table for a given client
 188  * @bat_priv: the bat priv with all the soft interface information
 189  * @addr: the mac address of the client to look for
 190  * @vid: VLAN identifier
 191  *
 192  * Return: a pointer to the corresponding tt_global_entry struct if the client
 193  * is found, NULL otherwise.
 194  */
 195 struct batadv_tt_global_entry *
 196 batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
 197                            unsigned short vid)
 198 {
 199         struct batadv_tt_common_entry *tt_common_entry;
 200         struct batadv_tt_global_entry *tt_global_entry = NULL;
 201
 202         tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,
 203                                               vid);
 204         if (tt_common_entry)
 205                 tt_global_entry = container_of(tt_common_entry,
 206                                                struct batadv_tt_global_entry,
 207                                                common);
 208         return tt_global_entry;
 209 }
 210
 211 /**
 212  * batadv_tt_local_entry_free_rcu() - free the tt_local_entry
 213  * @rcu: rcu pointer of the tt_local_entry
 214  */
 215 static void batadv_tt_local_entry_free_rcu(struct rcu_head *rcu)
 216 {
 217         struct batadv_tt_local_entry *tt_local_entry;
 218
 219         tt_local_entry = container_of(rcu, struct batadv_tt_local_entry,
 220                                       common.rcu);
 221
 222         kmem_cache_free(batadv_tl_cache, tt_local_entry);
 223 }
 224
 225 /**
 226  * batadv_tt_local_entry_release() - release tt_local_entry from lists and queue
 227  *  for free after rcu grace period
 228  * @ref: kref pointer of the nc_node
 229  */
 230 static void batadv_tt_local_entry_release(struct kref *ref)
 231 {
 232         struct batadv_tt_local_entry *tt_local_entry;
 233
 234         tt_local_entry = container_of(ref, struct batadv_tt_local_entry,
 235                                       common.refcount);
 236
 237         batadv_softif_vlan_put(tt_local_entry->vlan);
 238
 239         call_rcu(&tt_local_entry->common.rcu, batadv_tt_local_entry_free_rcu);
 240 }
 241
 242 /**
 243  * batadv_tt_local_entry_put() - decrement the tt_local_entry refcounter and
 244  *  possibly release it
 245  * @tt_local_entry: tt_local_entry to be free'd
 246  */
 247 static void
 248 batadv_tt_local_entry_put(struct batadv_tt_local_entry *tt_local_entry)
 249 {
 250         if (!tt_local_entry)
 251                 return;
 252
 253         kref_put(&tt_local_entry->common.refcount,
 254                  batadv_tt_local_entry_release);
 255 }
 256
 257 /**
 258  * batadv_tt_global_entry_free_rcu() - free the tt_global_entry
 259  * @rcu: rcu pointer of the tt_global_entry
 260  */
 261 static void batadv_tt_global_entry_free_rcu(struct rcu_head *rcu)
 262 {
 263         struct batadv_tt_global_entry *tt_global_entry;
 264
 265         tt_global_entry = container_of(rcu, struct batadv_tt_global_entry,
 266                                        common.rcu);
 267
 268         kmem_cache_free(batadv_tg_cache, tt_global_entry);
 269 }
 270
 271 /**
 272  * batadv_tt_global_entry_release() - release tt_global_entry from lists and
 273  *  queue for free after rcu grace period
 274  * @ref: kref pointer of the nc_node
 275  */
 276 void batadv_tt_global_entry_release(struct kref *ref)
 277 {
 278         struct batadv_tt_global_entry *tt_global_entry;
 279
 280         tt_global_entry = container_of(ref, struct batadv_tt_global_entry,
 281                                        common.refcount);
 282
 283         batadv_tt_global_del_orig_list(tt_global_entry);
 284
 285         call_rcu(&tt_global_entry->common.rcu, batadv_tt_global_entry_free_rcu);
 286 }
 287
 288 /**
 289  * batadv_tt_global_hash_count() - count the number of orig entries
 290  * @bat_priv: the bat priv with all the soft interface information
 291  * @addr: the mac address of the client to count entries for
 292  * @vid: VLAN identifier
 293  *
 294  * Return: the number of originators advertising the given address/data
 295  * (excluding our self).
 296  */
 297 int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,
 298                                 const u8 *addr, unsigned short vid)
 299 {
 300         struct batadv_tt_global_entry *tt_global_entry;
 301         int count;
 302
 303         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
 304         if (!tt_global_entry)
 305                 return 0;
 306
 307         count = atomic_read(&tt_global_entry->orig_list_count);
 308         batadv_tt_global_entry_put(tt_global_entry);
 309
 310         return count;
 311 }
 312
 313 /**
 314  * batadv_tt_local_size_mod() - change the size by v of the local table
 315  *  identified by vid
 316  * @bat_priv: the bat priv with all the soft interface information
 317  * @vid: the VLAN identifier of the sub-table to change
 318  * @v: the amount to sum to the local table size
 319  */
 320 static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv,
 321                                      unsigned short vid, int v)
 322 {
 323         struct batadv_softif_vlan *vlan;
 324
 325         vlan = batadv_softif_vlan_get(bat_priv, vid);
 326         if (!vlan)
 327                 return;
 328
 329         atomic_add(v, &vlan->tt.num_entries);
 330
 331         batadv_softif_vlan_put(vlan);
 332 }
 333
 334 /**
 335  * batadv_tt_local_size_inc() - increase by one the local table size for the
 336  *  given vid
 337  * @bat_priv: the bat priv with all the soft interface information
 338  * @vid: the VLAN identifier
 339  */
 340 static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv,
 341                                      unsigned short vid)
 342 {
 343         batadv_tt_local_size_mod(bat_priv, vid, 1);
 344 }
 345
 346 /**
 347  * batadv_tt_local_size_dec() - decrease by one the local table size for the
 348  *  given vid
 349  * @bat_priv: the bat priv with all the soft interface information
 350  * @vid: the VLAN identifier
 351  */
 352 static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv,
 353                                      unsigned short vid)
 354 {
 355         batadv_tt_local_size_mod(bat_priv, vid, -1);
 356 }
 357
 358 /**
 359  * batadv_tt_global_size_mod() - change the size by v of the global table
 360  *  for orig_node identified by vid
 361  * @orig_node: the originator for which the table has to be modified
 362  * @vid: the VLAN identifier
 363  * @v: the amount to sum to the global table size
 364  */
 365 static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node,
 366                                       unsigned short vid, int v)
 367 {
 368         struct batadv_orig_node_vlan *vlan;
 369
 370         vlan = batadv_orig_node_vlan_new(orig_node, vid);
 371         if (!vlan)
 372                 return;
 373
 374         if (atomic_add_return(v, &vlan->tt.num_entries) == 0) {
 375                 spin_lock_bh(&orig_node->vlan_list_lock);
 376                 if (!hlist_unhashed(&vlan->list)) {
 377                         hlist_del_init_rcu(&vlan->list);
 378                         batadv_orig_node_vlan_put(vlan);
 379                 }
 380                 spin_unlock_bh(&orig_node->vlan_list_lock);
 381         }
 382
 383         batadv_orig_node_vlan_put(vlan);
 384 }
 385
 386 /**
 387  * batadv_tt_global_size_inc() - increase by one the global table size for the
 388  *  given vid
 389  * @orig_node: the originator which global table size has to be decreased
 390  * @vid: the vlan identifier
 391  */
 392 static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node,
 393                                       unsigned short vid)
 394 {
 395         batadv_tt_global_size_mod(orig_node, vid, 1);
 396 }
 397
 398 /**
 399  * batadv_tt_global_size_dec() - decrease by one the global table size for the
 400  *  given vid
 401  * @orig_node: the originator which global table size has to be decreased
 402  * @vid: the vlan identifier
 403  */
 404 static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node,
 405                                       unsigned short vid)
 406 {
 407         batadv_tt_global_size_mod(orig_node, vid, -1);
 408 }
 409
 410 /**
 411  * batadv_tt_orig_list_entry_free_rcu() - free the orig_entry
 412  * @rcu: rcu pointer of the orig_entry
 413  */
 414 static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)
 415 {
 416         struct batadv_tt_orig_list_entry *orig_entry;
 417
 418         orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);
 419
 420         kmem_cache_free(batadv_tt_orig_cache, orig_entry);
 421 }
 422
 423 /**
 424  * batadv_tt_orig_list_entry_release() - release tt orig entry from lists and
 425  *  queue for free after rcu grace period
 426  * @ref: kref pointer of the tt orig entry
 427  */
 428 static void batadv_tt_orig_list_entry_release(struct kref *ref)
 429 {
 430         struct batadv_tt_orig_list_entry *orig_entry;
 431
 432         orig_entry = container_of(ref, struct batadv_tt_orig_list_entry,
 433                                   refcount);
 434
 435         batadv_orig_node_put(orig_entry->orig_node);
 436         call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);
 437 }
 438
 439 /**
 440  * batadv_tt_orig_list_entry_put() - decrement the tt orig entry refcounter and
 441  *  possibly release it
 442  * @orig_entry: tt orig entry to be free'd
 443  */
 444 static void
 445 batadv_tt_orig_list_entry_put(struct batadv_tt_orig_list_entry *orig_entry)
 446 {
 447         if (!orig_entry)
 448                 return;
 449
 450         kref_put(&orig_entry->refcount, batadv_tt_orig_list_entry_release);
 451 }
 452
 453 /**
 454  * batadv_tt_local_event() - store a local TT event (ADD/DEL)
 455  * @bat_priv: the bat priv with all the soft interface information
 456  * @tt_local_entry: the TT entry involved in the event
 457  * @event_flags: flags to store in the event structure
 458  */
 459 static void batadv_tt_local_event(struct batadv_priv *bat_priv,
 460                                   struct batadv_tt_local_entry *tt_local_entry,
 461                                   u8 event_flags)
 462 {
 463         struct batadv_tt_change_node *tt_change_node, *entry, *safe;
 464         struct batadv_tt_common_entry *common = &tt_local_entry->common;
 465         u8 flags = common->flags | event_flags;
 466         bool event_removed = false;
 467         bool del_op_requested, del_op_entry;
 468
 469         tt_change_node = kmem_cache_alloc(batadv_tt_change_cache, GFP_ATOMIC);
 470         if (!tt_change_node)
 471                 return;
 472
 473         tt_change_node->change.flags = flags;
 474         memset(tt_change_node->change.reserved, 0,
 475                sizeof(tt_change_node->change.reserved));
 476         ether_addr_copy(tt_change_node->change.addr, common->addr);
 477         tt_change_node->change.vid = htons(common->vid);
 478
 479         del_op_requested = flags & BATADV_TT_CLIENT_DEL;
 480
 481         /* check for ADD+DEL or DEL+ADD events */
 482         spin_lock_bh(&bat_priv->tt.changes_list_lock);
 483         list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
 484                                  list) {
 485                 if (!batadv_compare_eth(entry->change.addr, common->addr))
 486                         continue;
 487
 488                 /* DEL+ADD in the same orig interval have no effect and can be
 489                  * removed to avoid silly behaviour on the receiver side. The
 490                  * other way around (ADD+DEL) can happen in case of roaming of
 491                  * a client still in the NEW state. Roaming of NEW clients is
 492                  * now possible due to automatically recognition of "temporary"
 493                  * clients
 494                  */
 495                 del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;
 496                 if (!del_op_requested && del_op_entry)
 497                         goto del;
 498                 if (del_op_requested && !del_op_entry)
 499                         goto del;
 500
 501                 /* this is a second add in the same originator interval. It
 502                  * means that flags have been changed: update them!
 503                  */
 504                 if (!del_op_requested && !del_op_entry)
 505                         entry->change.flags = flags;
 506
 507                 continue;
 508 del:
 509                 list_del(&entry->list);
 510                 kmem_cache_free(batadv_tt_change_cache, entry);
 511                 kmem_cache_free(batadv_tt_change_cache, tt_change_node);
 512                 event_removed = true;
 513                 goto unlock;
 514         }
 515
 516         /* track the change in the OGMinterval list */
 517         list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);
 518
 519 unlock:
 520         spin_unlock_bh(&bat_priv->tt.changes_list_lock);
 521
 522         if (event_removed)
 523                 atomic_dec(&bat_priv->tt.local_changes);
 524         else
 525                 atomic_inc(&bat_priv->tt.local_changes);
 526 }
 527
 528 /**
 529  * batadv_tt_len() - compute length in bytes of given number of tt changes
 530  * @changes_num: number of tt changes
 531  *
 532  * Return: computed length in bytes.
 533  */
 534 static int batadv_tt_len(int changes_num)
 535 {
 536         return changes_num * sizeof(struct batadv_tvlv_tt_change);
 537 }
 538
 539 /**
 540  * batadv_tt_entries() - compute the number of entries fitting in tt_len bytes
 541  * @tt_len: available space
 542  *
 543  * Return: the number of entries.
 544  */
 545 static u16 batadv_tt_entries(u16 tt_len)
 546 {
 547         return tt_len / batadv_tt_len(1);
 548 }
 549
 550 /**
 551  * batadv_tt_local_table_transmit_size() - calculates the local translation
 552  *  table size when transmitted over the air
 553  * @bat_priv: the bat priv with all the soft interface information
 554  *
 555  * Return: local translation table size in bytes.
 556  */
 557 static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)
 558 {
 559         u16 num_vlan = 0;
 560         u16 tt_local_entries = 0;
 561         struct batadv_softif_vlan *vlan;
 562         int hdr_size;
 563
 564         rcu_read_lock();
 565         hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
 566                 num_vlan++;
 567                 tt_local_entries += atomic_read(&vlan->tt.num_entries);
 568         }
 569         rcu_read_unlock();
 570
 571         /* header size of tvlv encapsulated tt response payload */
 572         hdr_size = sizeof(struct batadv_unicast_tvlv_packet);
 573         hdr_size += sizeof(struct batadv_tvlv_hdr);
 574         hdr_size += sizeof(struct batadv_tvlv_tt_data);
 575         hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);
 576
 577         return hdr_size + batadv_tt_len(tt_local_entries);
 578 }
 579
 580 static int batadv_tt_local_init(struct batadv_priv *bat_priv)
 581 {
 582         if (bat_priv->tt.local_hash)
 583                 return 0;
 584
 585         bat_priv->tt.local_hash = batadv_hash_new(1024);
 586
 587         if (!bat_priv->tt.local_hash)
 588                 return -ENOMEM;
 589
 590         batadv_hash_set_lock_class(bat_priv->tt.local_hash,
 591                                    &batadv_tt_local_hash_lock_class_key);
 592
 593         return 0;
 594 }
 595
 596 static void batadv_tt_global_free(struct batadv_priv *bat_priv,
 597                                   struct batadv_tt_global_entry *tt_global,
 598                                   const char *message)
 599 {
 600         struct batadv_tt_global_entry *tt_removed_entry;
 601         struct hlist_node *tt_removed_node;
 602
 603         batadv_dbg(BATADV_DBG_TT, bat_priv,
 604                    "Deleting global tt entry %pM (vid: %d): %s\n",
 605                    tt_global->common.addr,
 606                    batadv_print_vid(tt_global->common.vid), message);
 607
 608         tt_removed_node = batadv_hash_remove(bat_priv->tt.global_hash,
 609                                              batadv_compare_tt,
 610                                              batadv_choose_tt,
 611                                              &tt_global->common);
 612         if (!tt_removed_node)
 613                 return;
 614
 615         /* drop reference of remove hash entry */
 616         tt_removed_entry = hlist_entry(tt_removed_node,
 617                                        struct batadv_tt_global_entry,
 618                                        common.hash_entry);
 619         batadv_tt_global_entry_put(tt_removed_entry);
 620 }
 621
 622 /**
 623  * batadv_tt_local_add() - add a new client to the local table or update an
 624  *  existing client
 625  * @soft_iface: netdev struct of the mesh interface
 626  * @addr: the mac address of the client to add
 627  * @vid: VLAN identifier
 628  * @ifindex: index of the interface where the client is connected to (useful to
 629  *  identify wireless clients)
 630  * @mark: the value contained in the skb->mark field of the received packet (if
 631  *  any)
 632  *
 633  * Return: true if the client was successfully added, false otherwise.
 634  */
 635 bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr,
 636                          unsigned short vid, int ifindex, u32 mark)
 637 {
 638         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 639         struct batadv_tt_local_entry *tt_local;
 640         struct batadv_tt_global_entry *tt_global = NULL;
 641         struct net *net = dev_net(soft_iface);
 642         struct batadv_softif_vlan *vlan;
 643         struct net_device *in_dev = NULL;
 644         struct batadv_hard_iface *in_hardif = NULL;
 645         struct hlist_head *head;
 646         struct batadv_tt_orig_list_entry *orig_entry;
 647         int hash_added, table_size, packet_size_max;
 648         bool ret = false;
 649         bool roamed_back = false;
 650         u8 remote_flags;
 651         u32 match_mark;
 652
 653         if (ifindex != BATADV_NULL_IFINDEX)
 654                 in_dev = dev_get_by_index(net, ifindex);
 655
 656         if (in_dev)
 657                 in_hardif = batadv_hardif_get_by_netdev(in_dev);
 658
 659         tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);
 660
 661         if (!is_multicast_ether_addr(addr))
 662                 tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid);
 663
 664         if (tt_local) {
 665                 tt_local->last_seen = jiffies;
 666                 if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {
 667                         batadv_dbg(BATADV_DBG_TT, bat_priv,
 668                                    "Re-adding pending client %pM (vid: %d)\n",
 669                                    addr, batadv_print_vid(vid));
 670                         /* whatever the reason why the PENDING flag was set,
 671                          * this is a client which was enqueued to be removed in
 672                          * this orig_interval. Since it popped up again, the
 673                          * flag can be reset like it was never enqueued
 674                          */
 675                         tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING;
 676                         goto add_event;
 677                 }
 678
 679                 if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) {
 680                         batadv_dbg(BATADV_DBG_TT, bat_priv,
 681                                    "Roaming client %pM (vid: %d) came back to its original location\n",
 682                                    addr, batadv_print_vid(vid));
 683                         /* the ROAM flag is set because this client roamed away
 684                          * and the node got a roaming_advertisement message. Now
 685                          * that the client popped up again at its original
 686                          * location such flag can be unset
 687                          */
 688                         tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM;
 689                         roamed_back = true;
 690                 }
 691                 goto check_roaming;
 692         }
 693
 694         /* Ignore the client if we cannot send it in a full table response. */
 695         table_size = batadv_tt_local_table_transmit_size(bat_priv);
 696         table_size += batadv_tt_len(1);
 697         packet_size_max = atomic_read(&bat_priv->packet_size_max);
 698         if (table_size > packet_size_max) {
 699                 net_ratelimited_function(batadv_info, soft_iface,
 700                                          "Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n",
 701                                          table_size, packet_size_max, addr);
 702                 goto out;
 703         }
 704
 705         tt_local = kmem_cache_alloc(batadv_tl_cache, GFP_ATOMIC);
 706         if (!tt_local)
 707                 goto out;
 708
 709         /* increase the refcounter of the related vlan */
 710         vlan = batadv_softif_vlan_get(bat_priv, vid);
 711         if (!vlan) {
 712                 net_ratelimited_function(batadv_info, soft_iface,
 713                                          "adding TT local entry %pM to non-existent VLAN %d\n",
 714                                          addr, batadv_print_vid(vid));
 715                 kmem_cache_free(batadv_tl_cache, tt_local);
 716                 tt_local = NULL;
 717                 goto out;
 718         }
 719
 720         batadv_dbg(BATADV_DBG_TT, bat_priv,
 721                    "Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n",
 722                    addr, batadv_print_vid(vid),
 723                    (u8)atomic_read(&bat_priv->tt.vn));
 724
 725         ether_addr_copy(tt_local->common.addr, addr);
 726         /* The local entry has to be marked as NEW to avoid to send it in
 727          * a full table response going out before the next ttvn increment
 728          * (consistency check)
 729          */
 730         tt_local->common.flags = BATADV_TT_CLIENT_NEW;
 731         tt_local->common.vid = vid;
 732         if (batadv_is_wifi_hardif(in_hardif))
 733                 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
 734         kref_init(&tt_local->common.refcount);
 735         tt_local->last_seen = jiffies;
 736         tt_local->common.added_at = tt_local->last_seen;
 737         tt_local->vlan = vlan;
 738
 739         /* the batman interface mac and multicast addresses should never be
 740          * purged
 741          */
 742         if (batadv_compare_eth(addr, soft_iface->dev_addr) ||
 743             is_multicast_ether_addr(addr))
 744                 tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;
 745
 746         kref_get(&tt_local->common.refcount);
 747         hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,
 748                                      batadv_choose_tt, &tt_local->common,
 749                                      &tt_local->common.hash_entry);
 750
 751         if (unlikely(hash_added != 0)) {
 752                 /* remove the reference for the hash */
 753                 batadv_tt_local_entry_put(tt_local);
 754                 goto out;
 755         }
 756
 757 add_event:
 758         batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
 759
 760 check_roaming:
 761         /* Check whether it is a roaming, but don't do anything if the roaming
 762          * process has already been handled
 763          */
 764         if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) {
 765                 /* These node are probably going to update their tt table */
 766                 head = &tt_global->orig_list;
 767                 rcu_read_lock();
 768                 hlist_for_each_entry_rcu(orig_entry, head, list) {
 769                         batadv_send_roam_adv(bat_priv, tt_global->common.addr,
 770                                              tt_global->common.vid,
 771                                              orig_entry->orig_node);
 772                 }
 773                 rcu_read_unlock();
 774                 if (roamed_back) {
 775                         batadv_tt_global_free(bat_priv, tt_global,
 776                                               "Roaming canceled");
 777                 } else {
 778                         /* The global entry has to be marked as ROAMING and
 779                          * has to be kept for consistency purpose
 780                          */
 781                         tt_global->common.flags |= BATADV_TT_CLIENT_ROAM;
 782                         tt_global->roam_at = jiffies;
 783                 }
 784         }
 785
 786         /* store the current remote flags before altering them. This helps
 787          * understanding is flags are changing or not
 788          */
 789         remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK;
 790
 791         if (batadv_is_wifi_hardif(in_hardif))
 792                 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
 793         else
 794                 tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI;
 795
 796         /* check the mark in the skb: if it's equal to the configured
 797          * isolation_mark, it means the packet is coming from an isolated
 798          * non-mesh client
 799          */
 800         match_mark = (mark & bat_priv->isolation_mark_mask);
 801         if (bat_priv->isolation_mark_mask &&
 802             match_mark == bat_priv->isolation_mark)
 803                 tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA;
 804         else
 805                 tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA;
 806
 807         /* if any "dynamic" flag has been modified, resend an ADD event for this
 808          * entry so that all the nodes can get the new flags
 809          */
 810         if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK))
 811                 batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
 812
 813         ret = true;
 814 out:
 815         batadv_hardif_put(in_hardif);
 816         dev_put(in_dev);
 817         batadv_tt_local_entry_put(tt_local);
 818         batadv_tt_global_entry_put(tt_global);
 819         return ret;
 820 }
 821
 822 /**
 823  * batadv_tt_prepare_tvlv_global_data() - prepare the TVLV TT header to send
 824  *  within a TT Response directed to another node
 825  * @orig_node: originator for which the TT data has to be prepared
 826  * @tt_data: uninitialised pointer to the address of the TVLV buffer
 827  * @tt_change: uninitialised pointer to the address of the area where the TT
 828  *  changed can be stored
 829  * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
 830  *  function reserves the amount of space needed to send the entire global TT
 831  *  table. In case of success the value is updated with the real amount of
 832  *  reserved bytes
 833  * Allocate the needed amount of memory for the entire TT TVLV and write its
 834  * header made up of one tvlv_tt_data object and a series of tvlv_tt_vlan_data
 835  * objects, one per active VLAN served by the originator node.
 836  *
 837  * Return: the size of the allocated buffer or 0 in case of failure.
 838  */
 839 static u16
 840 batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node,
 841                                    struct batadv_tvlv_tt_data **tt_data,
 842                                    struct batadv_tvlv_tt_change **tt_change,
 843                                    s32 *tt_len)
 844 {
 845         u16 num_vlan = 0;
 846         u16 num_entries = 0;
 847         u16 change_offset;
 848         u16 tvlv_len;
 849         struct batadv_tvlv_tt_vlan_data *tt_vlan;
 850         struct batadv_orig_node_vlan *vlan;
 851         u8 *tt_change_ptr;
 852
 853         spin_lock_bh(&orig_node->vlan_list_lock);
 854         hlist_for_each_entry(vlan, &orig_node->vlan_list, list) {
 855                 num_vlan++;
 856                 num_entries += atomic_read(&vlan->tt.num_entries);
 857         }
 858
 859         change_offset = sizeof(**tt_data);
 860         change_offset += num_vlan * sizeof(*tt_vlan);
 861
 862         /* if tt_len is negative, allocate the space needed by the full table */
 863         if (*tt_len < 0)
 864                 *tt_len = batadv_tt_len(num_entries);
 865
 866         tvlv_len = *tt_len;
 867         tvlv_len += change_offset;
 868
 869         *tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
 870         if (!*tt_data) {
 871                 *tt_len = 0;
 872                 goto out;
 873         }
 874
 875         (*tt_data)->flags = BATADV_NO_FLAGS;
 876         (*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn);
 877         (*tt_data)->num_vlan = htons(num_vlan);
 878
 879         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
 880         hlist_for_each_entry(vlan, &orig_node->vlan_list, list) {
 881                 tt_vlan->vid = htons(vlan->vid);
 882                 tt_vlan->crc = htonl(vlan->tt.crc);
 883                 tt_vlan->reserved = 0;
 884
 885                 tt_vlan++;
 886         }
 887
 888         tt_change_ptr = (u8 *)*tt_data + change_offset;
 889         *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
 890
 891 out:
 892         spin_unlock_bh(&orig_node->vlan_list_lock);
 893         return tvlv_len;
 894 }
 895
 896 /**
 897  * batadv_tt_prepare_tvlv_local_data() - allocate and prepare the TT TVLV for
 898  *  this node
 899  * @bat_priv: the bat priv with all the soft interface information
 900  * @tt_data: uninitialised pointer to the address of the TVLV buffer
 901  * @tt_change: uninitialised pointer to the address of the area where the TT
 902  *  changes can be stored
 903  * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
 904  *  function reserves the amount of space needed to send the entire local TT
 905  *  table. In case of success the value is updated with the real amount of
 906  *  reserved bytes
 907  *
 908  * Allocate the needed amount of memory for the entire TT TVLV and write its
 909  * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
 910  * objects, one per active VLAN.
 911  *
 912  * Return: the size of the allocated buffer or 0 in case of failure.
 913  */
 914 static u16
 915 batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,
 916                                   struct batadv_tvlv_tt_data **tt_data,
 917                                   struct batadv_tvlv_tt_change **tt_change,
 918                                   s32 *tt_len)
 919 {
 920         struct batadv_tvlv_tt_vlan_data *tt_vlan;
 921         struct batadv_softif_vlan *vlan;
 922         u16 num_vlan = 0;
 923         u16 vlan_entries = 0;
 924         u16 total_entries = 0;
 925         u16 tvlv_len;
 926         u8 *tt_change_ptr;
 927         int change_offset;
 928
 929         spin_lock_bh(&bat_priv->softif_vlan_list_lock);
 930         hlist_for_each_entry(vlan, &bat_priv->softif_vlan_list, list) {
 931                 vlan_entries = atomic_read(&vlan->tt.num_entries);
 932                 if (vlan_entries < 1)
 933                         continue;
 934
 935                 num_vlan++;
 936                 total_entries += vlan_entries;
 937         }
 938
 939         change_offset = sizeof(**tt_data);
 940         change_offset += num_vlan * sizeof(*tt_vlan);
 941
 942         /* if tt_len is negative, allocate the space needed by the full table */
 943         if (*tt_len < 0)
 944                 *tt_len = batadv_tt_len(total_entries);
 945
 946         tvlv_len = *tt_len;
 947         tvlv_len += change_offset;
 948
 949         *tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
 950         if (!*tt_data) {
 951                 tvlv_len = 0;
 952                 goto out;
 953         }
 954
 955         (*tt_data)->flags = BATADV_NO_FLAGS;
 956         (*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn);
 957         (*tt_data)->num_vlan = htons(num_vlan);
 958
 959         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
 960         hlist_for_each_entry(vlan, &bat_priv->softif_vlan_list, list) {
 961                 vlan_entries = atomic_read(&vlan->tt.num_entries);
 962                 if (vlan_entries < 1)
 963                         continue;
 964
 965                 tt_vlan->vid = htons(vlan->vid);
 966                 tt_vlan->crc = htonl(vlan->tt.crc);
 967                 tt_vlan->reserved = 0;
 968
 969                 tt_vlan++;
 970         }
 971
 972         tt_change_ptr = (u8 *)*tt_data + change_offset;
 973         *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
 974
 975 out:
 976         spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
 977         return tvlv_len;
 978 }
 979
 980 /**
 981  * batadv_tt_tvlv_container_update() - update the translation table tvlv
 982  *  container after local tt changes have been committed
 983  * @bat_priv: the bat priv with all the soft interface information
 984  */
 985 static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)
 986 {
 987         struct batadv_tt_change_node *entry, *safe;
 988         struct batadv_tvlv_tt_data *tt_data;
 989         struct batadv_tvlv_tt_change *tt_change;
 990         int tt_diff_len, tt_change_len = 0;
 991         int tt_diff_entries_num = 0;
 992         int tt_diff_entries_count = 0;
 993         u16 tvlv_len;
 994
 995         tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);
 996         tt_diff_len = batadv_tt_len(tt_diff_entries_num);
 997
 998         /* if we have too many changes for one packet don't send any
 999          * and wait for the tt table request which will be fragmented
1000          */
1001         if (tt_diff_len > bat_priv->soft_iface->mtu)
1002                 tt_diff_len = 0;
1003
1004         tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,
1005                                                      &tt_change, &tt_diff_len);
1006         if (!tvlv_len)
1007                 return;
1008
1009         tt_data->flags = BATADV_TT_OGM_DIFF;
1010
1011         if (tt_diff_len == 0)
1012                 goto container_register;
1013
1014         spin_lock_bh(&bat_priv->tt.changes_list_lock);
1015         atomic_set(&bat_priv->tt.local_changes, 0);
1016
1017         list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
1018                                  list) {
1019                 if (tt_diff_entries_count < tt_diff_entries_num) {
1020                         memcpy(tt_change + tt_diff_entries_count,
1021                                &entry->change,
1022                                sizeof(struct batadv_tvlv_tt_change));
1023                         tt_diff_entries_count++;
1024                 }
1025                 list_del(&entry->list);
1026                 kmem_cache_free(batadv_tt_change_cache, entry);
1027         }
1028         spin_unlock_bh(&bat_priv->tt.changes_list_lock);
1029
1030         /* Keep the buffer for possible tt_request */
1031         spin_lock_bh(&bat_priv->tt.last_changeset_lock);
1032         kfree(bat_priv->tt.last_changeset);
1033         bat_priv->tt.last_changeset_len = 0;
1034         bat_priv->tt.last_changeset = NULL;
1035         tt_change_len = batadv_tt_len(tt_diff_entries_count);
1036         /* check whether this new OGM has no changes due to size problems */
1037         if (tt_diff_entries_count > 0) {
1038                 /* if kmalloc() fails we will reply with the full table
1039                  * instead of providing the diff
1040                  */
1041                 bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);
1042                 if (bat_priv->tt.last_changeset) {
1043                         memcpy(bat_priv->tt.last_changeset,
1044                                tt_change, tt_change_len);
1045                         bat_priv->tt.last_changeset_len = tt_diff_len;
1046                 }
1047         }
1048         spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
1049
1050 container_register:
1051         batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,
1052                                        tvlv_len);
1053         kfree(tt_data);
1054 }
1055
1056 /**
1057  * batadv_tt_local_dump_entry() - Dump one TT local entry into a message
1058  * @msg :Netlink message to dump into
1059  * @portid: Port making netlink request
1060  * @cb: Control block containing additional options
1061  * @bat_priv: The bat priv with all the soft interface information
1062  * @common: tt local & tt global common data
1063  *
1064  * Return: Error code, or 0 on success
1065  */
1066 static int
1067 batadv_tt_local_dump_entry(struct sk_buff *msg, u32 portid,
1068                            struct netlink_callback *cb,
1069                            struct batadv_priv *bat_priv,
1070                            struct batadv_tt_common_entry *common)
1071 {
1072         void *hdr;
1073         struct batadv_softif_vlan *vlan;
1074         struct batadv_tt_local_entry *local;
1075         unsigned int last_seen_msecs;
1076         u32 crc;
1077
1078         local = container_of(common, struct batadv_tt_local_entry, common);
1079         last_seen_msecs = jiffies_to_msecs(jiffies - local->last_seen);
1080
1081         vlan = batadv_softif_vlan_get(bat_priv, common->vid);
1082         if (!vlan)
1083                 return 0;
1084
1085         crc = vlan->tt.crc;
1086
1087         batadv_softif_vlan_put(vlan);
1088
1089         hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
1090                           &batadv_netlink_family,  NLM_F_MULTI,
1091                           BATADV_CMD_GET_TRANSTABLE_LOCAL);
1092         if (!hdr)
1093                 return -ENOBUFS;
1094
1095         genl_dump_check_consistent(cb, hdr);
1096
1097         if (nla_put(msg, BATADV_ATTR_TT_ADDRESS, ETH_ALEN, common->addr) ||
1098             nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) ||
1099             nla_put_u16(msg, BATADV_ATTR_TT_VID, common->vid) ||
1100             nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, common->flags))
1101                 goto nla_put_failure;
1102
1103         if (!(common->flags & BATADV_TT_CLIENT_NOPURGE) &&
1104             nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, last_seen_msecs))
1105                 goto nla_put_failure;
1106
1107         genlmsg_end(msg, hdr);
1108         return 0;
1109
1110  nla_put_failure:
1111         genlmsg_cancel(msg, hdr);
1112         return -EMSGSIZE;
1113 }
1114
1115 /**
1116  * batadv_tt_local_dump_bucket() - Dump one TT local bucket into a message
1117  * @msg: Netlink message to dump into
1118  * @portid: Port making netlink request
1119  * @cb: Control block containing additional options
1120  * @bat_priv: The bat priv with all the soft interface information
1121  * @hash: hash to dump
1122  * @bucket: bucket index to dump
1123  * @idx_s: Number of entries to skip
1124  *
1125  * Return: Error code, or 0 on success
1126  */
1127 static int
1128 batadv_tt_local_dump_bucket(struct sk_buff *msg, u32 portid,
1129                             struct netlink_callback *cb,
1130                             struct batadv_priv *bat_priv,
1131                             struct batadv_hashtable *hash, unsigned int bucket,
1132                             int *idx_s)
1133 {
1134         struct batadv_tt_common_entry *common;
1135         int idx = 0;
1136
1137         spin_lock_bh(&hash->list_locks[bucket]);
1138         cb->seq = atomic_read(&hash->generation) << 1 | 1;
1139
1140         hlist_for_each_entry(common, &hash->table[bucket], hash_entry) {
1141                 if (idx++ < *idx_s)
1142                         continue;
1143
1144                 if (batadv_tt_local_dump_entry(msg, portid, cb, bat_priv,
1145                                                common)) {
1146                         spin_unlock_bh(&hash->list_locks[bucket]);
1147                         *idx_s = idx - 1;
1148                         return -EMSGSIZE;
1149                 }
1150         }
1151         spin_unlock_bh(&hash->list_locks[bucket]);
1152
1153         *idx_s = 0;
1154         return 0;
1155 }
1156
1157 /**
1158  * batadv_tt_local_dump() - Dump TT local entries into a message
1159  * @msg: Netlink message to dump into
1160  * @cb: Parameters from query
1161  *
1162  * Return: Error code, or 0 on success
1163  */
1164 int batadv_tt_local_dump(struct sk_buff *msg, struct netlink_callback *cb)
1165 {
1166         struct net *net = sock_net(cb->skb->sk);
1167         struct net_device *soft_iface;
1168         struct batadv_priv *bat_priv;
1169         struct batadv_hard_iface *primary_if = NULL;
1170         struct batadv_hashtable *hash;
1171         int ret;
1172         int ifindex;
1173         int bucket = cb->args[0];
1174         int idx = cb->args[1];
1175         int portid = NETLINK_CB(cb->skb).portid;
1176
1177         ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
1178         if (!ifindex)
1179                 return -EINVAL;
1180
1181         soft_iface = dev_get_by_index(net, ifindex);
1182         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
1183                 ret = -ENODEV;
1184                 goto out;
1185         }
1186
1187         bat_priv = netdev_priv(soft_iface);
1188
1189         primary_if = batadv_primary_if_get_selected(bat_priv);
1190         if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
1191                 ret = -ENOENT;
1192                 goto out;
1193         }
1194
1195         hash = bat_priv->tt.local_hash;
1196
1197         while (bucket < hash->size) {
1198                 if (batadv_tt_local_dump_bucket(msg, portid, cb, bat_priv,
1199                                                 hash, bucket, &idx))
1200                         break;
1201
1202                 bucket++;
1203         }
1204
1205         ret = msg->len;
1206
1207  out:
1208         batadv_hardif_put(primary_if);
1209         dev_put(soft_iface);
1210
1211         cb->args[0] = bucket;
1212         cb->args[1] = idx;
1213
1214         return ret;
1215 }
1216
1217 static void
1218 batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
1219                             struct batadv_tt_local_entry *tt_local_entry,
1220                             u16 flags, const char *message)
1221 {
1222         batadv_tt_local_event(bat_priv, tt_local_entry, flags);
1223
1224         /* The local client has to be marked as "pending to be removed" but has
1225          * to be kept in the table in order to send it in a full table
1226          * response issued before the net ttvn increment (consistency check)
1227          */
1228         tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;
1229
1230         batadv_dbg(BATADV_DBG_TT, bat_priv,
1231                    "Local tt entry (%pM, vid: %d) pending to be removed: %s\n",
1232                    tt_local_entry->common.addr,
1233                    batadv_print_vid(tt_local_entry->common.vid), message);
1234 }
1235
1236 /**
1237  * batadv_tt_local_remove() - logically remove an entry from the local table
1238  * @bat_priv: the bat priv with all the soft interface information
1239  * @addr: the MAC address of the client to remove
1240  * @vid: VLAN identifier
1241  * @message: message to append to the log on deletion
1242  * @roaming: true if the deletion is due to a roaming event
1243  *
1244  * Return: the flags assigned to the local entry before being deleted
1245  */
1246 u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr,
1247                            unsigned short vid, const char *message,
1248                            bool roaming)
1249 {
1250         struct batadv_tt_local_entry *tt_removed_entry;
1251         struct batadv_tt_local_entry *tt_local_entry;
1252         u16 flags, curr_flags = BATADV_NO_FLAGS;
1253         struct hlist_node *tt_removed_node;
1254
1255         tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
1256         if (!tt_local_entry)
1257                 goto out;
1258
1259         curr_flags = tt_local_entry->common.flags;
1260
1261         flags = BATADV_TT_CLIENT_DEL;
1262         /* if this global entry addition is due to a roaming, the node has to
1263          * mark the local entry as "roamed" in order to correctly reroute
1264          * packets later
1265          */
1266         if (roaming) {
1267                 flags |= BATADV_TT_CLIENT_ROAM;
1268                 /* mark the local client as ROAMed */
1269                 tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
1270         }
1271
1272         if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) {
1273                 batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags,
1274                                             message);
1275                 goto out;
1276         }
1277         /* if this client has been added right now, it is possible to
1278          * immediately purge it
1279          */
1280         batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);
1281
1282         tt_removed_node = batadv_hash_remove(bat_priv->tt.local_hash,
1283                                              batadv_compare_tt,
1284                                              batadv_choose_tt,
1285                                              &tt_local_entry->common);
1286         if (!tt_removed_node)
1287                 goto out;
1288
1289         /* drop reference of remove hash entry */
1290         tt_removed_entry = hlist_entry(tt_removed_node,
1291                                        struct batadv_tt_local_entry,
1292                                        common.hash_entry);
1293         batadv_tt_local_entry_put(tt_removed_entry);
1294
1295 out:
1296         batadv_tt_local_entry_put(tt_local_entry);
1297
1298         return curr_flags;
1299 }
1300
1301 /**
1302  * batadv_tt_local_purge_list() - purge inactive tt local entries
1303  * @bat_priv: the bat priv with all the soft interface information
1304  * @head: pointer to the list containing the local tt entries
1305  * @timeout: parameter deciding whether a given tt local entry is considered
1306  *  inactive or not
1307  */
1308 static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,
1309                                        struct hlist_head *head,
1310                                        int timeout)
1311 {
1312         struct batadv_tt_local_entry *tt_local_entry;
1313         struct batadv_tt_common_entry *tt_common_entry;
1314         struct hlist_node *node_tmp;
1315
1316         hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,
1317                                   hash_entry) {
1318                 tt_local_entry = container_of(tt_common_entry,
1319                                               struct batadv_tt_local_entry,
1320                                               common);
1321                 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)
1322                         continue;
1323
1324                 /* entry already marked for deletion */
1325                 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
1326                         continue;
1327
1328                 if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))
1329                         continue;
1330
1331                 batadv_tt_local_set_pending(bat_priv, tt_local_entry,
1332                                             BATADV_TT_CLIENT_DEL, "timed out");
1333         }
1334 }
1335
1336 /**
1337  * batadv_tt_local_purge() - purge inactive tt local entries
1338  * @bat_priv: the bat priv with all the soft interface information
1339  * @timeout: parameter deciding whether a given tt local entry is considered
1340  *  inactive or not
1341  */
1342 static void batadv_tt_local_purge(struct batadv_priv *bat_priv,
1343                                   int timeout)
1344 {
1345         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
1346         struct hlist_head *head;
1347         spinlock_t *list_lock; /* protects write access to the hash lists */
1348         u32 i;
1349
1350         for (i = 0; i < hash->size; i++) {
1351                 head = &hash->table[i];
1352                 list_lock = &hash->list_locks[i];
1353
1354                 spin_lock_bh(list_lock);
1355                 batadv_tt_local_purge_list(bat_priv, head, timeout);
1356                 spin_unlock_bh(list_lock);
1357         }
1358 }
1359
1360 static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
1361 {
1362         struct batadv_hashtable *hash;
1363         spinlock_t *list_lock; /* protects write access to the hash lists */
1364         struct batadv_tt_common_entry *tt_common_entry;
1365         struct batadv_tt_local_entry *tt_local;
1366         struct hlist_node *node_tmp;
1367         struct hlist_head *head;
1368         u32 i;
1369
1370         if (!bat_priv->tt.local_hash)
1371                 return;
1372
1373         hash = bat_priv->tt.local_hash;
1374
1375         for (i = 0; i < hash->size; i++) {
1376                 head = &hash->table[i];
1377                 list_lock = &hash->list_locks[i];
1378
1379                 spin_lock_bh(list_lock);
1380                 hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1381                                           head, hash_entry) {
1382                         hlist_del_rcu(&tt_common_entry->hash_entry);
1383                         tt_local = container_of(tt_common_entry,
1384                                                 struct batadv_tt_local_entry,
1385                                                 common);
1386
1387                         batadv_tt_local_entry_put(tt_local);
1388                 }
1389                 spin_unlock_bh(list_lock);
1390         }
1391
1392         batadv_hash_destroy(hash);
1393
1394         bat_priv->tt.local_hash = NULL;
1395 }
1396
1397 static int batadv_tt_global_init(struct batadv_priv *bat_priv)
1398 {
1399         if (bat_priv->tt.global_hash)
1400                 return 0;
1401
1402         bat_priv->tt.global_hash = batadv_hash_new(1024);
1403
1404         if (!bat_priv->tt.global_hash)
1405                 return -ENOMEM;
1406
1407         batadv_hash_set_lock_class(bat_priv->tt.global_hash,
1408                                    &batadv_tt_global_hash_lock_class_key);
1409
1410         return 0;
1411 }
1412
1413 static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)
1414 {
1415         struct batadv_tt_change_node *entry, *safe;
1416
1417         spin_lock_bh(&bat_priv->tt.changes_list_lock);
1418
1419         list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
1420                                  list) {
1421                 list_del(&entry->list);
1422                 kmem_cache_free(batadv_tt_change_cache, entry);
1423         }
1424
1425         atomic_set(&bat_priv->tt.local_changes, 0);
1426         spin_unlock_bh(&bat_priv->tt.changes_list_lock);
1427 }
1428
1429 /**
1430  * batadv_tt_global_orig_entry_find() - find a TT orig_list_entry
1431  * @entry: the TT global entry where the orig_list_entry has to be
1432  *  extracted from
1433  * @orig_node: the originator for which the orig_list_entry has to be found
1434  *
1435  * retrieve the orig_tt_list_entry belonging to orig_node from the
1436  * batadv_tt_global_entry list
1437  *
1438  * Return: it with an increased refcounter, NULL if not found
1439  */
1440 static struct batadv_tt_orig_list_entry *
1441 batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,
1442                                  const struct batadv_orig_node *orig_node)
1443 {
1444         struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;
1445         const struct hlist_head *head;
1446
1447         rcu_read_lock();
1448         head = &entry->orig_list;
1449         hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {
1450                 if (tmp_orig_entry->orig_node != orig_node)
1451                         continue;
1452                 if (!kref_get_unless_zero(&tmp_orig_entry->refcount))
1453                         continue;
1454
1455                 orig_entry = tmp_orig_entry;
1456                 break;
1457         }
1458         rcu_read_unlock();
1459
1460         return orig_entry;
1461 }
1462
1463 /**
1464  * batadv_tt_global_entry_has_orig() - check if a TT global entry is also
1465  *  handled by a given originator
1466  * @entry: the TT global entry to check
1467  * @orig_node: the originator to search in the list
1468  * @flags: a pointer to store TT flags for the given @entry received
1469  *  from @orig_node
1470  *
1471  * find out if an orig_node is already in the list of a tt_global_entry.
1472  *
1473  * Return: true if found, false otherwise
1474  */
1475 static bool
1476 batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,
1477                                 const struct batadv_orig_node *orig_node,
1478                                 u8 *flags)
1479 {
1480         struct batadv_tt_orig_list_entry *orig_entry;
1481         bool found = false;
1482
1483         orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node);
1484         if (orig_entry) {
1485                 found = true;
1486
1487                 if (flags)
1488                         *flags = orig_entry->flags;
1489
1490                 batadv_tt_orig_list_entry_put(orig_entry);
1491         }
1492
1493         return found;
1494 }
1495
1496 /**
1497  * batadv_tt_global_sync_flags() - update TT sync flags
1498  * @tt_global: the TT global entry to update sync flags in
1499  *
1500  * Updates the sync flag bits in the tt_global flag attribute with a logical
1501  * OR of all sync flags from any of its TT orig entries.
1502  */
1503 static void
1504 batadv_tt_global_sync_flags(struct batadv_tt_global_entry *tt_global)
1505 {
1506         struct batadv_tt_orig_list_entry *orig_entry;
1507         const struct hlist_head *head;
1508         u16 flags = BATADV_NO_FLAGS;
1509
1510         rcu_read_lock();
1511         head = &tt_global->orig_list;
1512         hlist_for_each_entry_rcu(orig_entry, head, list)
1513                 flags |= orig_entry->flags;
1514         rcu_read_unlock();
1515
1516         flags |= tt_global->common.flags & (~BATADV_TT_SYNC_MASK);
1517         tt_global->common.flags = flags;
1518 }
1519
1520 /**
1521  * batadv_tt_global_orig_entry_add() - add or update a TT orig entry
1522  * @tt_global: the TT global entry to add an orig entry in
1523  * @orig_node: the originator to add an orig entry for
1524  * @ttvn: translation table version number of this changeset
1525  * @flags: TT sync flags
1526  */
1527 static void
1528 batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
1529                                 struct batadv_orig_node *orig_node, int ttvn,
1530                                 u8 flags)
1531 {
1532         struct batadv_tt_orig_list_entry *orig_entry;
1533
1534         spin_lock_bh(&tt_global->list_lock);
1535
1536         orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);
1537         if (orig_entry) {
1538                 /* refresh the ttvn: the current value could be a bogus one that
1539                  * was added during a "temporary client detection"
1540                  */
1541                 orig_entry->ttvn = ttvn;
1542                 orig_entry->flags = flags;
1543                 goto sync_flags;
1544         }
1545
1546         orig_entry = kmem_cache_zalloc(batadv_tt_orig_cache, GFP_ATOMIC);
1547         if (!orig_entry)
1548                 goto out;
1549
1550         INIT_HLIST_NODE(&orig_entry->list);
1551         kref_get(&orig_node->refcount);
1552         batadv_tt_global_size_inc(orig_node, tt_global->common.vid);
1553         orig_entry->orig_node = orig_node;
1554         orig_entry->ttvn = ttvn;
1555         orig_entry->flags = flags;
1556         kref_init(&orig_entry->refcount);
1557
1558         kref_get(&orig_entry->refcount);
1559         hlist_add_head_rcu(&orig_entry->list,
1560                            &tt_global->orig_list);
1561         atomic_inc(&tt_global->orig_list_count);
1562
1563 sync_flags:
1564         batadv_tt_global_sync_flags(tt_global);
1565 out:
1566         batadv_tt_orig_list_entry_put(orig_entry);
1567
1568         spin_unlock_bh(&tt_global->list_lock);
1569 }
1570
1571 /**
1572  * batadv_tt_global_add() - add a new TT global entry or update an existing one
1573  * @bat_priv: the bat priv with all the soft interface information
1574  * @orig_node: the originator announcing the client
1575  * @tt_addr: the mac address of the non-mesh client
1576  * @vid: VLAN identifier
1577  * @flags: TT flags that have to be set for this non-mesh client
1578  * @ttvn: the tt version number ever announcing this non-mesh client
1579  *
1580  * Add a new TT global entry for the given originator. If the entry already
1581  * exists add a new reference to the given originator (a global entry can have
1582  * references to multiple originators) and adjust the flags attribute to reflect
1583  * the function argument.
1584  * If a TT local entry exists for this non-mesh client remove it.
1585  *
1586  * The caller must hold the orig_node refcount.
1587  *
1588  * Return: true if the new entry has been added, false otherwise
1589  */
1590 static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
1591                                  struct batadv_orig_node *orig_node,
1592                                  const unsigned char *tt_addr,
1593                                  unsigned short vid, u16 flags, u8 ttvn)
1594 {
1595         struct batadv_tt_global_entry *tt_global_entry;
1596         struct batadv_tt_local_entry *tt_local_entry;
1597         bool ret = false;
1598         int hash_added;
1599         struct batadv_tt_common_entry *common;
1600         u16 local_flags;
1601
1602         /* ignore global entries from backbone nodes */
1603         if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))
1604                 return true;
1605
1606         tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid);
1607         tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid);
1608
1609         /* if the node already has a local client for this entry, it has to wait
1610          * for a roaming advertisement instead of manually messing up the global
1611          * table
1612          */
1613         if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry &&
1614             !(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW))
1615                 goto out;
1616
1617         if (!tt_global_entry) {
1618                 tt_global_entry = kmem_cache_zalloc(batadv_tg_cache,
1619                                                     GFP_ATOMIC);
1620                 if (!tt_global_entry)
1621                         goto out;
1622
1623                 common = &tt_global_entry->common;
1624                 ether_addr_copy(common->addr, tt_addr);
1625                 common->vid = vid;
1626
1627                 if (!is_multicast_ether_addr(common->addr))
1628                         common->flags = flags & (~BATADV_TT_SYNC_MASK);
1629
1630                 tt_global_entry->roam_at = 0;
1631                 /* node must store current time in case of roaming. This is
1632                  * needed to purge this entry out on timeout (if nobody claims
1633                  * it)
1634                  */
1635                 if (flags & BATADV_TT_CLIENT_ROAM)
1636                         tt_global_entry->roam_at = jiffies;
1637                 kref_init(&common->refcount);
1638                 common->added_at = jiffies;
1639
1640                 INIT_HLIST_HEAD(&tt_global_entry->orig_list);
1641                 atomic_set(&tt_global_entry->orig_list_count, 0);
1642                 spin_lock_init(&tt_global_entry->list_lock);
1643
1644                 kref_get(&common->refcount);
1645                 hash_added = batadv_hash_add(bat_priv->tt.global_hash,
1646                                              batadv_compare_tt,
1647                                              batadv_choose_tt, common,
1648                                              &common->hash_entry);
1649
1650                 if (unlikely(hash_added != 0)) {
1651                         /* remove the reference for the hash */
1652                         batadv_tt_global_entry_put(tt_global_entry);
1653                         goto out_remove;
1654                 }
1655         } else {
1656                 common = &tt_global_entry->common;
1657                 /* If there is already a global entry, we can use this one for
1658                  * our processing.
1659                  * But if we are trying to add a temporary client then here are
1660                  * two options at this point:
1661                  * 1) the global client is not a temporary client: the global
1662                  *    client has to be left as it is, temporary information
1663                  *    should never override any already known client state
1664                  * 2) the global client is a temporary client: purge the
1665                  *    originator list and add the new one orig_entry
1666                  */
1667                 if (flags & BATADV_TT_CLIENT_TEMP) {
1668                         if (!(common->flags & BATADV_TT_CLIENT_TEMP))
1669                                 goto out;
1670                         if (batadv_tt_global_entry_has_orig(tt_global_entry,
1671                                                             orig_node, NULL))
1672                                 goto out_remove;
1673                         batadv_tt_global_del_orig_list(tt_global_entry);
1674                         goto add_orig_entry;
1675                 }
1676
1677                 /* if the client was temporary added before receiving the first
1678                  * OGM announcing it, we have to clear the TEMP flag. Also,
1679                  * remove the previous temporary orig node and re-add it
1680                  * if required. If the orig entry changed, the new one which
1681                  * is a non-temporary entry is preferred.
1682                  */
1683                 if (common->flags & BATADV_TT_CLIENT_TEMP) {
1684                         batadv_tt_global_del_orig_list(tt_global_entry);
1685                         common->flags &= ~BATADV_TT_CLIENT_TEMP;
1686                 }
1687
1688                 /* the change can carry possible "attribute" flags like the
1689                  * TT_CLIENT_TEMP, therefore they have to be copied in the
1690                  * client entry
1691                  */
1692                 if (!is_multicast_ether_addr(common->addr))
1693                         common->flags |= flags & (~BATADV_TT_SYNC_MASK);
1694
1695                 /* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only
1696                  * one originator left in the list and we previously received a
1697                  * delete + roaming change for this originator.
1698                  *
1699                  * We should first delete the old originator before adding the
1700                  * new one.
1701                  */
1702                 if (common->flags & BATADV_TT_CLIENT_ROAM) {
1703                         batadv_tt_global_del_orig_list(tt_global_entry);
1704                         common->flags &= ~BATADV_TT_CLIENT_ROAM;
1705                         tt_global_entry->roam_at = 0;
1706                 }
1707         }
1708 add_orig_entry:
1709         /* add the new orig_entry (if needed) or update it */
1710         batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn,
1711                                         flags & BATADV_TT_SYNC_MASK);
1712
1713         batadv_dbg(BATADV_DBG_TT, bat_priv,
1714                    "Creating new global tt entry: %pM (vid: %d, via %pM)\n",
1715                    common->addr, batadv_print_vid(common->vid),
1716                    orig_node->orig);
1717         ret = true;
1718
1719 out_remove:
1720         /* Do not remove multicast addresses from the local hash on
1721          * global additions
1722          */
1723         if (is_multicast_ether_addr(tt_addr))
1724                 goto out;
1725
1726         /* remove address from local hash if present */
1727         local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,
1728                                              "global tt received",
1729                                              flags & BATADV_TT_CLIENT_ROAM);
1730         tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;
1731
1732         if (!(flags & BATADV_TT_CLIENT_ROAM))
1733                 /* this is a normal global add. Therefore the client is not in a
1734                  * roaming state anymore.
1735                  */
1736                 tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;
1737
1738 out:
1739         batadv_tt_global_entry_put(tt_global_entry);
1740         batadv_tt_local_entry_put(tt_local_entry);
1741         return ret;
1742 }
1743
1744 /**
1745  * batadv_transtable_best_orig() - Get best originator list entry from tt entry
1746  * @bat_priv: the bat priv with all the soft interface information
1747  * @tt_global_entry: global translation table entry to be analyzed
1748  *
1749  * This function assumes the caller holds rcu_read_lock().
1750  * Return: best originator list entry or NULL on errors.
1751  */
1752 static struct batadv_tt_orig_list_entry *
1753 batadv_transtable_best_orig(struct batadv_priv *bat_priv,
1754                             struct batadv_tt_global_entry *tt_global_entry)
1755 {
1756         struct batadv_neigh_node *router, *best_router = NULL;
1757         struct batadv_algo_ops *bao = bat_priv->algo_ops;
1758         struct hlist_head *head;
1759         struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;
1760
1761         head = &tt_global_entry->orig_list;
1762         hlist_for_each_entry_rcu(orig_entry, head, list) {
1763                 router = batadv_orig_router_get(orig_entry->orig_node,
1764                                                 BATADV_IF_DEFAULT);
1765                 if (!router)
1766                         continue;
1767
1768                 if (best_router &&
1769                     bao->neigh.cmp(router, BATADV_IF_DEFAULT, best_router,
1770                                    BATADV_IF_DEFAULT) <= 0) {
1771                         batadv_neigh_node_put(router);
1772                         continue;
1773                 }
1774
1775                 /* release the refcount for the "old" best */
1776                 batadv_neigh_node_put(best_router);
1777
1778                 best_entry = orig_entry;
1779                 best_router = router;
1780         }
1781
1782         batadv_neigh_node_put(best_router);
1783
1784         return best_entry;
1785 }
1786
1787 /**
1788  * batadv_tt_global_dump_subentry() - Dump all TT local entries into a message
1789  * @msg: Netlink message to dump into
1790  * @portid: Port making netlink request
1791  * @seq: Sequence number of netlink message
1792  * @common: tt local & tt global common data
1793  * @orig: Originator node announcing a non-mesh client
1794  * @best: Is the best originator for the TT entry
1795  *
1796  * Return: Error code, or 0 on success
1797  */
1798 static int
1799 batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
1800                                struct batadv_tt_common_entry *common,
1801                                struct batadv_tt_orig_list_entry *orig,
1802                                bool best)
1803 {
1804         u16 flags = (common->flags & (~BATADV_TT_SYNC_MASK)) | orig->flags;
1805         void *hdr;
1806         struct batadv_orig_node_vlan *vlan;
1807         u8 last_ttvn;
1808         u32 crc;
1809
1810         vlan = batadv_orig_node_vlan_get(orig->orig_node,
1811                                          common->vid);
1812         if (!vlan)
1813                 return 0;
1814
1815         crc = vlan->tt.crc;
1816
1817         batadv_orig_node_vlan_put(vlan);
1818
1819         hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
1820                           NLM_F_MULTI,
1821                           BATADV_CMD_GET_TRANSTABLE_GLOBAL);
1822         if (!hdr)
1823                 return -ENOBUFS;
1824
1825         last_ttvn = atomic_read(&orig->orig_node->last_ttvn);
1826
1827         if (nla_put(msg, BATADV_ATTR_TT_ADDRESS, ETH_ALEN, common->addr) ||
1828             nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
1829                     orig->orig_node->orig) ||
1830             nla_put_u8(msg, BATADV_ATTR_TT_TTVN, orig->ttvn) ||
1831             nla_put_u8(msg, BATADV_ATTR_TT_LAST_TTVN, last_ttvn) ||
1832             nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) ||
1833             nla_put_u16(msg, BATADV_ATTR_TT_VID, common->vid) ||
1834             nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, flags))
1835                 goto nla_put_failure;
1836
1837         if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
1838                 goto nla_put_failure;
1839
1840         genlmsg_end(msg, hdr);
1841         return 0;
1842
1843  nla_put_failure:
1844         genlmsg_cancel(msg, hdr);
1845         return -EMSGSIZE;
1846 }
1847
1848 /**
1849  * batadv_tt_global_dump_entry() - Dump one TT global entry into a message
1850  * @msg: Netlink message to dump into
1851  * @portid: Port making netlink request
1852  * @seq: Sequence number of netlink message
1853  * @bat_priv: The bat priv with all the soft interface information
1854  * @common: tt local & tt global common data
1855  * @sub_s: Number of entries to skip
1856  *
1857  * This function assumes the caller holds rcu_read_lock().
1858  *
1859  * Return: Error code, or 0 on success
1860  */
1861 static int
1862 batadv_tt_global_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
1863                             struct batadv_priv *bat_priv,
1864                             struct batadv_tt_common_entry *common, int *sub_s)
1865 {
1866         struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
1867         struct batadv_tt_global_entry *global;
1868         struct hlist_head *head;
1869         int sub = 0;
1870         bool best;
1871
1872         global = container_of(common, struct batadv_tt_global_entry, common);
1873         best_entry = batadv_transtable_best_orig(bat_priv, global);
1874         head = &global->orig_list;
1875
1876         hlist_for_each_entry_rcu(orig_entry, head, list) {
1877                 if (sub++ < *sub_s)
1878                         continue;
1879
1880                 best = (orig_entry == best_entry);
1881
1882                 if (batadv_tt_global_dump_subentry(msg, portid, seq, common,
1883                                                    orig_entry, best)) {
1884                         *sub_s = sub - 1;
1885                         return -EMSGSIZE;
1886                 }
1887         }
1888
1889         *sub_s = 0;
1890         return 0;
1891 }
1892
1893 /**
1894  * batadv_tt_global_dump_bucket() - Dump one TT local bucket into a message
1895  * @msg: Netlink message to dump into
1896  * @portid: Port making netlink request
1897  * @seq: Sequence number of netlink message
1898  * @bat_priv: The bat priv with all the soft interface information
1899  * @head: Pointer to the list containing the global tt entries
1900  * @idx_s: Number of entries to skip
1901  * @sub: Number of entries to skip
1902  *
1903  * Return: Error code, or 0 on success
1904  */
1905 static int
1906 batadv_tt_global_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
1907                              struct batadv_priv *bat_priv,
1908                              struct hlist_head *head, int *idx_s, int *sub)
1909 {
1910         struct batadv_tt_common_entry *common;
1911         int idx = 0;
1912
1913         rcu_read_lock();
1914         hlist_for_each_entry_rcu(common, head, hash_entry) {
1915                 if (idx++ < *idx_s)
1916                         continue;
1917
1918                 if (batadv_tt_global_dump_entry(msg, portid, seq, bat_priv,
1919                                                 common, sub)) {
1920                         rcu_read_unlock();
1921                         *idx_s = idx - 1;
1922                         return -EMSGSIZE;
1923                 }
1924         }
1925         rcu_read_unlock();
1926
1927         *idx_s = 0;
1928         *sub = 0;
1929         return 0;
1930 }
1931
1932 /**
1933  * batadv_tt_global_dump() -  Dump TT global entries into a message
1934  * @msg: Netlink message to dump into
1935  * @cb: Parameters from query
1936  *
1937  * Return: Error code, or length of message on success
1938  */
1939 int batadv_tt_global_dump(struct sk_buff *msg, struct netlink_callback *cb)
1940 {
1941         struct net *net = sock_net(cb->skb->sk);
1942         struct net_device *soft_iface;
1943         struct batadv_priv *bat_priv;
1944         struct batadv_hard_iface *primary_if = NULL;
1945         struct batadv_hashtable *hash;
1946         struct hlist_head *head;
1947         int ret;
1948         int ifindex;
1949         int bucket = cb->args[0];
1950         int idx = cb->args[1];
1951         int sub = cb->args[2];
1952         int portid = NETLINK_CB(cb->skb).portid;
1953
1954         ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
1955         if (!ifindex)
1956                 return -EINVAL;
1957
1958         soft_iface = dev_get_by_index(net, ifindex);
1959         if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
1960                 ret = -ENODEV;
1961                 goto out;
1962         }
1963
1964         bat_priv = netdev_priv(soft_iface);
1965
1966         primary_if = batadv_primary_if_get_selected(bat_priv);
1967         if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
1968                 ret = -ENOENT;
1969                 goto out;
1970         }
1971
1972         hash = bat_priv->tt.global_hash;
1973
1974         while (bucket < hash->size) {
1975                 head = &hash->table[bucket];
1976
1977                 if (batadv_tt_global_dump_bucket(msg, portid,
1978                                                  cb->nlh->nlmsg_seq, bat_priv,
1979                                                  head, &idx, &sub))
1980                         break;
1981
1982                 bucket++;
1983         }
1984
1985         ret = msg->len;
1986
1987  out:
1988         batadv_hardif_put(primary_if);
1989         dev_put(soft_iface);
1990
1991         cb->args[0] = bucket;
1992         cb->args[1] = idx;
1993         cb->args[2] = sub;
1994
1995         return ret;
1996 }
1997
1998 /**
1999  * _batadv_tt_global_del_orig_entry() - remove and free an orig_entry
2000  * @tt_global_entry: the global entry to remove the orig_entry from
2001  * @orig_entry: the orig entry to remove and free
2002  *
2003  * Remove an orig_entry from its list in the given tt_global_entry and
2004  * free this orig_entry afterwards.
2005  *
2006  * Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is
2007  * part of a list.
2008  */
2009 static void
2010 _batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,
2011                                  struct batadv_tt_orig_list_entry *orig_entry)
2012 {
2013         lockdep_assert_held(&tt_global_entry->list_lock);
2014
2015         batadv_tt_global_size_dec(orig_entry->orig_node,
2016                                   tt_global_entry->common.vid);
2017         atomic_dec(&tt_global_entry->orig_list_count);
2018         /* requires holding tt_global_entry->list_lock and orig_entry->list
2019          * being part of a list
2020          */
2021         hlist_del_rcu(&orig_entry->list);
2022         batadv_tt_orig_list_entry_put(orig_entry);
2023 }
2024
2025 /* deletes the orig list of a tt_global_entry */
2026 static void
2027 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)
2028 {
2029         struct hlist_head *head;
2030         struct hlist_node *safe;
2031         struct batadv_tt_orig_list_entry *orig_entry;
2032
2033         spin_lock_bh(&tt_global_entry->list_lock);
2034         head = &tt_global_entry->orig_list;
2035         hlist_for_each_entry_safe(orig_entry, safe, head, list)
2036                 _batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry);
2037         spin_unlock_bh(&tt_global_entry->list_lock);
2038 }
2039
2040 /**
2041  * batadv_tt_global_del_orig_node() - remove orig_node from a global tt entry
2042  * @bat_priv: the bat priv with all the soft interface information
2043  * @tt_global_entry: the global entry to remove the orig_node from
2044  * @orig_node: the originator announcing the client
2045  * @message: message to append to the log on deletion
2046  *
2047  * Remove the given orig_node and its according orig_entry from the given
2048  * global tt entry.
2049  */
2050 static void
2051 batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv,
2052                                struct batadv_tt_global_entry *tt_global_entry,
2053                                struct batadv_orig_node *orig_node,
2054                                const char *message)
2055 {
2056         struct hlist_head *head;
2057         struct hlist_node *safe;
2058         struct batadv_tt_orig_list_entry *orig_entry;
2059         unsigned short vid;
2060
2061         spin_lock_bh(&tt_global_entry->list_lock);
2062         head = &tt_global_entry->orig_list;
2063         hlist_for_each_entry_safe(orig_entry, safe, head, list) {
2064                 if (orig_entry->orig_node == orig_node) {
2065                         vid = tt_global_entry->common.vid;
2066                         batadv_dbg(BATADV_DBG_TT, bat_priv,
2067                                    "Deleting %pM from global tt entry %pM (vid: %d): %s\n",
2068                                    orig_node->orig,
2069                                    tt_global_entry->common.addr,
2070                                    batadv_print_vid(vid), message);
2071                         _batadv_tt_global_del_orig_entry(tt_global_entry,
2072                                                          orig_entry);
2073                 }
2074         }
2075         spin_unlock_bh(&tt_global_entry->list_lock);
2076 }
2077
2078 /* If the client is to be deleted, we check if it is the last origantor entry
2079  * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the
2080  * timer, otherwise we simply remove the originator scheduled for deletion.
2081  */
2082 static void
2083 batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
2084                              struct batadv_tt_global_entry *tt_global_entry,
2085                              struct batadv_orig_node *orig_node,
2086                              const char *message)
2087 {
2088         bool last_entry = true;
2089         struct hlist_head *head;
2090         struct batadv_tt_orig_list_entry *orig_entry;
2091
2092         /* no local entry exists, case 1:
2093          * Check if this is the last one or if other entries exist.
2094          */
2095
2096         rcu_read_lock();
2097         head = &tt_global_entry->orig_list;
2098         hlist_for_each_entry_rcu(orig_entry, head, list) {
2099                 if (orig_entry->orig_node != orig_node) {
2100                         last_entry = false;
2101                         break;
2102                 }
2103         }
2104         rcu_read_unlock();
2105
2106         if (last_entry) {
2107                 /* its the last one, mark for roaming. */
2108                 tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
2109                 tt_global_entry->roam_at = jiffies;
2110         } else {
2111                 /* there is another entry, we can simply delete this
2112                  * one and can still use the other one.
2113                  */
2114                 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
2115                                                orig_node, message);
2116         }
2117 }
2118
2119 /**
2120  * batadv_tt_global_del() - remove a client from the global table
2121  * @bat_priv: the bat priv with all the soft interface information
2122  * @orig_node: an originator serving this client
2123  * @addr: the mac address of the client
2124  * @vid: VLAN identifier
2125  * @message: a message explaining the reason for deleting the client to print
2126  *  for debugging purpose
2127  * @roaming: true if the deletion has been triggered by a roaming event
2128  */
2129 static void batadv_tt_global_del(struct batadv_priv *bat_priv,
2130                                  struct batadv_orig_node *orig_node,
2131                                  const unsigned char *addr, unsigned short vid,
2132                                  const char *message, bool roaming)
2133 {
2134         struct batadv_tt_global_entry *tt_global_entry;
2135         struct batadv_tt_local_entry *local_entry = NULL;
2136
2137         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
2138         if (!tt_global_entry)
2139                 goto out;
2140
2141         if (!roaming) {
2142                 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
2143                                                orig_node, message);
2144
2145                 if (hlist_empty(&tt_global_entry->orig_list))
2146                         batadv_tt_global_free(bat_priv, tt_global_entry,
2147                                               message);
2148
2149                 goto out;
2150         }
2151
2152         /* if we are deleting a global entry due to a roam
2153          * event, there are two possibilities:
2154          * 1) the client roamed from node A to node B => if there
2155          *    is only one originator left for this client, we mark
2156          *    it with BATADV_TT_CLIENT_ROAM, we start a timer and we
2157          *    wait for node B to claim it. In case of timeout
2158          *    the entry is purged.
2159          *
2160          *    If there are other originators left, we directly delete
2161          *    the originator.
2162          * 2) the client roamed to us => we can directly delete
2163          *    the global entry, since it is useless now.
2164          */
2165         local_entry = batadv_tt_local_hash_find(bat_priv,
2166                                                 tt_global_entry->common.addr,
2167                                                 vid);
2168         if (local_entry) {
2169                 /* local entry exists, case 2: client roamed to us. */
2170                 batadv_tt_global_del_orig_list(tt_global_entry);
2171                 batadv_tt_global_free(bat_priv, tt_global_entry, message);
2172         } else {
2173                 /* no local entry exists, case 1: check for roaming */
2174                 batadv_tt_global_del_roaming(bat_priv, tt_global_entry,
2175                                              orig_node, message);
2176         }
2177
2178 out:
2179         batadv_tt_global_entry_put(tt_global_entry);
2180         batadv_tt_local_entry_put(local_entry);
2181 }
2182
2183 /**
2184  * batadv_tt_global_del_orig() - remove all the TT global entries belonging to
2185  *  the given originator matching the provided vid
2186  * @bat_priv: the bat priv with all the soft interface information
2187  * @orig_node: the originator owning the entries to remove
2188  * @match_vid: the VLAN identifier to match. If negative all the entries will be
2189  *  removed
2190  * @message: debug message to print as "reason"
2191  */
2192 void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
2193                                struct batadv_orig_node *orig_node,
2194                                s32 match_vid,
2195                                const char *message)
2196 {
2197         struct batadv_tt_global_entry *tt_global;
2198         struct batadv_tt_common_entry *tt_common_entry;
2199         u32 i;
2200         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2201         struct hlist_node *safe;
2202         struct hlist_head *head;
2203         spinlock_t *list_lock; /* protects write access to the hash lists */
2204         unsigned short vid;
2205
2206         if (!hash)
2207                 return;
2208
2209         for (i = 0; i < hash->size; i++) {
2210                 head = &hash->table[i];
2211                 list_lock = &hash->list_locks[i];
2212
2213                 spin_lock_bh(list_lock);
2214                 hlist_for_each_entry_safe(tt_common_entry, safe,
2215                                           head, hash_entry) {
2216                         /* remove only matching entries */
2217                         if (match_vid >= 0 && tt_common_entry->vid != match_vid)
2218                                 continue;
2219
2220                         tt_global = container_of(tt_common_entry,
2221                                                  struct batadv_tt_global_entry,
2222                                                  common);
2223
2224                         batadv_tt_global_del_orig_node(bat_priv, tt_global,
2225                                                        orig_node, message);
2226
2227                         if (hlist_empty(&tt_global->orig_list)) {
2228                                 vid = tt_global->common.vid;
2229                                 batadv_dbg(BATADV_DBG_TT, bat_priv,
2230                                            "Deleting global tt entry %pM (vid: %d): %s\n",
2231                                            tt_global->common.addr,
2232                                            batadv_print_vid(vid), message);
2233                                 hlist_del_rcu(&tt_common_entry->hash_entry);
2234                                 batadv_tt_global_entry_put(tt_global);
2235                         }
2236                 }
2237                 spin_unlock_bh(list_lock);
2238         }
2239         clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
2240 }
2241
2242 static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,
2243                                       char **msg)
2244 {
2245         bool purge = false;
2246         unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;
2247         unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;
2248
2249         if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) &&
2250             batadv_has_timed_out(tt_global->roam_at, roam_timeout)) {
2251                 purge = true;
2252                 *msg = "Roaming timeout\n";
2253         }
2254
2255         if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) &&
2256             batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) {
2257                 purge = true;
2258                 *msg = "Temporary client timeout\n";
2259         }
2260
2261         return purge;
2262 }
2263
2264 static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
2265 {
2266         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2267         struct hlist_head *head;
2268         struct hlist_node *node_tmp;
2269         spinlock_t *list_lock; /* protects write access to the hash lists */
2270         u32 i;
2271         char *msg = NULL;
2272         struct batadv_tt_common_entry *tt_common;
2273         struct batadv_tt_global_entry *tt_global;
2274
2275         for (i = 0; i < hash->size; i++) {
2276                 head = &hash->table[i];
2277                 list_lock = &hash->list_locks[i];
2278
2279                 spin_lock_bh(list_lock);
2280                 hlist_for_each_entry_safe(tt_common, node_tmp, head,
2281                                           hash_entry) {
2282                         tt_global = container_of(tt_common,
2283                                                  struct batadv_tt_global_entry,
2284                                                  common);
2285
2286                         if (!batadv_tt_global_to_purge(tt_global, &msg))
2287                                 continue;
2288
2289                         batadv_dbg(BATADV_DBG_TT, bat_priv,
2290                                    "Deleting global tt entry %pM (vid: %d): %s\n",
2291                                    tt_global->common.addr,
2292                                    batadv_print_vid(tt_global->common.vid),
2293                                    msg);
2294
2295                         hlist_del_rcu(&tt_common->hash_entry);
2296
2297                         batadv_tt_global_entry_put(tt_global);
2298                 }
2299                 spin_unlock_bh(list_lock);
2300         }
2301 }
2302
2303 static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
2304 {
2305         struct batadv_hashtable *hash;
2306         spinlock_t *list_lock; /* protects write access to the hash lists */
2307         struct batadv_tt_common_entry *tt_common_entry;
2308         struct batadv_tt_global_entry *tt_global;
2309         struct hlist_node *node_tmp;
2310         struct hlist_head *head;
2311         u32 i;
2312
2313         if (!bat_priv->tt.global_hash)
2314                 return;
2315
2316         hash = bat_priv->tt.global_hash;
2317
2318         for (i = 0; i < hash->size; i++) {
2319                 head = &hash->table[i];
2320                 list_lock = &hash->list_locks[i];
2321
2322                 spin_lock_bh(list_lock);
2323                 hlist_for_each_entry_safe(tt_common_entry, node_tmp,
2324                                           head, hash_entry) {
2325                         hlist_del_rcu(&tt_common_entry->hash_entry);
2326                         tt_global = container_of(tt_common_entry,
2327                                                  struct batadv_tt_global_entry,
2328                                                  common);
2329                         batadv_tt_global_entry_put(tt_global);
2330                 }
2331                 spin_unlock_bh(list_lock);
2332         }
2333
2334         batadv_hash_destroy(hash);
2335
2336         bat_priv->tt.global_hash = NULL;
2337 }
2338
2339 static bool
2340 _batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,
2341                        struct batadv_tt_global_entry *tt_global_entry)
2342 {
2343         if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&
2344             tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)
2345                 return true;
2346
2347         /* check if the two clients are marked as isolated */
2348         if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA &&
2349             tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA)
2350                 return true;
2351
2352         return false;
2353 }
2354
2355 /**
2356  * batadv_transtable_search() - get the mesh destination for a given client
2357  * @bat_priv: the bat priv with all the soft interface information
2358  * @src: mac address of the source client
2359  * @addr: mac address of the destination client
2360  * @vid: VLAN identifier
2361  *
2362  * Return: a pointer to the originator that was selected as destination in the
2363  * mesh for contacting the client 'addr', NULL otherwise.
2364  * In case of multiple originators serving the same client, the function returns
2365  * the best one (best in terms of metric towards the destination node).
2366  *
2367  * If the two clients are AP isolated the function returns NULL.
2368  */
2369 struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
2370                                                   const u8 *src,
2371                                                   const u8 *addr,
2372                                                   unsigned short vid)
2373 {
2374         struct batadv_tt_local_entry *tt_local_entry = NULL;
2375         struct batadv_tt_global_entry *tt_global_entry = NULL;
2376         struct batadv_orig_node *orig_node = NULL;
2377         struct batadv_tt_orig_list_entry *best_entry;
2378
2379         if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) {
2380                 tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid);
2381                 if (!tt_local_entry ||
2382                     (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING))
2383                         goto out;
2384         }
2385
2386         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
2387         if (!tt_global_entry)
2388                 goto out;
2389
2390         /* check whether the clients should not communicate due to AP
2391          * isolation
2392          */
2393         if (tt_local_entry &&
2394             _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
2395                 goto out;
2396
2397         rcu_read_lock();
2398         best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
2399         /* found anything? */
2400         if (best_entry)
2401                 orig_node = best_entry->orig_node;
2402         if (orig_node && !kref_get_unless_zero(&orig_node->refcount))
2403                 orig_node = NULL;
2404         rcu_read_unlock();
2405
2406 out:
2407         batadv_tt_global_entry_put(tt_global_entry);
2408         batadv_tt_local_entry_put(tt_local_entry);
2409
2410         return orig_node;
2411 }
2412
2413 /**
2414  * batadv_tt_global_crc() - calculates the checksum of the local table belonging
2415  *  to the given orig_node
2416  * @bat_priv: the bat priv with all the soft interface information
2417  * @orig_node: originator for which the CRC should be computed
2418  * @vid: VLAN identifier for which the CRC32 has to be computed
2419  *
2420  * This function computes the checksum for the global table corresponding to a
2421  * specific originator. In particular, the checksum is computed as follows: For
2422  * each client connected to the originator the CRC32C of the MAC address and the
2423  * VID is computed and then all the CRC32Cs of the various clients are xor'ed
2424  * together.
2425  *
2426  * The idea behind is that CRC32C should be used as much as possible in order to
2427  * produce a unique hash of the table, but since the order which is used to feed
2428  * the CRC32C function affects the result and since every node in the network
2429  * probably sorts the clients differently, the hash function cannot be directly
2430  * computed over the entire table. Hence the CRC32C is used only on
2431  * the single client entry, while all the results are then xor'ed together
2432  * because the XOR operation can combine them all while trying to reduce the
2433  * noise as much as possible.
2434  *
2435  * Return: the checksum of the global table of a given originator.
2436  */
2437 static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,
2438                                 struct batadv_orig_node *orig_node,
2439                                 unsigned short vid)
2440 {
2441         struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2442         struct batadv_tt_orig_list_entry *tt_orig;
2443         struct batadv_tt_common_entry *tt_common;
2444         struct batadv_tt_global_entry *tt_global;
2445         struct hlist_head *head;
2446         u32 i, crc_tmp, crc = 0;
2447         u8 flags;
2448         __be16 tmp_vid;
2449
2450         for (i = 0; i < hash->size; i++) {
2451                 head = &hash->table[i];
2452
2453                 rcu_read_lock();
2454                 hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2455                         tt_global = container_of(tt_common,
2456                                                  struct batadv_tt_global_entry,
2457                                                  common);
2458                         /* compute the CRC only for entries belonging to the
2459                          * VLAN identified by the vid passed as parameter
2460                          */
2461                         if (tt_common->vid != vid)
2462                                 continue;
2463
2464                         /* Roaming clients are in the global table for
2465                          * consistency only. They don't have to be
2466                          * taken into account while computing the
2467                          * global crc
2468                          */
2469                         if (tt_common->flags & BATADV_TT_CLIENT_ROAM)
2470                                 continue;
2471                         /* Temporary clients have not been announced yet, so
2472                          * they have to be skipped while computing the global
2473                          * crc
2474                          */
2475                         if (tt_common->flags & BATADV_TT_CLIENT_TEMP)
2476                                 continue;
2477
2478                         /* find out if this global entry is announced by this
2479                          * originator
2480                          */
2481                         tt_orig = batadv_tt_global_orig_entry_find(tt_global,
2482                                                                    orig_node);
2483                         if (!tt_orig)
2484                                 continue;
2485
2486                         /* use network order to read the VID: this ensures that
2487                          * every node reads the bytes in the same order.
2488                          */
2489                         tmp_vid = htons(tt_common->vid);
2490                         crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2491
2492                         /* compute the CRC on flags that have to be kept in sync
2493                          * among nodes
2494                          */
2495                         flags = tt_orig->flags;
2496                         crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
2497
2498                         crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2499
2500                         batadv_tt_orig_list_entry_put(tt_orig);
2501                 }
2502                 rcu_read_unlock();
2503         }
2504
2505         return crc;
2506 }
2507
2508 /**
2509  * batadv_tt_local_crc() - calculates the checksum of the local table
2510  * @bat_priv: the bat priv with all the soft interface information
2511  * @vid: VLAN identifier for which the CRC32 has to be computed
2512  *
2513  * For details about the computation, please refer to the documentation for
2514  * batadv_tt_global_crc().
2515  *
2516  * Return: the checksum of the local table
2517  */
2518 static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv,
2519                                unsigned short vid)
2520 {
2521         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
2522         struct batadv_tt_common_entry *tt_common;
2523         struct hlist_head *head;
2524         u32 i, crc_tmp, crc = 0;
2525         u8 flags;
2526         __be16 tmp_vid;
2527
2528         for (i = 0; i < hash->size; i++) {
2529                 head = &hash->table[i];
2530
2531                 rcu_read_lock();
2532                 hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2533                         /* compute the CRC only for entries belonging to the
2534                          * VLAN identified by vid
2535                          */
2536                         if (tt_common->vid != vid)
2537                                 continue;
2538
2539                         /* not yet committed clients have not to be taken into
2540                          * account while computing the CRC
2541                          */
2542                         if (tt_common->flags & BATADV_TT_CLIENT_NEW)
2543                                 continue;
2544
2545                         /* use network order to read the VID: this ensures that
2546                          * every node reads the bytes in the same order.
2547                          */
2548                         tmp_vid = htons(tt_common->vid);
2549                         crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2550
2551                         /* compute the CRC on flags that have to be kept in sync
2552                          * among nodes
2553                          */
2554                         flags = tt_common->flags & BATADV_TT_SYNC_MASK;
2555                         crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
2556
2557                         crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2558                 }
2559                 rcu_read_unlock();
2560         }
2561
2562         return crc;
2563 }
2564
2565 /**
2566  * batadv_tt_req_node_release() - free tt_req node entry
2567  * @ref: kref pointer of the tt req_node entry
2568  */
2569 static void batadv_tt_req_node_release(struct kref *ref)
2570 {
2571         struct batadv_tt_req_node *tt_req_node;
2572
2573         tt_req_node = container_of(ref, struct batadv_tt_req_node, refcount);
2574
2575         kmem_cache_free(batadv_tt_req_cache, tt_req_node);
2576 }
2577
2578 /**
2579  * batadv_tt_req_node_put() - decrement the tt_req_node refcounter and
2580  *  possibly release it
2581  * @tt_req_node: tt_req_node to be free'd
2582  */
2583 static void batadv_tt_req_node_put(struct batadv_tt_req_node *tt_req_node)
2584 {
2585         if (!tt_req_node)
2586                 return;
2587
2588         kref_put(&tt_req_node->refcount, batadv_tt_req_node_release);
2589 }
2590
2591 static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)
2592 {
2593         struct batadv_tt_req_node *node;
2594         struct hlist_node *safe;
2595
2596         spin_lock_bh(&bat_priv->tt.req_list_lock);
2597
2598         hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2599                 hlist_del_init(&node->list);
2600                 batadv_tt_req_node_put(node);
2601         }
2602
2603         spin_unlock_bh(&bat_priv->tt.req_list_lock);
2604 }
2605
2606 static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,
2607                                        struct batadv_orig_node *orig_node,
2608                                        const void *tt_buff,
2609                                        u16 tt_buff_len)
2610 {
2611         /* Replace the old buffer only if I received something in the
2612          * last OGM (the OGM could carry no changes)
2613          */
2614         spin_lock_bh(&orig_node->tt_buff_lock);
2615         if (tt_buff_len > 0) {
2616                 kfree(orig_node->tt_buff);
2617                 orig_node->tt_buff_len = 0;
2618                 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
2619                 if (orig_node->tt_buff) {
2620                         memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
2621                         orig_node->tt_buff_len = tt_buff_len;
2622                 }
2623         }
2624         spin_unlock_bh(&orig_node->tt_buff_lock);
2625 }
2626
2627 static void batadv_tt_req_purge(struct batadv_priv *bat_priv)
2628 {
2629         struct batadv_tt_req_node *node;
2630         struct hlist_node *safe;
2631
2632         spin_lock_bh(&bat_priv->tt.req_list_lock);
2633         hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2634                 if (batadv_has_timed_out(node->issued_at,
2635                                          BATADV_TT_REQUEST_TIMEOUT)) {
2636                         hlist_del_init(&node->list);
2637                         batadv_tt_req_node_put(node);
2638                 }
2639         }
2640         spin_unlock_bh(&bat_priv->tt.req_list_lock);
2641 }
2642
2643 /**
2644  * batadv_tt_req_node_new() - search and possibly create a tt_req_node object
2645  * @bat_priv: the bat priv with all the soft interface information
2646  * @orig_node: orig node this request is being issued for
2647  *
2648  * Return: the pointer to the new tt_req_node struct if no request
2649  * has already been issued for this orig_node, NULL otherwise.
2650  */
2651 static struct batadv_tt_req_node *
2652 batadv_tt_req_node_new(struct batadv_priv *bat_priv,
2653                        struct batadv_orig_node *orig_node)
2654 {
2655         struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
2656
2657         spin_lock_bh(&bat_priv->tt.req_list_lock);
2658         hlist_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {
2659                 if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&
2660                     !batadv_has_timed_out(tt_req_node_tmp->issued_at,
2661                                           BATADV_TT_REQUEST_TIMEOUT))
2662                         goto unlock;
2663         }
2664
2665         tt_req_node = kmem_cache_alloc(batadv_tt_req_cache, GFP_ATOMIC);
2666         if (!tt_req_node)
2667                 goto unlock;
2668
2669         kref_init(&tt_req_node->refcount);
2670         ether_addr_copy(tt_req_node->addr, orig_node->orig);
2671         tt_req_node->issued_at = jiffies;
2672
2673         kref_get(&tt_req_node->refcount);
2674         hlist_add_head(&tt_req_node->list, &bat_priv->tt.req_list);
2675 unlock:
2676         spin_unlock_bh(&bat_priv->tt.req_list_lock);
2677         return tt_req_node;
2678 }
2679
2680 /**
2681  * batadv_tt_local_valid() - verify local tt entry and get flags
2682  * @entry_ptr: to be checked local tt entry
2683  * @data_ptr: not used but definition required to satisfy the callback prototype
2684  * @flags: a pointer to store TT flags for this client to
2685  *
2686  * Checks the validity of the given local TT entry. If it is, then the provided
2687  * flags pointer is updated.
2688  *
2689  * Return: true if the entry is a valid, false otherwise.
2690  */
2691 static bool batadv_tt_local_valid(const void *entry_ptr,
2692                                   const void *data_ptr,
2693                                   u8 *flags)
2694 {
2695         const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2696
2697         if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
2698                 return false;
2699
2700         if (flags)
2701                 *flags = tt_common_entry->flags;
2702
2703         return true;
2704 }
2705
2706 /**
2707  * batadv_tt_global_valid() - verify global tt entry and get flags
2708  * @entry_ptr: to be checked global tt entry
2709  * @data_ptr: an orig_node object (may be NULL)
2710  * @flags: a pointer to store TT flags for this client to
2711  *
2712  * Checks the validity of the given global TT entry. If it is, then the provided
2713  * flags pointer is updated either with the common (summed) TT flags if data_ptr
2714  * is NULL or the specific, per originator TT flags otherwise.
2715  *
2716  * Return: true if the entry is a valid, false otherwise.
2717  */
2718 static bool batadv_tt_global_valid(const void *entry_ptr,
2719                                    const void *data_ptr,
2720                                    u8 *flags)
2721 {
2722         const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2723         const struct batadv_tt_global_entry *tt_global_entry;
2724         const struct batadv_orig_node *orig_node = data_ptr;
2725
2726         if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||
2727             tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)
2728                 return false;
2729
2730         tt_global_entry = container_of(tt_common_entry,
2731                                        struct batadv_tt_global_entry,
2732                                        common);
2733
2734         return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node,
2735                                                flags);
2736 }
2737
2738 /**
2739  * batadv_tt_tvlv_generate() - fill the tvlv buff with the tt entries from the
2740  *  specified tt hash
2741  * @bat_priv: the bat priv with all the soft interface information
2742  * @hash: hash table containing the tt entries
2743  * @tt_len: expected tvlv tt data buffer length in number of bytes
2744  * @tvlv_buff: pointer to the buffer to fill with the TT data
2745  * @valid_cb: function to filter tt change entries and to return TT flags
2746  * @cb_data: data passed to the filter function as argument
2747  *
2748  * Fills the tvlv buff with the tt entries from the specified hash. If valid_cb
2749  * is not provided then this becomes a no-op.
2750  */
2751 static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,
2752                                     struct batadv_hashtable *hash,
2753                                     void *tvlv_buff, u16 tt_len,
2754                                     bool (*valid_cb)(const void *,
2755                                                      const void *,
2756                                                      u8 *flags),
2757                                     void *cb_data)
2758 {
2759         struct batadv_tt_common_entry *tt_common_entry;
2760         struct batadv_tvlv_tt_change *tt_change;
2761         struct hlist_head *head;
2762         u16 tt_tot, tt_num_entries = 0;
2763         u8 flags;
2764         bool ret;
2765         u32 i;
2766
2767         tt_tot = batadv_tt_entries(tt_len);
2768         tt_change = tvlv_buff;
2769
2770         if (!valid_cb)
2771                 return;
2772
2773         rcu_read_lock();
2774         for (i = 0; i < hash->size; i++) {
2775                 head = &hash->table[i];
2776
2777                 hlist_for_each_entry_rcu(tt_common_entry,
2778                                          head, hash_entry) {
2779                         if (tt_tot == tt_num_entries)
2780                                 break;
2781
2782                         ret = valid_cb(tt_common_entry, cb_data, &flags);
2783                         if (!ret)
2784                                 continue;
2785
2786                         ether_addr_copy(tt_change->addr, tt_common_entry->addr);
2787                         tt_change->flags = flags;
2788                         tt_change->vid = htons(tt_common_entry->vid);
2789                         memset(tt_change->reserved, 0,
2790                                sizeof(tt_change->reserved));
2791
2792                         tt_num_entries++;
2793                         tt_change++;
2794                 }
2795         }
2796         rcu_read_unlock();
2797 }
2798
2799 /**
2800  * batadv_tt_global_check_crc() - check if all the CRCs are correct
2801  * @orig_node: originator for which the CRCs have to be checked
2802  * @tt_vlan: pointer to the first tvlv VLAN entry
2803  * @num_vlan: number of tvlv VLAN entries
2804  *
2805  * Return: true if all the received CRCs match the locally stored ones, false
2806  * otherwise
2807  */
2808 static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node,
2809                                        struct batadv_tvlv_tt_vlan_data *tt_vlan,
2810                                        u16 num_vlan)
2811 {
2812         struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp;
2813         struct batadv_orig_node_vlan *vlan;
2814         int i, orig_num_vlan;
2815         u32 crc;
2816
2817         /* check if each received CRC matches the locally stored one */
2818         for (i = 0; i < num_vlan; i++) {
2819                 tt_vlan_tmp = tt_vlan + i;
2820
2821                 /* if orig_node is a backbone node for this VLAN, don't check
2822                  * the CRC as we ignore all the global entries over it
2823                  */
2824                 if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv,
2825                                                    orig_node->orig,
2826                                                    ntohs(tt_vlan_tmp->vid)))
2827                         continue;
2828
2829                 vlan = batadv_orig_node_vlan_get(orig_node,
2830                                                  ntohs(tt_vlan_tmp->vid));
2831                 if (!vlan)
2832                         return false;
2833
2834                 crc = vlan->tt.crc;
2835                 batadv_orig_node_vlan_put(vlan);
2836
2837                 if (crc != ntohl(tt_vlan_tmp->crc))
2838                         return false;
2839         }
2840
2841         /* check if any excess VLANs exist locally for the originator
2842          * which are not mentioned in the TVLV from the originator.
2843          */
2844         rcu_read_lock();
2845         orig_num_vlan = 0;
2846         hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list)
2847                 orig_num_vlan++;
2848         rcu_read_unlock();
2849
2850         if (orig_num_vlan > num_vlan)
2851                 return false;
2852
2853         return true;
2854 }
2855
2856 /**
2857  * batadv_tt_local_update_crc() - update all the local CRCs
2858  * @bat_priv: the bat priv with all the soft interface information
2859  */
2860 static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv)
2861 {
2862         struct batadv_softif_vlan *vlan;
2863
2864         /* recompute the global CRC for each VLAN */
2865         rcu_read_lock();
2866         hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
2867                 vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid);
2868         }
2869         rcu_read_unlock();
2870 }
2871
2872 /**
2873  * batadv_tt_global_update_crc() - update all the global CRCs for this orig_node
2874  * @bat_priv: the bat priv with all the soft interface information
2875  * @orig_node: the orig_node for which the CRCs have to be updated
2876  */
2877 static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,
2878                                         struct batadv_orig_node *orig_node)
2879 {
2880         struct batadv_orig_node_vlan *vlan;
2881         u32 crc;
2882
2883         /* recompute the global CRC for each VLAN */
2884         rcu_read_lock();
2885         hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
2886                 /* if orig_node is a backbone node for this VLAN, don't compute
2887                  * the CRC as we ignore all the global entries over it
2888                  */
2889                 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,
2890                                                    vlan->vid))
2891                         continue;
2892
2893                 crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid);
2894                 vlan->tt.crc = crc;
2895         }
2896         rcu_read_unlock();
2897 }
2898
2899 /**
2900  * batadv_send_tt_request() - send a TT Request message to a given node
2901  * @bat_priv: the bat priv with all the soft interface information
2902  * @dst_orig_node: the destination of the message
2903  * @ttvn: the version number that the source of the message is looking for
2904  * @tt_vlan: pointer to the first tvlv VLAN object to request
2905  * @num_vlan: number of tvlv VLAN entries
2906  * @full_table: ask for the entire translation table if true, while only for the
2907  *  last TT diff otherwise
2908  *
2909  * Return: true if the TT Request was sent, false otherwise
2910  */
2911 static bool batadv_send_tt_request(struct batadv_priv *bat_priv,
2912                                    struct batadv_orig_node *dst_orig_node,
2913                                    u8 ttvn,
2914                                    struct batadv_tvlv_tt_vlan_data *tt_vlan,
2915                                    u16 num_vlan, bool full_table)
2916 {
2917         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2918         struct batadv_tt_req_node *tt_req_node = NULL;
2919         struct batadv_tvlv_tt_vlan_data *tt_vlan_req;
2920         struct batadv_hard_iface *primary_if;
2921         bool ret = false;
2922         int i, size;
2923
2924         primary_if = batadv_primary_if_get_selected(bat_priv);
2925         if (!primary_if)
2926                 goto out;
2927
2928         /* The new tt_req will be issued only if I'm not waiting for a
2929          * reply from the same orig_node yet
2930          */
2931         tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node);
2932         if (!tt_req_node)
2933                 goto out;
2934
2935         size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;
2936         tvlv_tt_data = kzalloc(size, GFP_ATOMIC);
2937         if (!tvlv_tt_data)
2938                 goto out;
2939
2940         tvlv_tt_data->flags = BATADV_TT_REQUEST;
2941         tvlv_tt_data->ttvn = ttvn;
2942         tvlv_tt_data->num_vlan = htons(num_vlan);
2943
2944         /* send all the CRCs within the request. This is needed by intermediate
2945          * nodes to ensure they have the correct table before replying
2946          */
2947         tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1);
2948         for (i = 0; i < num_vlan; i++) {
2949                 tt_vlan_req->vid = tt_vlan->vid;
2950                 tt_vlan_req->crc = tt_vlan->crc;
2951
2952                 tt_vlan_req++;
2953                 tt_vlan++;
2954         }
2955
2956         if (full_table)
2957                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2958
2959         batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n",
2960                    dst_orig_node->orig, full_table ? 'F' : '.');
2961
2962         batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
2963         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2964                                  dst_orig_node->orig, BATADV_TVLV_TT, 1,
2965                                  tvlv_tt_data, size);
2966         ret = true;
2967
2968 out:
2969         batadv_hardif_put(primary_if);
2970
2971         if (ret && tt_req_node) {
2972                 spin_lock_bh(&bat_priv->tt.req_list_lock);
2973                 if (!hlist_unhashed(&tt_req_node->list)) {
2974                         hlist_del_init(&tt_req_node->list);
2975                         batadv_tt_req_node_put(tt_req_node);
2976                 }
2977                 spin_unlock_bh(&bat_priv->tt.req_list_lock);
2978         }
2979
2980         batadv_tt_req_node_put(tt_req_node);
2981
2982         kfree(tvlv_tt_data);
2983         return ret;
2984 }
2985
2986 /**
2987  * batadv_send_other_tt_response() - send reply to tt request concerning another
2988  *  node's translation table
2989  * @bat_priv: the bat priv with all the soft interface information
2990  * @tt_data: tt data containing the tt request information
2991  * @req_src: mac address of tt request sender
2992  * @req_dst: mac address of tt request recipient
2993  *
2994  * Return: true if tt request reply was sent, false otherwise.
2995  */
2996 static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,
2997                                           struct batadv_tvlv_tt_data *tt_data,
2998                                           u8 *req_src, u8 *req_dst)
2999 {
3000         struct batadv_orig_node *req_dst_orig_node;
3001         struct batadv_orig_node *res_dst_orig_node = NULL;
3002         struct batadv_tvlv_tt_change *tt_change;
3003         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
3004         struct batadv_tvlv_tt_vlan_data *tt_vlan;
3005         bool ret = false, full_table;
3006         u8 orig_ttvn, req_ttvn;
3007         u16 tvlv_len;
3008         s32 tt_len;
3009
3010         batadv_dbg(BATADV_DBG_TT, bat_priv,
3011                    "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
3012                    req_src, tt_data->ttvn, req_dst,
3013                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
3014
3015         /* Let's get the orig node of the REAL destination */
3016         req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);
3017         if (!req_dst_orig_node)
3018                 goto out;
3019
3020         res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);
3021         if (!res_dst_orig_node)
3022                 goto out;
3023
3024         orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn);
3025         req_ttvn = tt_data->ttvn;
3026
3027         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
3028         /* this node doesn't have the requested data */
3029         if (orig_ttvn != req_ttvn ||
3030             !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,
3031                                         ntohs(tt_data->num_vlan)))
3032                 goto out;
3033
3034         /* If the full table has been explicitly requested */
3035         if (tt_data->flags & BATADV_TT_FULL_TABLE ||
3036             !req_dst_orig_node->tt_buff)
3037                 full_table = true;
3038         else
3039                 full_table = false;
3040
3041         /* TT fragmentation hasn't been implemented yet, so send as many
3042          * TT entries fit a single packet as possible only
3043          */
3044         if (!full_table) {
3045                 spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
3046                 tt_len = req_dst_orig_node->tt_buff_len;
3047
3048                 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
3049                                                               &tvlv_tt_data,
3050                                                               &tt_change,
3051                                                               &tt_len);
3052                 if (!tt_len)
3053                         goto unlock;
3054
3055                 /* Copy the last orig_node's OGM buffer */
3056                 memcpy(tt_change, req_dst_orig_node->tt_buff,
3057                        req_dst_orig_node->tt_buff_len);
3058                 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
3059         } else {
3060                 /* allocate the tvlv, put the tt_data and all the tt_vlan_data
3061                  * in the initial part
3062                  */
3063                 tt_len = -1;
3064                 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
3065                                                               &tvlv_tt_data,
3066                                                               &tt_change,
3067                                                               &tt_len);
3068                 if (!tt_len)
3069                         goto out;
3070
3071                 /* fill the rest of the tvlv with the real TT entries */
3072                 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash,
3073                                         tt_change, tt_len,
3074                                         batadv_tt_global_valid,
3075                                         req_dst_orig_node);
3076         }
3077
3078         /* Don't send the response, if larger than fragmented packet. */
3079         tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len;
3080         if (tt_len > atomic_read(&bat_priv->packet_size_max)) {
3081                 net_ratelimited_function(batadv_info, bat_priv->soft_iface,
3082                                          "Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n",
3083                                          res_dst_orig_node->orig);
3084                 goto out;
3085         }
3086
3087         tvlv_tt_data->flags = BATADV_TT_RESPONSE;
3088         tvlv_tt_data->ttvn = req_ttvn;
3089
3090         if (full_table)
3091                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
3092
3093         batadv_dbg(BATADV_DBG_TT, bat_priv,
3094                    "Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n",
3095                    res_dst_orig_node->orig, req_dst_orig_node->orig,
3096                    full_table ? 'F' : '.', req_ttvn);
3097
3098         batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
3099
3100         batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,
3101                                  req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
3102                                  tvlv_len);
3103
3104         ret = true;
3105         goto out;
3106
3107 unlock:
3108         spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
3109
3110 out:
3111         batadv_orig_node_put(res_dst_orig_node);
3112         batadv_orig_node_put(req_dst_orig_node);
3113         kfree(tvlv_tt_data);
3114         return ret;
3115 }
3116
3117 /**
3118  * batadv_send_my_tt_response() - send reply to tt request concerning this
3119  *  node's translation table
3120  * @bat_priv: the bat priv with all the soft interface information
3121  * @tt_data: tt data containing the tt request information
3122  * @req_src: mac address of tt request sender
3123  *
3124  * Return: true if tt request reply was sent, false otherwise.
3125  */
3126 static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,
3127                                        struct batadv_tvlv_tt_data *tt_data,
3128                                        u8 *req_src)
3129 {
3130         struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
3131         struct batadv_hard_iface *primary_if = NULL;
3132         struct batadv_tvlv_tt_change *tt_change;
3133         struct batadv_orig_node *orig_node;
3134         u8 my_ttvn, req_ttvn;
3135         u16 tvlv_len;
3136         bool full_table;
3137         s32 tt_len;
3138
3139         batadv_dbg(BATADV_DBG_TT, bat_priv,
3140                    "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
3141                    req_src, tt_data->ttvn,
3142                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
3143
3144         spin_lock_bh(&bat_priv->tt.commit_lock);
3145
3146         my_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
3147         req_ttvn = tt_data->ttvn;
3148
3149         orig_node = batadv_orig_hash_find(bat_priv, req_src);
3150         if (!orig_node)
3151                 goto out;
3152
3153         primary_if = batadv_primary_if_get_selected(bat_priv);
3154         if (!primary_if)
3155                 goto out;
3156
3157         /* If the full table has been explicitly requested or the gap
3158          * is too big send the whole local translation table
3159          */
3160         if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
3161             !bat_priv->tt.last_changeset)
3162                 full_table = true;
3163         else
3164                 full_table = false;
3165
3166         /* TT fragmentation hasn't been implemented yet, so send as many
3167          * TT entries fit a single packet as possible only
3168          */
3169         if (!full_table) {
3170                 spin_lock_bh(&bat_priv->tt.last_changeset_lock);
3171
3172                 tt_len = bat_priv->tt.last_changeset_len;
3173                 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
3174                                                              &tvlv_tt_data,
3175                                                              &tt_change,
3176                                                              &tt_len);
3177                 if (!tt_len || !tvlv_len)
3178                         goto unlock;
3179
3180                 /* Copy the last orig_node's OGM buffer */
3181                 memcpy(tt_change, bat_priv->tt.last_changeset,
3182                        bat_priv->tt.last_changeset_len);
3183                 spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
3184         } else {
3185                 req_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
3186
3187                 /* allocate the tvlv, put the tt_data and all the tt_vlan_data
3188                  * in the initial part
3189                  */
3190                 tt_len = -1;
3191                 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
3192                                                              &tvlv_tt_data,
3193                                                              &tt_change,
3194                                                              &tt_len);
3195                 if (!tt_len || !tvlv_len)
3196                         goto out;
3197
3198                 /* fill the rest of the tvlv with the real TT entries */
3199                 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash,
3200                                         tt_change, tt_len,
3201                                         batadv_tt_local_valid, NULL);
3202         }
3203
3204         tvlv_tt_data->flags = BATADV_TT_RESPONSE;
3205         tvlv_tt_data->ttvn = req_ttvn;
3206
3207         if (full_table)
3208                 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
3209
3210         batadv_dbg(BATADV_DBG_TT, bat_priv,
3211                    "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",
3212                    orig_node->orig, full_table ? 'F' : '.', req_ttvn);
3213
3214         batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
3215
3216         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
3217                                  req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
3218                                  tvlv_len);
3219
3220         goto out;
3221
3222 unlock:
3223         spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
3224 out:
3225         spin_unlock_bh(&bat_priv->tt.commit_lock);
3226         batadv_orig_node_put(orig_node);
3227         batadv_hardif_put(primary_if);
3228         kfree(tvlv_tt_data);
3229         /* The packet was for this host, so it doesn't need to be re-routed */
3230         return true;
3231 }
3232
3233 /**
3234  * batadv_send_tt_response() - send reply to tt request
3235  * @bat_priv: the bat priv with all the soft interface information
3236  * @tt_data: tt data containing the tt request information
3237  * @req_src: mac address of tt request sender
3238  * @req_dst: mac address of tt request recipient
3239  *
3240  * Return: true if tt request reply was sent, false otherwise.
3241  */
3242 static bool batadv_send_tt_response(struct batadv_priv *bat_priv,
3243                                     struct batadv_tvlv_tt_data *tt_data,
3244                                     u8 *req_src, u8 *req_dst)
3245 {
3246         if (batadv_is_my_mac(bat_priv, req_dst))
3247                 return batadv_send_my_tt_response(bat_priv, tt_data, req_src);
3248         return batadv_send_other_tt_response(bat_priv, tt_data, req_src,
3249                                              req_dst);
3250 }
3251
3252 static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
3253                                       struct batadv_orig_node *orig_node,
3254                                       struct batadv_tvlv_tt_change *tt_change,
3255                                       u16 tt_num_changes, u8 ttvn)
3256 {
3257         int i;
3258         int roams;
3259
3260         for (i = 0; i < tt_num_changes; i++) {
3261                 if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
3262                         roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
3263                         batadv_tt_global_del(bat_priv, orig_node,
3264                                              (tt_change + i)->addr,
3265                                              ntohs((tt_change + i)->vid),
3266                                              "tt removed by changes",
3267                                              roams);
3268                 } else {
3269                         if (!batadv_tt_global_add(bat_priv, orig_node,
3270                                                   (tt_change + i)->addr,
3271                                                   ntohs((tt_change + i)->vid),
3272                                                   (tt_change + i)->flags, ttvn))
3273                                 /* In case of problem while storing a
3274                                  * global_entry, we stop the updating
3275                                  * procedure without committing the
3276                                  * ttvn change. This will avoid to send
3277                                  * corrupted data on tt_request
3278                                  */
3279                                 return;
3280                 }
3281         }
3282         set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
3283 }
3284
3285 static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
3286                                   struct batadv_tvlv_tt_change *tt_change,
3287                                   u8 ttvn, u8 *resp_src,
3288                                   u16 num_entries)
3289 {
3290         struct batadv_orig_node *orig_node;
3291
3292         orig_node = batadv_orig_hash_find(bat_priv, resp_src);
3293         if (!orig_node)
3294                 goto out;
3295
3296         /* Purge the old table first.. */
3297         batadv_tt_global_del_orig(bat_priv, orig_node, -1,
3298                                   "Received full table");
3299
3300         _batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,
3301                                   ttvn);
3302
3303         spin_lock_bh(&orig_node->tt_buff_lock);
3304         kfree(orig_node->tt_buff);
3305         orig_node->tt_buff_len = 0;
3306         orig_node->tt_buff = NULL;
3307         spin_unlock_bh(&orig_node->tt_buff_lock);
3308
3309         atomic_set(&orig_node->last_ttvn, ttvn);
3310
3311 out:
3312         batadv_orig_node_put(orig_node);
3313 }
3314
3315 static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
3316                                      struct batadv_orig_node *orig_node,
3317                                      u16 tt_num_changes, u8 ttvn,
3318                                      struct batadv_tvlv_tt_change *tt_change)
3319 {
3320         _batadv_tt_update_changes(bat_priv, orig_node, tt_change,
3321                                   tt_num_changes, ttvn);
3322
3323         batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,
3324                                    batadv_tt_len(tt_num_changes));
3325         atomic_set(&orig_node->last_ttvn, ttvn);
3326 }
3327
3328 /**
3329  * batadv_is_my_client() - check if a client is served by the local node
3330  * @bat_priv: the bat priv with all the soft interface information
3331  * @addr: the mac address of the client to check
3332  * @vid: VLAN identifier
3333  *
3334  * Return: true if the client is served by this node, false otherwise.
3335  */
3336 bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr,
3337                          unsigned short vid)
3338 {
3339         struct batadv_tt_local_entry *tt_local_entry;
3340         bool ret = false;
3341
3342         tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3343         if (!tt_local_entry)
3344                 goto out;
3345         /* Check if the client has been logically deleted (but is kept for
3346          * consistency purpose)
3347          */
3348         if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||
3349             (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))
3350                 goto out;
3351         ret = true;
3352 out:
3353         batadv_tt_local_entry_put(tt_local_entry);
3354         return ret;
3355 }
3356
3357 /**
3358  * batadv_handle_tt_response() - process incoming tt reply
3359  * @bat_priv: the bat priv with all the soft interface information
3360  * @tt_data: tt data containing the tt request information
3361  * @resp_src: mac address of tt reply sender
3362  * @num_entries: number of tt change entries appended to the tt data
3363  */
3364 static void batadv_handle_tt_response(struct batadv_priv *bat_priv,
3365                                       struct batadv_tvlv_tt_data *tt_data,
3366                                       u8 *resp_src, u16 num_entries)
3367 {
3368         struct batadv_tt_req_node *node;
3369         struct hlist_node *safe;
3370         struct batadv_orig_node *orig_node = NULL;
3371         struct batadv_tvlv_tt_change *tt_change;
3372         u8 *tvlv_ptr = (u8 *)tt_data;
3373         u16 change_offset;
3374
3375         batadv_dbg(BATADV_DBG_TT, bat_priv,
3376                    "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
3377                    resp_src, tt_data->ttvn, num_entries,
3378                    ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
3379
3380         orig_node = batadv_orig_hash_find(bat_priv, resp_src);
3381         if (!orig_node)
3382                 goto out;
3383
3384         spin_lock_bh(&orig_node->tt_lock);
3385
3386         change_offset = sizeof(struct batadv_tvlv_tt_vlan_data);
3387         change_offset *= ntohs(tt_data->num_vlan);
3388         change_offset += sizeof(*tt_data);
3389         tvlv_ptr += change_offset;
3390
3391         tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr;
3392         if (tt_data->flags & BATADV_TT_FULL_TABLE) {
3393                 batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,
3394                                       resp_src, num_entries);
3395         } else {
3396                 batadv_tt_update_changes(bat_priv, orig_node, num_entries,
3397                                          tt_data->ttvn, tt_change);
3398         }
3399
3400         /* Recalculate the CRC for this orig_node and store it */
3401         batadv_tt_global_update_crc(bat_priv, orig_node);
3402
3403         spin_unlock_bh(&orig_node->tt_lock);
3404
3405         /* Delete the tt_req_node from pending tt_requests list */
3406         spin_lock_bh(&bat_priv->tt.req_list_lock);
3407         hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
3408                 if (!batadv_compare_eth(node->addr, resp_src))
3409                         continue;
3410                 hlist_del_init(&node->list);
3411                 batadv_tt_req_node_put(node);
3412         }
3413
3414         spin_unlock_bh(&bat_priv->tt.req_list_lock);
3415 out:
3416         batadv_orig_node_put(orig_node);
3417 }
3418
3419 static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
3420 {
3421         struct batadv_tt_roam_node *node, *safe;
3422
3423         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3424
3425         list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3426                 list_del(&node->list);
3427                 kmem_cache_free(batadv_tt_roam_cache, node);
3428         }
3429
3430         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3431 }
3432
3433 static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
3434 {
3435         struct batadv_tt_roam_node *node, *safe;
3436
3437         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3438         list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3439                 if (!batadv_has_timed_out(node->first_time,
3440                                           BATADV_ROAMING_MAX_TIME))
3441                         continue;
3442
3443                 list_del(&node->list);
3444                 kmem_cache_free(batadv_tt_roam_cache, node);
3445         }
3446         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3447 }
3448
3449 /**
3450  * batadv_tt_check_roam_count() - check if a client has roamed too frequently
3451  * @bat_priv: the bat priv with all the soft interface information
3452  * @client: mac address of the roaming client
3453  *
3454  * This function checks whether the client already reached the
3455  * maximum number of possible roaming phases. In this case the ROAMING_ADV
3456  * will not be sent.
3457  *
3458  * Return: true if the ROAMING_ADV can be sent, false otherwise
3459  */
3460 static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)
3461 {
3462         struct batadv_tt_roam_node *tt_roam_node;
3463         bool ret = false;
3464
3465         spin_lock_bh(&bat_priv->tt.roam_list_lock);
3466         /* The new tt_req will be issued only if I'm not waiting for a
3467          * reply from the same orig_node yet
3468          */
3469         list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {
3470                 if (!batadv_compare_eth(tt_roam_node->addr, client))
3471                         continue;
3472
3473                 if (batadv_has_timed_out(tt_roam_node->first_time,
3474                                          BATADV_ROAMING_MAX_TIME))
3475                         continue;
3476
3477                 if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
3478                         /* Sorry, you roamed too many times! */
3479                         goto unlock;
3480                 ret = true;
3481                 break;
3482         }
3483
3484         if (!ret) {
3485                 tt_roam_node = kmem_cache_alloc(batadv_tt_roam_cache,
3486                                                 GFP_ATOMIC);
3487                 if (!tt_roam_node)
3488                         goto unlock;
3489
3490                 tt_roam_node->first_time = jiffies;
3491                 atomic_set(&tt_roam_node->counter,
3492                            BATADV_ROAMING_MAX_COUNT - 1);
3493                 ether_addr_copy(tt_roam_node->addr, client);
3494
3495                 list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);
3496                 ret = true;
3497         }
3498
3499 unlock:
3500         spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3501         return ret;
3502 }
3503
3504 /**
3505  * batadv_send_roam_adv() - send a roaming advertisement message
3506  * @bat_priv: the bat priv with all the soft interface information
3507  * @client: mac address of the roaming client
3508  * @vid: VLAN identifier
3509  * @orig_node: message destination
3510  *
3511  * Send a ROAMING_ADV message to the node which was previously serving this
3512  * client. This is done to inform the node that from now on all traffic destined
3513  * for this particular roamed client has to be forwarded to the sender of the
3514  * roaming message.
3515  */
3516 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
3517                                  unsigned short vid,
3518                                  struct batadv_orig_node *orig_node)
3519 {
3520         struct batadv_hard_iface *primary_if;
3521         struct batadv_tvlv_roam_adv tvlv_roam;
3522
3523         primary_if = batadv_primary_if_get_selected(bat_priv);
3524         if (!primary_if)
3525                 goto out;
3526
3527         /* before going on we have to check whether the client has
3528          * already roamed to us too many times
3529          */
3530         if (!batadv_tt_check_roam_count(bat_priv, client))
3531                 goto out;
3532
3533         batadv_dbg(BATADV_DBG_TT, bat_priv,
3534                    "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",
3535                    orig_node->orig, client, batadv_print_vid(vid));
3536
3537         batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
3538
3539         memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));
3540         tvlv_roam.vid = htons(vid);
3541
3542         batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
3543                                  orig_node->orig, BATADV_TVLV_ROAM, 1,
3544                                  &tvlv_roam, sizeof(tvlv_roam));
3545
3546 out:
3547         batadv_hardif_put(primary_if);
3548 }
3549
3550 static void batadv_tt_purge(struct work_struct *work)
3551 {
3552         struct delayed_work *delayed_work;
3553         struct batadv_priv_tt *priv_tt;
3554         struct batadv_priv *bat_priv;
3555
3556         delayed_work = to_delayed_work(work);
3557         priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);
3558         bat_priv = container_of(priv_tt, struct batadv_priv, tt);
3559
3560         batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);
3561         batadv_tt_global_purge(bat_priv);
3562         batadv_tt_req_purge(bat_priv);
3563         batadv_tt_roam_purge(bat_priv);
3564
3565         queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
3566                            msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3567 }
3568
3569 /**
3570  * batadv_tt_free() - Free translation table of soft interface
3571  * @bat_priv: the bat priv with all the soft interface information
3572  */
3573 void batadv_tt_free(struct batadv_priv *bat_priv)
3574 {
3575         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_ROAM, 1);
3576
3577         batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);
3578         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);
3579
3580         cancel_delayed_work_sync(&bat_priv->tt.work);
3581
3582         batadv_tt_local_table_free(bat_priv);
3583         batadv_tt_global_table_free(bat_priv);
3584         batadv_tt_req_list_free(bat_priv);
3585         batadv_tt_changes_list_free(bat_priv);
3586         batadv_tt_roam_list_free(bat_priv);
3587
3588         kfree(bat_priv->tt.last_changeset);
3589 }
3590
3591 /**
3592  * batadv_tt_local_set_flags() - set or unset the specified flags on the local
3593  *  table and possibly count them in the TT size
3594  * @bat_priv: the bat priv with all the soft interface information
3595  * @flags: the flag to switch
3596  * @enable: whether to set or unset the flag
3597  * @count: whether to increase the TT size by the number of changed entries
3598  */
3599 static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags,
3600                                       bool enable, bool count)
3601 {
3602         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3603         struct batadv_tt_common_entry *tt_common_entry;
3604         struct hlist_head *head;
3605         u32 i;
3606
3607         if (!hash)
3608                 return;
3609
3610         for (i = 0; i < hash->size; i++) {
3611                 head = &hash->table[i];
3612
3613                 rcu_read_lock();
3614                 hlist_for_each_entry_rcu(tt_common_entry,
3615                                          head, hash_entry) {
3616                         if (enable) {
3617                                 if ((tt_common_entry->flags & flags) == flags)
3618                                         continue;
3619                                 tt_common_entry->flags |= flags;
3620                         } else {
3621                                 if (!(tt_common_entry->flags & flags))
3622                                         continue;
3623                                 tt_common_entry->flags &= ~flags;
3624                         }
3625
3626                         if (!count)
3627                                 continue;
3628
3629                         batadv_tt_local_size_inc(bat_priv,
3630                                                  tt_common_entry->vid);
3631                 }
3632                 rcu_read_unlock();
3633         }
3634 }
3635
3636 /* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */
3637 static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
3638 {
3639         struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3640         struct batadv_tt_common_entry *tt_common;
3641         struct batadv_tt_local_entry *tt_local;
3642         struct hlist_node *node_tmp;
3643         struct hlist_head *head;
3644         spinlock_t *list_lock; /* protects write access to the hash lists */
3645         u32 i;
3646
3647         if (!hash)
3648                 return;
3649
3650         for (i = 0; i < hash->size; i++) {
3651                 head = &hash->table[i];
3652                 list_lock = &hash->list_locks[i];
3653
3654                 spin_lock_bh(list_lock);
3655                 hlist_for_each_entry_safe(tt_common, node_tmp, head,
3656                                           hash_entry) {
3657                         if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
3658                                 continue;
3659
3660                         batadv_dbg(BATADV_DBG_TT, bat_priv,
3661                                    "Deleting local tt entry (%pM, vid: %d): pending\n",
3662                                    tt_common->addr,
3663                                    batadv_print_vid(tt_common->vid));
3664
3665                         batadv_tt_local_size_dec(bat_priv, tt_common->vid);
3666                         hlist_del_rcu(&tt_common->hash_entry);
3667                         tt_local = container_of(tt_common,
3668                                                 struct batadv_tt_local_entry,
3669                                                 common);
3670
3671                         batadv_tt_local_entry_put(tt_local);
3672                 }
3673                 spin_unlock_bh(list_lock);
3674         }
3675 }
3676
3677 /**
3678  * batadv_tt_local_commit_changes_nolock() - commit all pending local tt changes
3679  *  which have been queued in the time since the last commit
3680  * @bat_priv: the bat priv with all the soft interface information
3681  *
3682  * Caller must hold tt->commit_lock.
3683  */
3684 static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)
3685 {
3686         lockdep_assert_held(&bat_priv->tt.commit_lock);
3687
3688         if (atomic_read(&bat_priv->tt.local_changes) < 1) {
3689                 if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))
3690                         batadv_tt_tvlv_container_update(bat_priv);
3691                 return;
3692         }
3693
3694         batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);
3695
3696         batadv_tt_local_purge_pending_clients(bat_priv);
3697         batadv_tt_local_update_crc(bat_priv);
3698
3699         /* Increment the TTVN only once per OGM interval */
3700         atomic_inc(&bat_priv->tt.vn);
3701         batadv_dbg(BATADV_DBG_TT, bat_priv,
3702                    "Local changes committed, updating to ttvn %u\n",
3703                    (u8)atomic_read(&bat_priv->tt.vn));
3704
3705         /* reset the sending counter */
3706         atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
3707         batadv_tt_tvlv_container_update(bat_priv);
3708 }
3709
3710 /**
3711  * batadv_tt_local_commit_changes() - commit all pending local tt changes which
3712  *  have been queued in the time since the last commit
3713  * @bat_priv: the bat priv with all the soft interface information
3714  */
3715 void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv)
3716 {
3717         spin_lock_bh(&bat_priv->tt.commit_lock);
3718         batadv_tt_local_commit_changes_nolock(bat_priv);
3719         spin_unlock_bh(&bat_priv->tt.commit_lock);
3720 }
3721
3722 /**
3723  * batadv_is_ap_isolated() - Check if packet from upper layer should be dropped
3724  * @bat_priv: the bat priv with all the soft interface information
3725  * @src: source mac address of packet
3726  * @dst: destination mac address of packet
3727  * @vid: vlan id of packet
3728  *
3729  * Return: true when src+dst(+vid) pair should be isolated, false otherwise
3730  */
3731 bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,
3732                            unsigned short vid)
3733 {
3734         struct batadv_tt_local_entry *tt_local_entry;
3735         struct batadv_tt_global_entry *tt_global_entry;
3736         struct batadv_softif_vlan *vlan;
3737         bool ret = false;
3738
3739         vlan = batadv_softif_vlan_get(bat_priv, vid);
3740         if (!vlan)
3741                 return false;
3742
3743         if (!atomic_read(&vlan->ap_isolation))
3744                 goto vlan_put;
3745
3746         tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);
3747         if (!tt_local_entry)
3748                 goto vlan_put;
3749
3750         tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);
3751         if (!tt_global_entry)
3752                 goto local_entry_put;
3753
3754         if (_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
3755                 ret = true;
3756
3757         batadv_tt_global_entry_put(tt_global_entry);
3758 local_entry_put:
3759         batadv_tt_local_entry_put(tt_local_entry);
3760 vlan_put:
3761         batadv_softif_vlan_put(vlan);
3762         return ret;
3763 }
3764
3765 /**
3766  * batadv_tt_update_orig() - update global translation table with new tt
3767  *  information received via ogms
3768  * @bat_priv: the bat priv with all the soft interface information
3769  * @orig_node: the orig_node of the ogm
3770  * @tt_buff: pointer to the first tvlv VLAN entry
3771  * @tt_num_vlan: number of tvlv VLAN entries
3772  * @tt_change: pointer to the first entry in the TT buffer
3773  * @tt_num_changes: number of tt changes inside the tt buffer
3774  * @ttvn: translation table version number of this changeset
3775  */
3776 static void batadv_tt_update_orig(struct batadv_priv *bat_priv,
3777                                   struct batadv_orig_node *orig_node,
3778                                   const void *tt_buff, u16 tt_num_vlan,
3779                                   struct batadv_tvlv_tt_change *tt_change,
3780                                   u16 tt_num_changes, u8 ttvn)
3781 {
3782         u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
3783         struct batadv_tvlv_tt_vlan_data *tt_vlan;
3784         bool full_table = true;
3785         bool has_tt_init;
3786
3787         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;
3788         has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT,
3789                                &orig_node->capa_initialized);
3790
3791         /* orig table not initialised AND first diff is in the OGM OR the ttvn
3792          * increased by one -> we can apply the attached changes
3793          */
3794         if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {
3795                 /* the OGM could not contain the changes due to their size or
3796                  * because they have already been sent BATADV_TT_OGM_APPEND_MAX
3797                  * times.
3798                  * In this case send a tt request
3799                  */
3800                 if (!tt_num_changes) {
3801                         full_table = false;
3802                         goto request_table;
3803                 }
3804
3805                 spin_lock_bh(&orig_node->tt_lock);
3806
3807                 batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
3808                                          ttvn, tt_change);
3809
3810                 /* Even if we received the precomputed crc with the OGM, we
3811                  * prefer to recompute it to spot any possible inconsistency
3812                  * in the global table
3813                  */
3814                 batadv_tt_global_update_crc(bat_priv, orig_node);
3815
3816                 spin_unlock_bh(&orig_node->tt_lock);
3817
3818                 /* The ttvn alone is not enough to guarantee consistency
3819                  * because a single value could represent different states
3820                  * (due to the wrap around). Thus a node has to check whether
3821                  * the resulting table (after applying the changes) is still
3822                  * consistent or not. E.g. a node could disconnect while its
3823                  * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
3824                  * checking the CRC value is mandatory to detect the
3825                  * inconsistency
3826                  */
3827                 if (!batadv_tt_global_check_crc(orig_node, tt_vlan,
3828                                                 tt_num_vlan))
3829                         goto request_table;
3830         } else {
3831                 /* if we missed more than one change or our tables are not
3832                  * in sync anymore -> request fresh tt data
3833                  */
3834                 if (!has_tt_init || ttvn != orig_ttvn ||
3835                     !batadv_tt_global_check_crc(orig_node, tt_vlan,
3836                                                 tt_num_vlan)) {
3837 request_table:
3838                         batadv_dbg(BATADV_DBG_TT, bat_priv,
3839                                    "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n",
3840                                    orig_node->orig, ttvn, orig_ttvn,
3841                                    tt_num_changes);
3842                         batadv_send_tt_request(bat_priv, orig_node, ttvn,
3843                                                tt_vlan, tt_num_vlan,
3844                                                full_table);
3845                         return;
3846                 }
3847         }
3848 }
3849
3850 /**
3851  * batadv_tt_global_client_is_roaming() - check if a client is marked as roaming
3852  * @bat_priv: the bat priv with all the soft interface information
3853  * @addr: the mac address of the client to check
3854  * @vid: VLAN identifier
3855  *
3856  * Return: true if we know that the client has moved from its old originator
3857  * to another one. This entry is still kept for consistency purposes and will be
3858  * deleted later by a DEL or because of timeout
3859  */
3860 bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
3861                                         u8 *addr, unsigned short vid)
3862 {
3863         struct batadv_tt_global_entry *tt_global_entry;
3864         bool ret = false;
3865
3866         tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
3867         if (!tt_global_entry)
3868                 goto out;
3869
3870         ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3871         batadv_tt_global_entry_put(tt_global_entry);
3872 out:
3873         return ret;
3874 }
3875
3876 /**
3877  * batadv_tt_local_client_is_roaming() - tells whether the client is roaming
3878  * @bat_priv: the bat priv with all the soft interface information
3879  * @addr: the mac address of the local client to query
3880  * @vid: VLAN identifier
3881  *
3882  * Return: true if the local client is known to be roaming (it is not served by
3883  * this node anymore) or not. If yes, the client is still present in the table
3884  * to keep the latter consistent with the node TTVN
3885  */
3886 bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,
3887                                        u8 *addr, unsigned short vid)
3888 {
3889         struct batadv_tt_local_entry *tt_local_entry;
3890         bool ret = false;
3891
3892         tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3893         if (!tt_local_entry)
3894                 goto out;
3895
3896         ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3897         batadv_tt_local_entry_put(tt_local_entry);
3898 out:
3899         return ret;
3900 }
3901
3902 /**
3903  * batadv_tt_add_temporary_global_entry() - Add temporary entry to global TT
3904  * @bat_priv: the bat priv with all the soft interface information
3905  * @orig_node: orig node which the temporary entry should be associated with
3906  * @addr: mac address of the client
3907  * @vid: VLAN id of the new temporary global translation table
3908  *
3909  * Return: true when temporary tt entry could be added, false otherwise
3910  */
3911 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
3912                                           struct batadv_orig_node *orig_node,
3913                                           const unsigned char *addr,
3914                                           unsigned short vid)
3915 {
3916         /* ignore loop detect macs, they are not supposed to be in the tt local
3917          * data as well.
3918          */
3919         if (batadv_bla_is_loopdetect_mac(addr))
3920                 return false;
3921
3922         if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,
3923                                   BATADV_TT_CLIENT_TEMP,
3924                                   atomic_read(&orig_node->last_ttvn)))
3925                 return false;
3926
3927         batadv_dbg(BATADV_DBG_TT, bat_priv,
3928                    "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",
3929                    addr, batadv_print_vid(vid), orig_node->orig);
3930
3931         return true;
3932 }
3933
3934 /**
3935  * batadv_tt_local_resize_to_mtu() - resize the local translation table fit the
3936  *  maximum packet size that can be transported through the mesh
3937  * @soft_iface: netdev struct of the mesh interface
3938  *
3939  * Remove entries older than 'timeout' and half timeout if more entries need
3940  * to be removed.
3941  */
3942 void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface)
3943 {
3944         struct batadv_priv *bat_priv = netdev_priv(soft_iface);
3945         int packet_size_max = atomic_read(&bat_priv->packet_size_max);
3946         int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2;
3947         bool reduced = false;
3948
3949         spin_lock_bh(&bat_priv->tt.commit_lock);
3950
3951         while (true) {
3952                 table_size = batadv_tt_local_table_transmit_size(bat_priv);
3953                 if (packet_size_max >= table_size)
3954                         break;
3955
3956                 batadv_tt_local_purge(bat_priv, timeout);
3957                 batadv_tt_local_purge_pending_clients(bat_priv);
3958
3959                 timeout /= 2;
3960                 reduced = true;
3961                 net_ratelimited_function(batadv_info, soft_iface,
3962                                          "Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n",
3963                                          packet_size_max);
3964         }
3965
3966         /* commit these changes immediately, to avoid synchronization problem
3967          * with the TTVN
3968          */
3969         if (reduced)
3970                 batadv_tt_local_commit_changes_nolock(bat_priv);
3971
3972         spin_unlock_bh(&bat_priv->tt.commit_lock);
3973 }
3974
3975 /**
3976  * batadv_tt_tvlv_ogm_handler_v1() - process incoming tt tvlv container
3977  * @bat_priv: the bat priv with all the soft interface information
3978  * @orig: the orig_node of the ogm
3979  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
3980  * @tvlv_value: tvlv buffer containing the gateway data
3981  * @tvlv_value_len: tvlv buffer length
3982  */
3983 static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
3984                                           struct batadv_orig_node *orig,
3985                                           u8 flags, void *tvlv_value,
3986                                           u16 tvlv_value_len)
3987 {
3988         struct batadv_tvlv_tt_vlan_data *tt_vlan;
3989         struct batadv_tvlv_tt_change *tt_change;
3990         struct batadv_tvlv_tt_data *tt_data;
3991         u16 num_entries, num_vlan;
3992
3993         if (tvlv_value_len < sizeof(*tt_data))
3994                 return;
3995
3996         tt_data = tvlv_value;
3997         tvlv_value_len -= sizeof(*tt_data);
3998
3999         num_vlan = ntohs(tt_data->num_vlan);
4000
4001         if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan)
4002                 return;
4003
4004         tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
4005         tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan);
4006         tvlv_value_len -= sizeof(*tt_vlan) * num_vlan;
4007
4008         num_entries = batadv_tt_entries(tvlv_value_len);
4009
4010         batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,
4011                               num_entries, tt_data->ttvn);
4012 }
4013
4014 /**
4015  * batadv_tt_tvlv_unicast_handler_v1() - process incoming (unicast) tt tvlv
4016  *  container
4017  * @bat_priv: the bat priv with all the soft interface information
4018  * @src: mac address of tt tvlv sender
4019  * @dst: mac address of tt tvlv recipient
4020  * @tvlv_value: tvlv buffer containing the tt data
4021  * @tvlv_value_len: tvlv buffer length
4022  *
4023  * Return: NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS
4024  * otherwise.
4025  */
4026 static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
4027                                              u8 *src, u8 *dst,
4028                                              void *tvlv_value,
4029                                              u16 tvlv_value_len)
4030 {
4031         struct batadv_tvlv_tt_data *tt_data;
4032         u16 tt_vlan_len, tt_num_entries;
4033         char tt_flag;
4034         bool ret;
4035
4036         if (tvlv_value_len < sizeof(*tt_data))
4037                 return NET_RX_SUCCESS;
4038
4039         tt_data = tvlv_value;
4040         tvlv_value_len -= sizeof(*tt_data);
4041
4042         tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data);
4043         tt_vlan_len *= ntohs(tt_data->num_vlan);
4044
4045         if (tvlv_value_len < tt_vlan_len)
4046                 return NET_RX_SUCCESS;
4047
4048         tvlv_value_len -= tt_vlan_len;
4049         tt_num_entries = batadv_tt_entries(tvlv_value_len);
4050
4051         switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) {
4052         case BATADV_TT_REQUEST:
4053                 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);
4054
4055                 /* If this node cannot provide a TT response the tt_request is
4056                  * forwarded
4057                  */
4058                 ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);
4059                 if (!ret) {
4060                         if (tt_data->flags & BATADV_TT_FULL_TABLE)
4061                                 tt_flag = 'F';
4062                         else
4063                                 tt_flag = '.';
4064
4065                         batadv_dbg(BATADV_DBG_TT, bat_priv,
4066                                    "Routing TT_REQUEST to %pM [%c]\n",
4067                                    dst, tt_flag);
4068                         /* tvlv API will re-route the packet */
4069                         return NET_RX_DROP;
4070                 }
4071                 break;
4072         case BATADV_TT_RESPONSE:
4073                 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);
4074
4075                 if (batadv_is_my_mac(bat_priv, dst)) {
4076                         batadv_handle_tt_response(bat_priv, tt_data,
4077                                                   src, tt_num_entries);
4078                         return NET_RX_SUCCESS;
4079                 }
4080
4081                 if (tt_data->flags & BATADV_TT_FULL_TABLE)
4082                         tt_flag =  'F';
4083                 else
4084                         tt_flag = '.';
4085
4086                 batadv_dbg(BATADV_DBG_TT, bat_priv,
4087                            "Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);
4088
4089                 /* tvlv API will re-route the packet */
4090                 return NET_RX_DROP;
4091         }
4092
4093         return NET_RX_SUCCESS;
4094 }
4095
4096 /**
4097  * batadv_roam_tvlv_unicast_handler_v1() - process incoming tt roam tvlv
4098  *  container
4099  * @bat_priv: the bat priv with all the soft interface information
4100  * @src: mac address of tt tvlv sender
4101  * @dst: mac address of tt tvlv recipient
4102  * @tvlv_value: tvlv buffer containing the tt data
4103  * @tvlv_value_len: tvlv buffer length
4104  *
4105  * Return: NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS
4106  * otherwise.
4107  */
4108 static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
4109                                                u8 *src, u8 *dst,
4110                                                void *tvlv_value,
4111                                                u16 tvlv_value_len)
4112 {
4113         struct batadv_tvlv_roam_adv *roaming_adv;
4114         struct batadv_orig_node *orig_node = NULL;
4115
4116         /* If this node is not the intended recipient of the
4117          * roaming advertisement the packet is forwarded
4118          * (the tvlv API will re-route the packet).
4119          */
4120         if (!batadv_is_my_mac(bat_priv, dst))
4121                 return NET_RX_DROP;
4122
4123         if (tvlv_value_len < sizeof(*roaming_adv))
4124                 goto out;
4125
4126         orig_node = batadv_orig_hash_find(bat_priv, src);
4127         if (!orig_node)
4128                 goto out;
4129
4130         batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
4131         roaming_adv = tvlv_value;
4132
4133         batadv_dbg(BATADV_DBG_TT, bat_priv,
4134                    "Received ROAMING_ADV from %pM (client %pM)\n",
4135                    src, roaming_adv->client);
4136
4137         batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client,
4138                              ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,
4139                              atomic_read(&orig_node->last_ttvn) + 1);
4140
4141 out:
4142         batadv_orig_node_put(orig_node);
4143         return NET_RX_SUCCESS;
4144 }
4145
4146 /**
4147  * batadv_tt_init() - initialise the translation table internals
4148  * @bat_priv: the bat priv with all the soft interface information
4149  *
4150  * Return: 0 on success or negative error number in case of failure.
4151  */
4152 int batadv_tt_init(struct batadv_priv *bat_priv)
4153 {
4154         int ret;
4155
4156         /* synchronized flags must be remote */
4157         BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));
4158
4159         ret = batadv_tt_local_init(bat_priv);
4160         if (ret < 0)
4161                 return ret;
4162
4163         ret = batadv_tt_global_init(bat_priv);
4164         if (ret < 0) {
4165                 batadv_tt_local_table_free(bat_priv);
4166                 return ret;
4167         }
4168
4169         batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1,
4170                                      batadv_tt_tvlv_unicast_handler_v1, NULL,
4171                                      BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);
4172
4173         batadv_tvlv_handler_register(bat_priv, NULL,
4174                                      batadv_roam_tvlv_unicast_handler_v1, NULL,
4175                                      BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);
4176
4177         INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);
4178         queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
4179                            msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
4180
4181         return 1;
4182 }
4183
4184 /**
4185  * batadv_tt_global_is_isolated() - check if a client is marked as isolated
4186  * @bat_priv: the bat priv with all the soft interface information
4187  * @addr: the mac address of the client
4188  * @vid: the identifier of the VLAN where this client is connected
4189  *
4190  * Return: true if the client is marked with the TT_CLIENT_ISOLA flag, false
4191  * otherwise
4192  */
4193 bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,
4194                                   const u8 *addr, unsigned short vid)
4195 {
4196         struct batadv_tt_global_entry *tt;
4197         bool ret;
4198
4199         tt = batadv_tt_global_hash_find(bat_priv, addr, vid);
4200         if (!tt)
4201                 return false;
4202
4203         ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA;
4204
4205         batadv_tt_global_entry_put(tt);
4206
4207         return ret;
4208 }
4209
4210 /**
4211  * batadv_tt_cache_init() - Initialize tt memory object cache
4212  *
4213  * Return: 0 on success or negative error number in case of failure.
4214  */
4215 int __init batadv_tt_cache_init(void)
4216 {
4217         size_t tl_size = sizeof(struct batadv_tt_local_entry);
4218         size_t tg_size = sizeof(struct batadv_tt_global_entry);
4219         size_t tt_orig_size = sizeof(struct batadv_tt_orig_list_entry);
4220         size_t tt_change_size = sizeof(struct batadv_tt_change_node);
4221         size_t tt_req_size = sizeof(struct batadv_tt_req_node);
4222         size_t tt_roam_size = sizeof(struct batadv_tt_roam_node);
4223
4224         batadv_tl_cache = kmem_cache_create("batadv_tl_cache", tl_size, 0,
4225                                             SLAB_HWCACHE_ALIGN, NULL);
4226         if (!batadv_tl_cache)
4227                 return -ENOMEM;
4228
4229         batadv_tg_cache = kmem_cache_create("batadv_tg_cache", tg_size, 0,
4230                                             SLAB_HWCACHE_ALIGN, NULL);
4231         if (!batadv_tg_cache)
4232                 goto err_tt_tl_destroy;
4233
4234         batadv_tt_orig_cache = kmem_cache_create("batadv_tt_orig_cache",
4235                                                  tt_orig_size, 0,
4236                                                  SLAB_HWCACHE_ALIGN, NULL);
4237         if (!batadv_tt_orig_cache)
4238                 goto err_tt_tg_destroy;
4239
4240         batadv_tt_change_cache = kmem_cache_create("batadv_tt_change_cache",
4241                                                    tt_change_size, 0,
4242                                                    SLAB_HWCACHE_ALIGN, NULL);
4243         if (!batadv_tt_change_cache)
4244                 goto err_tt_orig_destroy;
4245
4246         batadv_tt_req_cache = kmem_cache_create("batadv_tt_req_cache",
4247                                                 tt_req_size, 0,
4248                                                 SLAB_HWCACHE_ALIGN, NULL);
4249         if (!batadv_tt_req_cache)
4250                 goto err_tt_change_destroy;
4251
4252         batadv_tt_roam_cache = kmem_cache_create("batadv_tt_roam_cache",
4253                                                  tt_roam_size, 0,
4254                                                  SLAB_HWCACHE_ALIGN, NULL);
4255         if (!batadv_tt_roam_cache)
4256                 goto err_tt_req_destroy;
4257
4258         return 0;
4259
4260 err_tt_req_destroy:
4261         kmem_cache_destroy(batadv_tt_req_cache);
4262         batadv_tt_req_cache = NULL;
4263 err_tt_change_destroy:
4264         kmem_cache_destroy(batadv_tt_change_cache);
4265         batadv_tt_change_cache = NULL;
4266 err_tt_orig_destroy:
4267         kmem_cache_destroy(batadv_tt_orig_cache);
4268         batadv_tt_orig_cache = NULL;
4269 err_tt_tg_destroy:
4270         kmem_cache_destroy(batadv_tg_cache);
4271         batadv_tg_cache = NULL;
4272 err_tt_tl_destroy:
4273         kmem_cache_destroy(batadv_tl_cache);
4274         batadv_tl_cache = NULL;
4275
4276         return -ENOMEM;
4277 }
4278
4279 /**
4280  * batadv_tt_cache_destroy() - Destroy tt memory object cache
4281  */
4282 void batadv_tt_cache_destroy(void)
4283 {
4284         kmem_cache_destroy(batadv_tl_cache);
4285         kmem_cache_destroy(batadv_tg_cache);
4286         kmem_cache_destroy(batadv_tt_orig_cache);
4287         kmem_cache_destroy(batadv_tt_change_cache);
4288         kmem_cache_destroy(batadv_tt_req_cache);
4289         kmem_cache_destroy(batadv_tt_roam_cache);
4290 }