kernel/net/batman-adv/bat_iv_ogm.c

   1 /* Copyright (C) 2007-2015 B.A.T.M.A.N. contributors:
   2  *
   3  * Marek Lindner, Simon Wunderlich
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of version 2 of the GNU General Public
   7  * License as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "bat_algo.h"
  19 #include "main.h"
  20
  21 #include <linux/atomic.h>
  22 #include <linux/bitmap.h>
  23 #include <linux/bitops.h>
  24 #include <linux/bug.h>
  25 #include <linux/byteorder/generic.h>
  26 #include <linux/cache.h>
  27 #include <linux/errno.h>
  28 #include <linux/etherdevice.h>
  29 #include <linux/fs.h>
  30 #include <linux/if_ether.h>
  31 #include <linux/init.h>
  32 #include <linux/jiffies.h>
  33 #include <linux/list.h>
  34 #include <linux/netdevice.h>
  35 #include <linux/pkt_sched.h>
  36 #include <linux/printk.h>
  37 #include <linux/random.h>
  38 #include <linux/rculist.h>
  39 #include <linux/rcupdate.h>
  40 #include <linux/seq_file.h>
  41 #include <linux/skbuff.h>
  42 #include <linux/slab.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/stddef.h>
  45 #include <linux/string.h>
  46 #include <linux/types.h>
  47 #include <linux/workqueue.h>
  48
  49 #include "bitarray.h"
  50 #include "hard-interface.h"
  51 #include "hash.h"
  52 #include "network-coding.h"
  53 #include "originator.h"
  54 #include "packet.h"
  55 #include "routing.h"
  56 #include "send.h"
  57 #include "translation-table.h"
  58
  59 /**
  60  * enum batadv_dup_status - duplicate status
  61  * @BATADV_NO_DUP: the packet is no duplicate
  62  * @BATADV_ORIG_DUP: OGM is a duplicate in the originator (but not for the
  63  *  neighbor)
  64  * @BATADV_NEIGH_DUP: OGM is a duplicate for the neighbor
  65  * @BATADV_PROTECTED: originator is currently protected (after reboot)
  66  */
  67 enum batadv_dup_status {
  68         BATADV_NO_DUP = 0,
  69         BATADV_ORIG_DUP,
  70         BATADV_NEIGH_DUP,
  71         BATADV_PROTECTED,
  72 };
  73
  74 /**
  75  * batadv_ring_buffer_set - update the ring buffer with the given value
  76  * @lq_recv: pointer to the ring buffer
  77  * @lq_index: index to store the value at
  78  * @value: value to store in the ring buffer
  79  */
  80 static void batadv_ring_buffer_set(u8 lq_recv[], u8 *lq_index, u8 value)
  81 {
  82         lq_recv[*lq_index] = value;
  83         *lq_index = (*lq_index + 1) % BATADV_TQ_GLOBAL_WINDOW_SIZE;
  84 }
  85
  86 /**
  87  * batadv_ring_buffer_avg - compute the average of all non-zero values stored
  88  * in the given ring buffer
  89  * @lq_recv: pointer to the ring buffer
  90  *
  91  * Returns computed average value.
  92  */
  93 static u8 batadv_ring_buffer_avg(const u8 lq_recv[])
  94 {
  95         const u8 *ptr;
  96         u16 count = 0;
  97         u16 i = 0;
  98         u16 sum = 0;
  99
 100         ptr = lq_recv;
 101
 102         while (i < BATADV_TQ_GLOBAL_WINDOW_SIZE) {
 103                 if (*ptr != 0) {
 104                         count++;
 105                         sum += *ptr;
 106                 }
 107
 108                 i++;
 109                 ptr++;
 110         }
 111
 112         if (count == 0)
 113                 return 0;
 114
 115         return (u8)(sum / count);
 116 }
 117
 118 /**
 119  * batadv_iv_ogm_orig_free - free the private resources allocated for this
 120  *  orig_node
 121  * @orig_node: the orig_node for which the resources have to be free'd
 122  */
 123 static void batadv_iv_ogm_orig_free(struct batadv_orig_node *orig_node)
 124 {
 125         kfree(orig_node->bat_iv.bcast_own);
 126         kfree(orig_node->bat_iv.bcast_own_sum);
 127 }
 128
 129 /**
 130  * batadv_iv_ogm_orig_add_if - change the private structures of the orig_node to
 131  *  include the new hard-interface
 132  * @orig_node: the orig_node that has to be changed
 133  * @max_if_num: the current amount of interfaces
 134  *
 135  * Returns 0 on success, a negative error code otherwise.
 136  */
 137 static int batadv_iv_ogm_orig_add_if(struct batadv_orig_node *orig_node,
 138                                      int max_if_num)
 139 {
 140         void *data_ptr;
 141         size_t old_size;
 142         int ret = -ENOMEM;
 143
 144         spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 145
 146         old_size = (max_if_num - 1) * sizeof(unsigned long) * BATADV_NUM_WORDS;
 147         data_ptr = kmalloc_array(max_if_num,
 148                                  BATADV_NUM_WORDS * sizeof(unsigned long),
 149                                  GFP_ATOMIC);
 150         if (!data_ptr)
 151                 goto unlock;
 152
 153         memcpy(data_ptr, orig_node->bat_iv.bcast_own, old_size);
 154         kfree(orig_node->bat_iv.bcast_own);
 155         orig_node->bat_iv.bcast_own = data_ptr;
 156
 157         data_ptr = kmalloc_array(max_if_num, sizeof(u8), GFP_ATOMIC);
 158         if (!data_ptr) {
 159                 kfree(orig_node->bat_iv.bcast_own);
 160                 goto unlock;
 161         }
 162
 163         memcpy(data_ptr, orig_node->bat_iv.bcast_own_sum,
 164                (max_if_num - 1) * sizeof(u8));
 165         kfree(orig_node->bat_iv.bcast_own_sum);
 166         orig_node->bat_iv.bcast_own_sum = data_ptr;
 167
 168         ret = 0;
 169
 170 unlock:
 171         spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 172
 173         return ret;
 174 }
 175
 176 /**
 177  * batadv_iv_ogm_orig_del_if - change the private structures of the orig_node to
 178  *  exclude the removed interface
 179  * @orig_node: the orig_node that has to be changed
 180  * @max_if_num: the current amount of interfaces
 181  * @del_if_num: the index of the interface being removed
 182  *
 183  * Returns 0 on success, a negative error code otherwise.
 184  */
 185 static int batadv_iv_ogm_orig_del_if(struct batadv_orig_node *orig_node,
 186                                      int max_if_num, int del_if_num)
 187 {
 188         int chunk_size,  ret = -ENOMEM, if_offset;
 189         void *data_ptr = NULL;
 190
 191         spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 192
 193         /* last interface was removed */
 194         if (max_if_num == 0)
 195                 goto free_bcast_own;
 196
 197         chunk_size = sizeof(unsigned long) * BATADV_NUM_WORDS;
 198         data_ptr = kmalloc_array(max_if_num, chunk_size, GFP_ATOMIC);
 199         if (!data_ptr)
 200                 goto unlock;
 201
 202         /* copy first part */
 203         memcpy(data_ptr, orig_node->bat_iv.bcast_own, del_if_num * chunk_size);
 204
 205         /* copy second part */
 206         memcpy((char *)data_ptr + del_if_num * chunk_size,
 207                orig_node->bat_iv.bcast_own + ((del_if_num + 1) * chunk_size),
 208                (max_if_num - del_if_num) * chunk_size);
 209
 210 free_bcast_own:
 211         kfree(orig_node->bat_iv.bcast_own);
 212         orig_node->bat_iv.bcast_own = data_ptr;
 213
 214         if (max_if_num == 0)
 215                 goto free_own_sum;
 216
 217         data_ptr = kmalloc_array(max_if_num, sizeof(u8), GFP_ATOMIC);
 218         if (!data_ptr) {
 219                 kfree(orig_node->bat_iv.bcast_own);
 220                 goto unlock;
 221         }
 222
 223         memcpy(data_ptr, orig_node->bat_iv.bcast_own_sum,
 224                del_if_num * sizeof(u8));
 225
 226         if_offset = (del_if_num + 1) * sizeof(u8);
 227         memcpy((char *)data_ptr + del_if_num * sizeof(u8),
 228                orig_node->bat_iv.bcast_own_sum + if_offset,
 229                (max_if_num - del_if_num) * sizeof(u8));
 230
 231 free_own_sum:
 232         kfree(orig_node->bat_iv.bcast_own_sum);
 233         orig_node->bat_iv.bcast_own_sum = data_ptr;
 234
 235         ret = 0;
 236 unlock:
 237         spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 238
 239         return ret;
 240 }
 241
 242 /**
 243  * batadv_iv_ogm_orig_get - retrieve or create (if does not exist) an originator
 244  * @bat_priv: the bat priv with all the soft interface information
 245  * @addr: mac address of the originator
 246  *
 247  * Returns the originator object corresponding to the passed mac address or NULL
 248  * on failure.
 249  * If the object does not exists it is created an initialised.
 250  */
 251 static struct batadv_orig_node *
 252 batadv_iv_ogm_orig_get(struct batadv_priv *bat_priv, const u8 *addr)
 253 {
 254         struct batadv_orig_node *orig_node;
 255         int size, hash_added;
 256
 257         orig_node = batadv_orig_hash_find(bat_priv, addr);
 258         if (orig_node)
 259                 return orig_node;
 260
 261         orig_node = batadv_orig_node_new(bat_priv, addr);
 262         if (!orig_node)
 263                 return NULL;
 264
 265         spin_lock_init(&orig_node->bat_iv.ogm_cnt_lock);
 266
 267         size = bat_priv->num_ifaces * sizeof(unsigned long) * BATADV_NUM_WORDS;
 268         orig_node->bat_iv.bcast_own = kzalloc(size, GFP_ATOMIC);
 269         if (!orig_node->bat_iv.bcast_own)
 270                 goto free_orig_node;
 271
 272         size = bat_priv->num_ifaces * sizeof(u8);
 273         orig_node->bat_iv.bcast_own_sum = kzalloc(size, GFP_ATOMIC);
 274         if (!orig_node->bat_iv.bcast_own_sum)
 275                 goto free_orig_node;
 276
 277         hash_added = batadv_hash_add(bat_priv->orig_hash, batadv_compare_orig,
 278                                      batadv_choose_orig, orig_node,
 279                                      &orig_node->hash_entry);
 280         if (hash_added != 0)
 281                 goto free_orig_node;
 282
 283         return orig_node;
 284
 285 free_orig_node:
 286         /* free twice, as batadv_orig_node_new sets refcount to 2 */
 287         batadv_orig_node_free_ref(orig_node);
 288         batadv_orig_node_free_ref(orig_node);
 289
 290         return NULL;
 291 }
 292
 293 static struct batadv_neigh_node *
 294 batadv_iv_ogm_neigh_new(struct batadv_hard_iface *hard_iface,
 295                         const u8 *neigh_addr,
 296                         struct batadv_orig_node *orig_node,
 297                         struct batadv_orig_node *orig_neigh)
 298 {
 299         struct batadv_neigh_node *neigh_node;
 300
 301         neigh_node = batadv_neigh_node_new(orig_node, hard_iface, neigh_addr);
 302         if (!neigh_node)
 303                 goto out;
 304
 305         neigh_node->orig_node = orig_neigh;
 306
 307 out:
 308         return neigh_node;
 309 }
 310
 311 static int batadv_iv_ogm_iface_enable(struct batadv_hard_iface *hard_iface)
 312 {
 313         struct batadv_ogm_packet *batadv_ogm_packet;
 314         unsigned char *ogm_buff;
 315         u32 random_seqno;
 316
 317         /* randomize initial seqno to avoid collision */
 318         get_random_bytes(&random_seqno, sizeof(random_seqno));
 319         atomic_set(&hard_iface->bat_iv.ogm_seqno, random_seqno);
 320
 321         hard_iface->bat_iv.ogm_buff_len = BATADV_OGM_HLEN;
 322         ogm_buff = kmalloc(hard_iface->bat_iv.ogm_buff_len, GFP_ATOMIC);
 323         if (!ogm_buff)
 324                 return -ENOMEM;
 325
 326         hard_iface->bat_iv.ogm_buff = ogm_buff;
 327
 328         batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
 329         batadv_ogm_packet->packet_type = BATADV_IV_OGM;
 330         batadv_ogm_packet->version = BATADV_COMPAT_VERSION;
 331         batadv_ogm_packet->ttl = 2;
 332         batadv_ogm_packet->flags = BATADV_NO_FLAGS;
 333         batadv_ogm_packet->reserved = 0;
 334         batadv_ogm_packet->tq = BATADV_TQ_MAX_VALUE;
 335
 336         return 0;
 337 }
 338
 339 static void batadv_iv_ogm_iface_disable(struct batadv_hard_iface *hard_iface)
 340 {
 341         kfree(hard_iface->bat_iv.ogm_buff);
 342         hard_iface->bat_iv.ogm_buff = NULL;
 343 }
 344
 345 static void batadv_iv_ogm_iface_update_mac(struct batadv_hard_iface *hard_iface)
 346 {
 347         struct batadv_ogm_packet *batadv_ogm_packet;
 348         unsigned char *ogm_buff = hard_iface->bat_iv.ogm_buff;
 349
 350         batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
 351         ether_addr_copy(batadv_ogm_packet->orig,
 352                         hard_iface->net_dev->dev_addr);
 353         ether_addr_copy(batadv_ogm_packet->prev_sender,
 354                         hard_iface->net_dev->dev_addr);
 355 }
 356
 357 static void
 358 batadv_iv_ogm_primary_iface_set(struct batadv_hard_iface *hard_iface)
 359 {
 360         struct batadv_ogm_packet *batadv_ogm_packet;
 361         unsigned char *ogm_buff = hard_iface->bat_iv.ogm_buff;
 362
 363         batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
 364         batadv_ogm_packet->flags = BATADV_PRIMARIES_FIRST_HOP;
 365         batadv_ogm_packet->ttl = BATADV_TTL;
 366 }
 367
 368 /* when do we schedule our own ogm to be sent */
 369 static unsigned long
 370 batadv_iv_ogm_emit_send_time(const struct batadv_priv *bat_priv)
 371 {
 372         unsigned int msecs;
 373
 374         msecs = atomic_read(&bat_priv->orig_interval) - BATADV_JITTER;
 375         msecs += prandom_u32() % (2 * BATADV_JITTER);
 376
 377         return jiffies + msecs_to_jiffies(msecs);
 378 }
 379
 380 /* when do we schedule a ogm packet to be sent */
 381 static unsigned long batadv_iv_ogm_fwd_send_time(void)
 382 {
 383         return jiffies + msecs_to_jiffies(prandom_u32() % (BATADV_JITTER / 2));
 384 }
 385
 386 /* apply hop penalty for a normal link */
 387 static u8 batadv_hop_penalty(u8 tq, const struct batadv_priv *bat_priv)
 388 {
 389         int hop_penalty = atomic_read(&bat_priv->hop_penalty);
 390         int new_tq;
 391
 392         new_tq = tq * (BATADV_TQ_MAX_VALUE - hop_penalty);
 393         new_tq /= BATADV_TQ_MAX_VALUE;
 394
 395         return new_tq;
 396 }
 397
 398 /* is there another aggregated packet here? */
 399 static bool batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len,
 400                                       __be16 tvlv_len)
 401 {
 402         int next_buff_pos = 0;
 403
 404         next_buff_pos += buff_pos + BATADV_OGM_HLEN;
 405         next_buff_pos += ntohs(tvlv_len);
 406
 407         return (next_buff_pos <= packet_len) &&
 408                (next_buff_pos <= BATADV_MAX_AGGREGATION_BYTES);
 409 }
 410
 411 /* send a batman ogm to a given interface */
 412 static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet,
 413                                      struct batadv_hard_iface *hard_iface)
 414 {
 415         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 416         const char *fwd_str;
 417         u8 packet_num;
 418         s16 buff_pos;
 419         struct batadv_ogm_packet *batadv_ogm_packet;
 420         struct sk_buff *skb;
 421         u8 *packet_pos;
 422
 423         if (hard_iface->if_status != BATADV_IF_ACTIVE)
 424                 return;
 425
 426         packet_num = 0;
 427         buff_pos = 0;
 428         packet_pos = forw_packet->skb->data;
 429         batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
 430
 431         /* adjust all flags and log packets */
 432         while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
 433                                          batadv_ogm_packet->tvlv_len)) {
 434                 /* we might have aggregated direct link packets with an
 435                  * ordinary base packet
 436                  */
 437                 if (forw_packet->direct_link_flags & BIT(packet_num) &&
 438                     forw_packet->if_incoming == hard_iface)
 439                         batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
 440                 else
 441                         batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
 442
 443                 if (packet_num > 0 || !forw_packet->own)
 444                         fwd_str = "Forwarding";
 445                 else
 446                         fwd_str = "Sending own";
 447
 448                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 449                            "%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s) on interface %s [%pM]\n",
 450                            fwd_str, (packet_num > 0 ? "aggregated " : ""),
 451                            batadv_ogm_packet->orig,
 452                            ntohl(batadv_ogm_packet->seqno),
 453                            batadv_ogm_packet->tq, batadv_ogm_packet->ttl,
 454                            ((batadv_ogm_packet->flags & BATADV_DIRECTLINK) ?
 455                             "on" : "off"),
 456                            hard_iface->net_dev->name,
 457                            hard_iface->net_dev->dev_addr);
 458
 459                 buff_pos += BATADV_OGM_HLEN;
 460                 buff_pos += ntohs(batadv_ogm_packet->tvlv_len);
 461                 packet_num++;
 462                 packet_pos = forw_packet->skb->data + buff_pos;
 463                 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
 464         }
 465
 466         /* create clone because function is called more than once */
 467         skb = skb_clone(forw_packet->skb, GFP_ATOMIC);
 468         if (skb) {
 469                 batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_TX);
 470                 batadv_add_counter(bat_priv, BATADV_CNT_MGMT_TX_BYTES,
 471                                    skb->len + ETH_HLEN);
 472                 batadv_send_skb_packet(skb, hard_iface, batadv_broadcast_addr);
 473         }
 474 }
 475
 476 /* send a batman ogm packet */
 477 static void batadv_iv_ogm_emit(struct batadv_forw_packet *forw_packet)
 478 {
 479         struct net_device *soft_iface;
 480         struct batadv_priv *bat_priv;
 481         struct batadv_hard_iface *primary_if = NULL;
 482
 483         if (!forw_packet->if_incoming) {
 484                 pr_err("Error - can't forward packet: incoming iface not specified\n");
 485                 goto out;
 486         }
 487
 488         soft_iface = forw_packet->if_incoming->soft_iface;
 489         bat_priv = netdev_priv(soft_iface);
 490
 491         if (WARN_ON(!forw_packet->if_outgoing))
 492                 goto out;
 493
 494         if (WARN_ON(forw_packet->if_outgoing->soft_iface != soft_iface))
 495                 goto out;
 496
 497         if (forw_packet->if_incoming->if_status != BATADV_IF_ACTIVE)
 498                 goto out;
 499
 500         primary_if = batadv_primary_if_get_selected(bat_priv);
 501         if (!primary_if)
 502                 goto out;
 503
 504         /* only for one specific outgoing interface */
 505         batadv_iv_ogm_send_to_if(forw_packet, forw_packet->if_outgoing);
 506
 507 out:
 508         if (primary_if)
 509                 batadv_hardif_free_ref(primary_if);
 510 }
 511
 512 /**
 513  * batadv_iv_ogm_can_aggregate - find out if an OGM can be aggregated on an
 514  *  existing forward packet
 515  * @new_bat_ogm_packet: OGM packet to be aggregated
 516  * @bat_priv: the bat priv with all the soft interface information
 517  * @packet_len: (total) length of the OGM
 518  * @send_time: timestamp (jiffies) when the packet is to be sent
 519  * @directlink: true if this is a direct link packet
 520  * @if_incoming: interface where the packet was received
 521  * @if_outgoing: interface for which the retransmission should be considered
 522  * @forw_packet: the forwarded packet which should be checked
 523  *
 524  * Returns true if new_packet can be aggregated with forw_packet
 525  */
 526 static bool
 527 batadv_iv_ogm_can_aggregate(const struct batadv_ogm_packet *new_bat_ogm_packet,
 528                             struct batadv_priv *bat_priv,
 529                             int packet_len, unsigned long send_time,
 530                             bool directlink,
 531                             const struct batadv_hard_iface *if_incoming,
 532                             const struct batadv_hard_iface *if_outgoing,
 533                             const struct batadv_forw_packet *forw_packet)
 534 {
 535         struct batadv_ogm_packet *batadv_ogm_packet;
 536         int aggregated_bytes = forw_packet->packet_len + packet_len;
 537         struct batadv_hard_iface *primary_if = NULL;
 538         bool res = false;
 539         unsigned long aggregation_end_time;
 540
 541         batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data;
 542         aggregation_end_time = send_time;
 543         aggregation_end_time += msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
 544
 545         /* we can aggregate the current packet to this aggregated packet
 546          * if:
 547          *
 548          * - the send time is within our MAX_AGGREGATION_MS time
 549          * - the resulting packet wont be bigger than
 550          *   MAX_AGGREGATION_BYTES
 551          * otherwise aggregation is not possible
 552          */
 553         if (!time_before(send_time, forw_packet->send_time) ||
 554             !time_after_eq(aggregation_end_time, forw_packet->send_time))
 555                 return false;
 556
 557         if (aggregated_bytes > BATADV_MAX_AGGREGATION_BYTES)
 558                 return false;
 559
 560         /* packet is not leaving on the same interface. */
 561         if (forw_packet->if_outgoing != if_outgoing)
 562                 return false;
 563
 564         /* check aggregation compatibility
 565          * -> direct link packets are broadcasted on
 566          *    their interface only
 567          * -> aggregate packet if the current packet is
 568          *    a "global" packet as well as the base
 569          *    packet
 570          */
 571         primary_if = batadv_primary_if_get_selected(bat_priv);
 572         if (!primary_if)
 573                 return false;
 574
 575         /* packets without direct link flag and high TTL
 576          * are flooded through the net
 577          */
 578         if (!directlink &&
 579             !(batadv_ogm_packet->flags & BATADV_DIRECTLINK) &&
 580             batadv_ogm_packet->ttl != 1 &&
 581
 582             /* own packets originating non-primary
 583              * interfaces leave only that interface
 584              */
 585             (!forw_packet->own ||
 586              forw_packet->if_incoming == primary_if)) {
 587                 res = true;
 588                 goto out;
 589         }
 590
 591         /* if the incoming packet is sent via this one
 592          * interface only - we still can aggregate
 593          */
 594         if (directlink &&
 595             new_bat_ogm_packet->ttl == 1 &&
 596             forw_packet->if_incoming == if_incoming &&
 597
 598             /* packets from direct neighbors or
 599              * own secondary interface packets
 600              * (= secondary interface packets in general)
 601              */
 602             (batadv_ogm_packet->flags & BATADV_DIRECTLINK ||
 603              (forw_packet->own &&
 604               forw_packet->if_incoming != primary_if))) {
 605                 res = true;
 606                 goto out;
 607         }
 608
 609 out:
 610         if (primary_if)
 611                 batadv_hardif_free_ref(primary_if);
 612         return res;
 613 }
 614
 615 /**
 616  * batadv_iv_ogm_aggregate_new - create a new aggregated packet and add this
 617  *  packet to it.
 618  * @packet_buff: pointer to the OGM
 619  * @packet_len: (total) length of the OGM
 620  * @send_time: timestamp (jiffies) when the packet is to be sent
 621  * @direct_link: whether this OGM has direct link status
 622  * @if_incoming: interface where the packet was received
 623  * @if_outgoing: interface for which the retransmission should be considered
 624  * @own_packet: true if it is a self-generated ogm
 625  */
 626 static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
 627                                         int packet_len, unsigned long send_time,
 628                                         bool direct_link,
 629                                         struct batadv_hard_iface *if_incoming,
 630                                         struct batadv_hard_iface *if_outgoing,
 631                                         int own_packet)
 632 {
 633         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 634         struct batadv_forw_packet *forw_packet_aggr;
 635         unsigned char *skb_buff;
 636         unsigned int skb_size;
 637
 638         if (!atomic_inc_not_zero(&if_incoming->refcount))
 639                 return;
 640
 641         if (!atomic_inc_not_zero(&if_outgoing->refcount))
 642                 goto out_free_incoming;
 643
 644         /* own packet should always be scheduled */
 645         if (!own_packet) {
 646                 if (!batadv_atomic_dec_not_zero(&bat_priv->batman_queue_left)) {
 647                         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 648                                    "batman packet queue full\n");
 649                         goto out_free_outgoing;
 650                 }
 651         }
 652
 653         forw_packet_aggr = kmalloc(sizeof(*forw_packet_aggr), GFP_ATOMIC);
 654         if (!forw_packet_aggr)
 655                 goto out_nomem;
 656
 657         if (atomic_read(&bat_priv->aggregated_ogms) &&
 658             packet_len < BATADV_MAX_AGGREGATION_BYTES)
 659                 skb_size = BATADV_MAX_AGGREGATION_BYTES;
 660         else
 661                 skb_size = packet_len;
 662
 663         skb_size += ETH_HLEN;
 664
 665         forw_packet_aggr->skb = netdev_alloc_skb_ip_align(NULL, skb_size);
 666         if (!forw_packet_aggr->skb)
 667                 goto out_free_forw_packet;
 668         forw_packet_aggr->skb->priority = TC_PRIO_CONTROL;
 669         skb_reserve(forw_packet_aggr->skb, ETH_HLEN);
 670
 671         skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
 672         forw_packet_aggr->packet_len = packet_len;
 673         memcpy(skb_buff, packet_buff, packet_len);
 674
 675         forw_packet_aggr->own = own_packet;
 676         forw_packet_aggr->if_incoming = if_incoming;
 677         forw_packet_aggr->if_outgoing = if_outgoing;
 678         forw_packet_aggr->num_packets = 0;
 679         forw_packet_aggr->direct_link_flags = BATADV_NO_FLAGS;
 680         forw_packet_aggr->send_time = send_time;
 681
 682         /* save packet direct link flag status */
 683         if (direct_link)
 684                 forw_packet_aggr->direct_link_flags |= 1;
 685
 686         /* add new packet to packet list */
 687         spin_lock_bh(&bat_priv->forw_bat_list_lock);
 688         hlist_add_head(&forw_packet_aggr->list, &bat_priv->forw_bat_list);
 689         spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 690
 691         /* start timer for this packet */
 692         INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work,
 693                           batadv_send_outstanding_bat_ogm_packet);
 694         queue_delayed_work(batadv_event_workqueue,
 695                            &forw_packet_aggr->delayed_work,
 696                            send_time - jiffies);
 697
 698         return;
 699 out_free_forw_packet:
 700         kfree(forw_packet_aggr);
 701 out_nomem:
 702         if (!own_packet)
 703                 atomic_inc(&bat_priv->batman_queue_left);
 704 out_free_outgoing:
 705         batadv_hardif_free_ref(if_outgoing);
 706 out_free_incoming:
 707         batadv_hardif_free_ref(if_incoming);
 708 }
 709
 710 /* aggregate a new packet into the existing ogm packet */
 711 static void batadv_iv_ogm_aggregate(struct batadv_forw_packet *forw_packet_aggr,
 712                                     const unsigned char *packet_buff,
 713                                     int packet_len, bool direct_link)
 714 {
 715         unsigned char *skb_buff;
 716         unsigned long new_direct_link_flag;
 717
 718         skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
 719         memcpy(skb_buff, packet_buff, packet_len);
 720         forw_packet_aggr->packet_len += packet_len;
 721         forw_packet_aggr->num_packets++;
 722
 723         /* save packet direct link flag status */
 724         if (direct_link) {
 725                 new_direct_link_flag = BIT(forw_packet_aggr->num_packets);
 726                 forw_packet_aggr->direct_link_flags |= new_direct_link_flag;
 727         }
 728 }
 729
 730 /**
 731  * batadv_iv_ogm_queue_add - queue up an OGM for transmission
 732  * @bat_priv: the bat priv with all the soft interface information
 733  * @packet_buff: pointer to the OGM
 734  * @packet_len: (total) length of the OGM
 735  * @if_incoming: interface where the packet was received
 736  * @if_outgoing: interface for which the retransmission should be considered
 737  * @own_packet: true if it is a self-generated ogm
 738  * @send_time: timestamp (jiffies) when the packet is to be sent
 739  */
 740 static void batadv_iv_ogm_queue_add(struct batadv_priv *bat_priv,
 741                                     unsigned char *packet_buff,
 742                                     int packet_len,
 743                                     struct batadv_hard_iface *if_incoming,
 744                                     struct batadv_hard_iface *if_outgoing,
 745                                     int own_packet, unsigned long send_time)
 746 {
 747         /* _aggr -> pointer to the packet we want to aggregate with
 748          * _pos -> pointer to the position in the queue
 749          */
 750         struct batadv_forw_packet *forw_packet_aggr = NULL;
 751         struct batadv_forw_packet *forw_packet_pos = NULL;
 752         struct batadv_ogm_packet *batadv_ogm_packet;
 753         bool direct_link;
 754         unsigned long max_aggregation_jiffies;
 755
 756         batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff;
 757         direct_link = !!(batadv_ogm_packet->flags & BATADV_DIRECTLINK);
 758         max_aggregation_jiffies = msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
 759
 760         /* find position for the packet in the forward queue */
 761         spin_lock_bh(&bat_priv->forw_bat_list_lock);
 762         /* own packets are not to be aggregated */
 763         if (atomic_read(&bat_priv->aggregated_ogms) && !own_packet) {
 764                 hlist_for_each_entry(forw_packet_pos,
 765                                      &bat_priv->forw_bat_list, list) {
 766                         if (batadv_iv_ogm_can_aggregate(batadv_ogm_packet,
 767                                                         bat_priv, packet_len,
 768                                                         send_time, direct_link,
 769                                                         if_incoming,
 770                                                         if_outgoing,
 771                                                         forw_packet_pos)) {
 772                                 forw_packet_aggr = forw_packet_pos;
 773                                 break;
 774                         }
 775                 }
 776         }
 777
 778         /* nothing to aggregate with - either aggregation disabled or no
 779          * suitable aggregation packet found
 780          */
 781         if (!forw_packet_aggr) {
 782                 /* the following section can run without the lock */
 783                 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 784
 785                 /* if we could not aggregate this packet with one of the others
 786                  * we hold it back for a while, so that it might be aggregated
 787                  * later on
 788                  */
 789                 if (!own_packet && atomic_read(&bat_priv->aggregated_ogms))
 790                         send_time += max_aggregation_jiffies;
 791
 792                 batadv_iv_ogm_aggregate_new(packet_buff, packet_len,
 793                                             send_time, direct_link,
 794                                             if_incoming, if_outgoing,
 795                                             own_packet);
 796         } else {
 797                 batadv_iv_ogm_aggregate(forw_packet_aggr, packet_buff,
 798                                         packet_len, direct_link);
 799                 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 800         }
 801 }
 802
 803 static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node,
 804                                   const struct ethhdr *ethhdr,
 805                                   struct batadv_ogm_packet *batadv_ogm_packet,
 806                                   bool is_single_hop_neigh,
 807                                   bool is_from_best_next_hop,
 808                                   struct batadv_hard_iface *if_incoming,
 809                                   struct batadv_hard_iface *if_outgoing)
 810 {
 811         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 812         u16 tvlv_len;
 813
 814         if (batadv_ogm_packet->ttl <= 1) {
 815                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "ttl exceeded\n");
 816                 return;
 817         }
 818
 819         if (!is_from_best_next_hop) {
 820                 /* Mark the forwarded packet when it is not coming from our
 821                  * best next hop. We still need to forward the packet for our
 822                  * neighbor link quality detection to work in case the packet
 823                  * originated from a single hop neighbor. Otherwise we can
 824                  * simply drop the ogm.
 825                  */
 826                 if (is_single_hop_neigh)
 827                         batadv_ogm_packet->flags |= BATADV_NOT_BEST_NEXT_HOP;
 828                 else
 829                         return;
 830         }
 831
 832         tvlv_len = ntohs(batadv_ogm_packet->tvlv_len);
 833
 834         batadv_ogm_packet->ttl--;
 835         ether_addr_copy(batadv_ogm_packet->prev_sender, ethhdr->h_source);
 836
 837         /* apply hop penalty */
 838         batadv_ogm_packet->tq = batadv_hop_penalty(batadv_ogm_packet->tq,
 839                                                    bat_priv);
 840
 841         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 842                    "Forwarding packet: tq: %i, ttl: %i\n",
 843                    batadv_ogm_packet->tq, batadv_ogm_packet->ttl);
 844
 845         /* switch of primaries first hop flag when forwarding */
 846         batadv_ogm_packet->flags &= ~BATADV_PRIMARIES_FIRST_HOP;
 847         if (is_single_hop_neigh)
 848                 batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
 849         else
 850                 batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
 851
 852         batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batadv_ogm_packet,
 853                                 BATADV_OGM_HLEN + tvlv_len,
 854                                 if_incoming, if_outgoing, 0,
 855                                 batadv_iv_ogm_fwd_send_time());
 856 }
 857
 858 /**
 859  * batadv_iv_ogm_slide_own_bcast_window - bitshift own OGM broadcast windows for
 860  * the given interface
 861  * @hard_iface: the interface for which the windows have to be shifted
 862  */
 863 static void
 864 batadv_iv_ogm_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)
 865 {
 866         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 867         struct batadv_hashtable *hash = bat_priv->orig_hash;
 868         struct hlist_head *head;
 869         struct batadv_orig_node *orig_node;
 870         unsigned long *word;
 871         u32 i;
 872         size_t word_index;
 873         u8 *w;
 874         int if_num;
 875
 876         for (i = 0; i < hash->size; i++) {
 877                 head = &hash->table[i];
 878
 879                 rcu_read_lock();
 880                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
 881                         spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 882                         word_index = hard_iface->if_num * BATADV_NUM_WORDS;
 883                         word = &orig_node->bat_iv.bcast_own[word_index];
 884
 885                         batadv_bit_get_packet(bat_priv, word, 1, 0);
 886                         if_num = hard_iface->if_num;
 887                         w = &orig_node->bat_iv.bcast_own_sum[if_num];
 888                         *w = bitmap_weight(word, BATADV_TQ_LOCAL_WINDOW_SIZE);
 889                         spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 890                 }
 891                 rcu_read_unlock();
 892         }
 893 }
 894
 895 static void batadv_iv_ogm_schedule(struct batadv_hard_iface *hard_iface)
 896 {
 897         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 898         unsigned char **ogm_buff = &hard_iface->bat_iv.ogm_buff;
 899         struct batadv_ogm_packet *batadv_ogm_packet;
 900         struct batadv_hard_iface *primary_if, *tmp_hard_iface;
 901         int *ogm_buff_len = &hard_iface->bat_iv.ogm_buff_len;
 902         u32 seqno;
 903         u16 tvlv_len = 0;
 904         unsigned long send_time;
 905
 906         primary_if = batadv_primary_if_get_selected(bat_priv);
 907
 908         if (hard_iface == primary_if) {
 909                 /* tt changes have to be committed before the tvlv data is
 910                  * appended as it may alter the tt tvlv container
 911                  */
 912                 batadv_tt_local_commit_changes(bat_priv);
 913                 tvlv_len = batadv_tvlv_container_ogm_append(bat_priv, ogm_buff,
 914                                                             ogm_buff_len,
 915                                                             BATADV_OGM_HLEN);
 916         }
 917
 918         batadv_ogm_packet = (struct batadv_ogm_packet *)(*ogm_buff);
 919         batadv_ogm_packet->tvlv_len = htons(tvlv_len);
 920
 921         /* change sequence number to network order */
 922         seqno = (u32)atomic_read(&hard_iface->bat_iv.ogm_seqno);
 923         batadv_ogm_packet->seqno = htonl(seqno);
 924         atomic_inc(&hard_iface->bat_iv.ogm_seqno);
 925
 926         batadv_iv_ogm_slide_own_bcast_window(hard_iface);
 927
 928         send_time = batadv_iv_ogm_emit_send_time(bat_priv);
 929
 930         if (hard_iface != primary_if) {
 931                 /* OGMs from secondary interfaces are only scheduled on their
 932                  * respective interfaces.
 933                  */
 934                 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff, *ogm_buff_len,
 935                                         hard_iface, hard_iface, 1, send_time);
 936                 goto out;
 937         }
 938
 939         /* OGMs from primary interfaces are scheduled on all
 940          * interfaces.
 941          */
 942         rcu_read_lock();
 943         list_for_each_entry_rcu(tmp_hard_iface, &batadv_hardif_list, list) {
 944                 if (tmp_hard_iface->soft_iface != hard_iface->soft_iface)
 945                         continue;
 946                 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff,
 947                                         *ogm_buff_len, hard_iface,
 948                                         tmp_hard_iface, 1, send_time);
 949         }
 950         rcu_read_unlock();
 951
 952 out:
 953         if (primary_if)
 954                 batadv_hardif_free_ref(primary_if);
 955 }
 956
 957 /**
 958  * batadv_iv_ogm_orig_update - use OGM to update corresponding data in an
 959  *  originator
 960  * @bat_priv: the bat priv with all the soft interface information
 961  * @orig_node: the orig node who originally emitted the ogm packet
 962  * @orig_ifinfo: ifinfo for the outgoing interface of the orig_node
 963  * @ethhdr: Ethernet header of the OGM
 964  * @batadv_ogm_packet: the ogm packet
 965  * @if_incoming: interface where the packet was received
 966  * @if_outgoing: interface for which the retransmission should be considered
 967  * @dup_status: the duplicate status of this ogm packet.
 968  */
 969 static void
 970 batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv,
 971                           struct batadv_orig_node *orig_node,
 972                           struct batadv_orig_ifinfo *orig_ifinfo,
 973                           const struct ethhdr *ethhdr,
 974                           const struct batadv_ogm_packet *batadv_ogm_packet,
 975                           struct batadv_hard_iface *if_incoming,
 976                           struct batadv_hard_iface *if_outgoing,
 977                           enum batadv_dup_status dup_status)
 978 {
 979         struct batadv_neigh_ifinfo *neigh_ifinfo = NULL;
 980         struct batadv_neigh_ifinfo *router_ifinfo = NULL;
 981         struct batadv_neigh_node *neigh_node = NULL;
 982         struct batadv_neigh_node *tmp_neigh_node = NULL;
 983         struct batadv_neigh_node *router = NULL;
 984         struct batadv_orig_node *orig_node_tmp;
 985         int if_num;
 986         u8 sum_orig, sum_neigh;
 987         u8 *neigh_addr;
 988         u8 tq_avg;
 989
 990         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 991                    "update_originator(): Searching and updating originator entry of received packet\n");
 992
 993         rcu_read_lock();
 994         hlist_for_each_entry_rcu(tmp_neigh_node,
 995                                  &orig_node->neigh_list, list) {
 996                 neigh_addr = tmp_neigh_node->addr;
 997                 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
 998                     tmp_neigh_node->if_incoming == if_incoming &&
 999                     atomic_inc_not_zero(&tmp_neigh_node->refcount)) {
1000                         if (WARN(neigh_node, "too many matching neigh_nodes"))
1001                                 batadv_neigh_node_free_ref(neigh_node);
1002                         neigh_node = tmp_neigh_node;
1003                         continue;
1004                 }
1005
1006                 if (dup_status != BATADV_NO_DUP)
1007                         continue;
1008
1009                 /* only update the entry for this outgoing interface */
1010                 neigh_ifinfo = batadv_neigh_ifinfo_get(tmp_neigh_node,
1011                                                        if_outgoing);
1012                 if (!neigh_ifinfo)
1013                         continue;
1014
1015                 spin_lock_bh(&tmp_neigh_node->ifinfo_lock);
1016                 batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv,
1017                                        &neigh_ifinfo->bat_iv.tq_index, 0);
1018                 tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv);
1019                 neigh_ifinfo->bat_iv.tq_avg = tq_avg;
1020                 spin_unlock_bh(&tmp_neigh_node->ifinfo_lock);
1021
1022                 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
1023                 neigh_ifinfo = NULL;
1024         }
1025
1026         if (!neigh_node) {
1027                 struct batadv_orig_node *orig_tmp;
1028
1029                 orig_tmp = batadv_iv_ogm_orig_get(bat_priv, ethhdr->h_source);
1030                 if (!orig_tmp)
1031                         goto unlock;
1032
1033                 neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
1034                                                      ethhdr->h_source,
1035                                                      orig_node, orig_tmp);
1036
1037                 batadv_orig_node_free_ref(orig_tmp);
1038                 if (!neigh_node)
1039                         goto unlock;
1040         } else {
1041                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1042                            "Updating existing last-hop neighbor of originator\n");
1043         }
1044
1045         rcu_read_unlock();
1046         neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing);
1047         if (!neigh_ifinfo)
1048                 goto out;
1049
1050         neigh_node->last_seen = jiffies;
1051
1052         spin_lock_bh(&neigh_node->ifinfo_lock);
1053         batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv,
1054                                &neigh_ifinfo->bat_iv.tq_index,
1055                                batadv_ogm_packet->tq);
1056         tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv);
1057         neigh_ifinfo->bat_iv.tq_avg = tq_avg;
1058         spin_unlock_bh(&neigh_node->ifinfo_lock);
1059
1060         if (dup_status == BATADV_NO_DUP) {
1061                 orig_ifinfo->last_ttl = batadv_ogm_packet->ttl;
1062                 neigh_ifinfo->last_ttl = batadv_ogm_packet->ttl;
1063         }
1064
1065         /* if this neighbor already is our next hop there is nothing
1066          * to change
1067          */
1068         router = batadv_orig_router_get(orig_node, if_outgoing);
1069         if (router == neigh_node)
1070                 goto out;
1071
1072         if (router) {
1073                 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing);
1074                 if (!router_ifinfo)
1075                         goto out;
1076
1077                 /* if this neighbor does not offer a better TQ we won't
1078                  * consider it
1079                  */
1080                 if (router_ifinfo->bat_iv.tq_avg > neigh_ifinfo->bat_iv.tq_avg)
1081                         goto out;
1082         }
1083
1084         /* if the TQ is the same and the link not more symmetric we
1085          * won't consider it either
1086          */
1087         if (router_ifinfo &&
1088             neigh_ifinfo->bat_iv.tq_avg == router_ifinfo->bat_iv.tq_avg) {
1089                 orig_node_tmp = router->orig_node;
1090                 spin_lock_bh(&orig_node_tmp->bat_iv.ogm_cnt_lock);
1091                 if_num = router->if_incoming->if_num;
1092                 sum_orig = orig_node_tmp->bat_iv.bcast_own_sum[if_num];
1093                 spin_unlock_bh(&orig_node_tmp->bat_iv.ogm_cnt_lock);
1094
1095                 orig_node_tmp = neigh_node->orig_node;
1096                 spin_lock_bh(&orig_node_tmp->bat_iv.ogm_cnt_lock);
1097                 if_num = neigh_node->if_incoming->if_num;
1098                 sum_neigh = orig_node_tmp->bat_iv.bcast_own_sum[if_num];
1099                 spin_unlock_bh(&orig_node_tmp->bat_iv.ogm_cnt_lock);
1100
1101                 if (sum_orig >= sum_neigh)
1102                         goto out;
1103         }
1104
1105         batadv_update_route(bat_priv, orig_node, if_outgoing, neigh_node);
1106         goto out;
1107
1108 unlock:
1109         rcu_read_unlock();
1110 out:
1111         if (neigh_node)
1112                 batadv_neigh_node_free_ref(neigh_node);
1113         if (router)
1114                 batadv_neigh_node_free_ref(router);
1115         if (neigh_ifinfo)
1116                 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
1117         if (router_ifinfo)
1118                 batadv_neigh_ifinfo_free_ref(router_ifinfo);
1119 }
1120
1121 /**
1122  * batadv_iv_ogm_calc_tq - calculate tq for current received ogm packet
1123  * @orig_node: the orig node who originally emitted the ogm packet
1124  * @orig_neigh_node: the orig node struct of the neighbor who sent the packet
1125  * @batadv_ogm_packet: the ogm packet
1126  * @if_incoming: interface where the packet was received
1127  * @if_outgoing: interface for which the retransmission should be considered
1128  *
1129  * Returns 1 if the link can be considered bidirectional, 0 otherwise
1130  */
1131 static int batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
1132                                  struct batadv_orig_node *orig_neigh_node,
1133                                  struct batadv_ogm_packet *batadv_ogm_packet,
1134                                  struct batadv_hard_iface *if_incoming,
1135                                  struct batadv_hard_iface *if_outgoing)
1136 {
1137         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1138         struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node;
1139         struct batadv_neigh_ifinfo *neigh_ifinfo;
1140         u8 total_count;
1141         u8 orig_eq_count, neigh_rq_count, neigh_rq_inv, tq_own;
1142         unsigned int neigh_rq_inv_cube, neigh_rq_max_cube;
1143         int tq_asym_penalty, inv_asym_penalty, if_num, ret = 0;
1144         unsigned int combined_tq;
1145         int tq_iface_penalty;
1146
1147         /* find corresponding one hop neighbor */
1148         rcu_read_lock();
1149         hlist_for_each_entry_rcu(tmp_neigh_node,
1150                                  &orig_neigh_node->neigh_list, list) {
1151                 if (!batadv_compare_eth(tmp_neigh_node->addr,
1152                                         orig_neigh_node->orig))
1153                         continue;
1154
1155                 if (tmp_neigh_node->if_incoming != if_incoming)
1156                         continue;
1157
1158                 if (!atomic_inc_not_zero(&tmp_neigh_node->refcount))
1159                         continue;
1160
1161                 neigh_node = tmp_neigh_node;
1162                 break;
1163         }
1164         rcu_read_unlock();
1165
1166         if (!neigh_node)
1167                 neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
1168                                                      orig_neigh_node->orig,
1169                                                      orig_neigh_node,
1170                                                      orig_neigh_node);
1171
1172         if (!neigh_node)
1173                 goto out;
1174
1175         /* if orig_node is direct neighbor update neigh_node last_seen */
1176         if (orig_node == orig_neigh_node)
1177                 neigh_node->last_seen = jiffies;
1178
1179         orig_node->last_seen = jiffies;
1180
1181         /* find packet count of corresponding one hop neighbor */
1182         spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1183         if_num = if_incoming->if_num;
1184         orig_eq_count = orig_neigh_node->bat_iv.bcast_own_sum[if_num];
1185         neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing);
1186         if (neigh_ifinfo) {
1187                 neigh_rq_count = neigh_ifinfo->bat_iv.real_packet_count;
1188                 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
1189         } else {
1190                 neigh_rq_count = 0;
1191         }
1192         spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1193
1194         /* pay attention to not get a value bigger than 100 % */
1195         if (orig_eq_count > neigh_rq_count)
1196                 total_count = neigh_rq_count;
1197         else
1198                 total_count = orig_eq_count;
1199
1200         /* if we have too few packets (too less data) we set tq_own to zero
1201          * if we receive too few packets it is not considered bidirectional
1202          */
1203         if (total_count < BATADV_TQ_LOCAL_BIDRECT_SEND_MINIMUM ||
1204             neigh_rq_count < BATADV_TQ_LOCAL_BIDRECT_RECV_MINIMUM)
1205                 tq_own = 0;
1206         else
1207                 /* neigh_node->real_packet_count is never zero as we
1208                  * only purge old information when getting new
1209                  * information
1210                  */
1211                 tq_own = (BATADV_TQ_MAX_VALUE * total_count) /  neigh_rq_count;
1212
1213         /* 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does
1214          * affect the nearly-symmetric links only a little, but
1215          * punishes asymmetric links more.  This will give a value
1216          * between 0 and TQ_MAX_VALUE
1217          */
1218         neigh_rq_inv = BATADV_TQ_LOCAL_WINDOW_SIZE - neigh_rq_count;
1219         neigh_rq_inv_cube = neigh_rq_inv * neigh_rq_inv * neigh_rq_inv;
1220         neigh_rq_max_cube = BATADV_TQ_LOCAL_WINDOW_SIZE *
1221                             BATADV_TQ_LOCAL_WINDOW_SIZE *
1222                             BATADV_TQ_LOCAL_WINDOW_SIZE;
1223         inv_asym_penalty = BATADV_TQ_MAX_VALUE * neigh_rq_inv_cube;
1224         inv_asym_penalty /= neigh_rq_max_cube;
1225         tq_asym_penalty = BATADV_TQ_MAX_VALUE - inv_asym_penalty;
1226
1227         /* penalize if the OGM is forwarded on the same interface. WiFi
1228          * interfaces and other half duplex devices suffer from throughput
1229          * drops as they can't send and receive at the same time.
1230          */
1231         tq_iface_penalty = BATADV_TQ_MAX_VALUE;
1232         if (if_outgoing && (if_incoming == if_outgoing) &&
1233             batadv_is_wifi_netdev(if_outgoing->net_dev))
1234                 tq_iface_penalty = batadv_hop_penalty(BATADV_TQ_MAX_VALUE,
1235                                                       bat_priv);
1236
1237         combined_tq = batadv_ogm_packet->tq *
1238                       tq_own *
1239                       tq_asym_penalty *
1240                       tq_iface_penalty;
1241         combined_tq /= BATADV_TQ_MAX_VALUE *
1242                        BATADV_TQ_MAX_VALUE *
1243                        BATADV_TQ_MAX_VALUE;
1244         batadv_ogm_packet->tq = combined_tq;
1245
1246         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1247                    "bidirectional: orig = %-15pM neigh = %-15pM => own_bcast = %2i, real recv = %2i, local tq: %3i, asym_penalty: %3i, iface_penalty: %3i, total tq: %3i, if_incoming = %s, if_outgoing = %s\n",
1248                    orig_node->orig, orig_neigh_node->orig, total_count,
1249                    neigh_rq_count, tq_own, tq_asym_penalty, tq_iface_penalty,
1250                    batadv_ogm_packet->tq, if_incoming->net_dev->name,
1251                    if_outgoing ? if_outgoing->net_dev->name : "DEFAULT");
1252
1253         /* if link has the minimum required transmission quality
1254          * consider it bidirectional
1255          */
1256         if (batadv_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT)
1257                 ret = 1;
1258
1259 out:
1260         if (neigh_node)
1261                 batadv_neigh_node_free_ref(neigh_node);
1262         return ret;
1263 }
1264
1265 /**
1266  * batadv_iv_ogm_update_seqnos -  process a batman packet for all interfaces,
1267  *  adjust the sequence number and find out whether it is a duplicate
1268  * @ethhdr: ethernet header of the packet
1269  * @batadv_ogm_packet: OGM packet to be considered
1270  * @if_incoming: interface on which the OGM packet was received
1271  * @if_outgoing: interface for which the retransmission should be considered
1272  *
1273  * Returns duplicate status as enum batadv_dup_status
1274  */
1275 static enum batadv_dup_status
1276 batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
1277                             const struct batadv_ogm_packet *batadv_ogm_packet,
1278                             const struct batadv_hard_iface *if_incoming,
1279                             struct batadv_hard_iface *if_outgoing)
1280 {
1281         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1282         struct batadv_orig_node *orig_node;
1283         struct batadv_orig_ifinfo *orig_ifinfo = NULL;
1284         struct batadv_neigh_node *neigh_node;
1285         struct batadv_neigh_ifinfo *neigh_ifinfo;
1286         int is_dup;
1287         s32 seq_diff;
1288         int need_update = 0;
1289         int set_mark;
1290         enum batadv_dup_status ret = BATADV_NO_DUP;
1291         u32 seqno = ntohl(batadv_ogm_packet->seqno);
1292         u8 *neigh_addr;
1293         u8 packet_count;
1294         unsigned long *bitmap;
1295
1296         orig_node = batadv_iv_ogm_orig_get(bat_priv, batadv_ogm_packet->orig);
1297         if (!orig_node)
1298                 return BATADV_NO_DUP;
1299
1300         orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing);
1301         if (WARN_ON(!orig_ifinfo)) {
1302                 batadv_orig_node_free_ref(orig_node);
1303                 return 0;
1304         }
1305
1306         spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1307         seq_diff = seqno - orig_ifinfo->last_real_seqno;
1308
1309         /* signalize caller that the packet is to be dropped. */
1310         if (!hlist_empty(&orig_node->neigh_list) &&
1311             batadv_window_protected(bat_priv, seq_diff,
1312                                     &orig_ifinfo->batman_seqno_reset)) {
1313                 ret = BATADV_PROTECTED;
1314                 goto out;
1315         }
1316
1317         rcu_read_lock();
1318         hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1319                 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node,
1320                                                        if_outgoing);
1321                 if (!neigh_ifinfo)
1322                         continue;
1323
1324                 neigh_addr = neigh_node->addr;
1325                 is_dup = batadv_test_bit(neigh_ifinfo->bat_iv.real_bits,
1326                                          orig_ifinfo->last_real_seqno,
1327                                          seqno);
1328
1329                 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
1330                     neigh_node->if_incoming == if_incoming) {
1331                         set_mark = 1;
1332                         if (is_dup)
1333                                 ret = BATADV_NEIGH_DUP;
1334                 } else {
1335                         set_mark = 0;
1336                         if (is_dup && (ret != BATADV_NEIGH_DUP))
1337                                 ret = BATADV_ORIG_DUP;
1338                 }
1339
1340                 /* if the window moved, set the update flag. */
1341                 bitmap = neigh_ifinfo->bat_iv.real_bits;
1342                 need_update |= batadv_bit_get_packet(bat_priv, bitmap,
1343                                                      seq_diff, set_mark);
1344
1345                 packet_count = bitmap_weight(bitmap,
1346                                              BATADV_TQ_LOCAL_WINDOW_SIZE);
1347                 neigh_ifinfo->bat_iv.real_packet_count = packet_count;
1348                 batadv_neigh_ifinfo_free_ref(neigh_ifinfo);
1349         }
1350         rcu_read_unlock();
1351
1352         if (need_update) {
1353                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1354                            "%s updating last_seqno: old %u, new %u\n",
1355                            if_outgoing ? if_outgoing->net_dev->name : "DEFAULT",
1356                            orig_ifinfo->last_real_seqno, seqno);
1357                 orig_ifinfo->last_real_seqno = seqno;
1358         }
1359
1360 out:
1361         spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1362         batadv_orig_node_free_ref(orig_node);
1363         batadv_orig_ifinfo_free_ref(orig_ifinfo);
1364         return ret;
1365 }
1366
1367 /**
1368  * batadv_iv_ogm_process_per_outif - process a batman iv OGM for an outgoing if
1369  * @skb: the skb containing the OGM
1370  * @ogm_offset: offset from skb->data to start of ogm header
1371  * @orig_node: the (cached) orig node for the originator of this OGM
1372  * @if_incoming: the interface where this packet was received
1373  * @if_outgoing: the interface for which the packet should be considered
1374  */
1375 static void
1376 batadv_iv_ogm_process_per_outif(const struct sk_buff *skb, int ogm_offset,
1377                                 struct batadv_orig_node *orig_node,
1378                                 struct batadv_hard_iface *if_incoming,
1379                                 struct batadv_hard_iface *if_outgoing)
1380 {
1381         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1382         struct batadv_neigh_node *router = NULL;
1383         struct batadv_neigh_node *router_router = NULL;
1384         struct batadv_orig_node *orig_neigh_node;
1385         struct batadv_orig_ifinfo *orig_ifinfo;
1386         struct batadv_neigh_node *orig_neigh_router = NULL;
1387         struct batadv_neigh_ifinfo *router_ifinfo = NULL;
1388         struct batadv_ogm_packet *ogm_packet;
1389         enum batadv_dup_status dup_status;
1390         bool is_from_best_next_hop = false;
1391         bool is_single_hop_neigh = false;
1392         bool sameseq, similar_ttl;
1393         struct sk_buff *skb_priv;
1394         struct ethhdr *ethhdr;
1395         u8 *prev_sender;
1396         int is_bidirect;
1397
1398         /* create a private copy of the skb, as some functions change tq value
1399          * and/or flags.
1400          */
1401         skb_priv = skb_copy(skb, GFP_ATOMIC);
1402         if (!skb_priv)
1403                 return;
1404
1405         ethhdr = eth_hdr(skb_priv);
1406         ogm_packet = (struct batadv_ogm_packet *)(skb_priv->data + ogm_offset);
1407
1408         dup_status = batadv_iv_ogm_update_seqnos(ethhdr, ogm_packet,
1409                                                  if_incoming, if_outgoing);
1410         if (batadv_compare_eth(ethhdr->h_source, ogm_packet->orig))
1411                 is_single_hop_neigh = true;
1412
1413         if (dup_status == BATADV_PROTECTED) {
1414                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1415                            "Drop packet: packet within seqno protection time (sender: %pM)\n",
1416                            ethhdr->h_source);
1417                 goto out;
1418         }
1419
1420         if (ogm_packet->tq == 0) {
1421                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1422                            "Drop packet: originator packet with tq equal 0\n");
1423                 goto out;
1424         }
1425
1426         router = batadv_orig_router_get(orig_node, if_outgoing);
1427         if (router) {
1428                 router_router = batadv_orig_router_get(router->orig_node,
1429                                                        if_outgoing);
1430                 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing);
1431         }
1432
1433         if ((router_ifinfo && router_ifinfo->bat_iv.tq_avg != 0) &&
1434             (batadv_compare_eth(router->addr, ethhdr->h_source)))
1435                 is_from_best_next_hop = true;
1436
1437         prev_sender = ogm_packet->prev_sender;
1438         /* avoid temporary routing loops */
1439         if (router && router_router &&
1440             (batadv_compare_eth(router->addr, prev_sender)) &&
1441             !(batadv_compare_eth(ogm_packet->orig, prev_sender)) &&
1442             (batadv_compare_eth(router->addr, router_router->addr))) {
1443                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1444                            "Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",
1445                            ethhdr->h_source);
1446                 goto out;
1447         }
1448
1449         if (if_outgoing == BATADV_IF_DEFAULT)
1450                 batadv_tvlv_ogm_receive(bat_priv, ogm_packet, orig_node);
1451
1452         /* if sender is a direct neighbor the sender mac equals
1453          * originator mac
1454          */
1455         if (is_single_hop_neigh)
1456                 orig_neigh_node = orig_node;
1457         else
1458                 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv,
1459                                                          ethhdr->h_source);
1460
1461         if (!orig_neigh_node)
1462                 goto out;
1463
1464         /* Update nc_nodes of the originator */
1465         batadv_nc_update_nc_node(bat_priv, orig_node, orig_neigh_node,
1466                                  ogm_packet, is_single_hop_neigh);
1467
1468         orig_neigh_router = batadv_orig_router_get(orig_neigh_node,
1469                                                    if_outgoing);
1470
1471         /* drop packet if sender is not a direct neighbor and if we
1472          * don't route towards it
1473          */
1474         if (!is_single_hop_neigh && (!orig_neigh_router)) {
1475                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1476                            "Drop packet: OGM via unknown neighbor!\n");
1477                 goto out_neigh;
1478         }
1479
1480         is_bidirect = batadv_iv_ogm_calc_tq(orig_node, orig_neigh_node,
1481                                             ogm_packet, if_incoming,
1482                                             if_outgoing);
1483
1484         /* update ranking if it is not a duplicate or has the same
1485          * seqno and similar ttl as the non-duplicate
1486          */
1487         orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing);
1488         if (!orig_ifinfo)
1489                 goto out_neigh;
1490
1491         sameseq = orig_ifinfo->last_real_seqno == ntohl(ogm_packet->seqno);
1492         similar_ttl = (orig_ifinfo->last_ttl - 3) <= ogm_packet->ttl;
1493
1494         if (is_bidirect && ((dup_status == BATADV_NO_DUP) ||
1495                             (sameseq && similar_ttl))) {
1496                 batadv_iv_ogm_orig_update(bat_priv, orig_node,
1497                                           orig_ifinfo, ethhdr,
1498                                           ogm_packet, if_incoming,
1499                                           if_outgoing, dup_status);
1500         }
1501         batadv_orig_ifinfo_free_ref(orig_ifinfo);
1502
1503         /* only forward for specific interface, not for the default one. */
1504         if (if_outgoing == BATADV_IF_DEFAULT)
1505                 goto out_neigh;
1506
1507         /* is single hop (direct) neighbor */
1508         if (is_single_hop_neigh) {
1509                 /* OGMs from secondary interfaces should only scheduled once
1510                  * per interface where it has been received, not multiple times
1511                  */
1512                 if ((ogm_packet->ttl <= 2) &&
1513                     (if_incoming != if_outgoing)) {
1514                         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1515                                    "Drop packet: OGM from secondary interface and wrong outgoing interface\n");
1516                         goto out_neigh;
1517                 }
1518                 /* mark direct link on incoming interface */
1519                 batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet,
1520                                       is_single_hop_neigh,
1521                                       is_from_best_next_hop, if_incoming,
1522                                       if_outgoing);
1523
1524                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1525                            "Forwarding packet: rebroadcast neighbor packet with direct link flag\n");
1526                 goto out_neigh;
1527         }
1528
1529         /* multihop originator */
1530         if (!is_bidirect) {
1531                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1532                            "Drop packet: not received via bidirectional link\n");
1533                 goto out_neigh;
1534         }
1535
1536         if (dup_status == BATADV_NEIGH_DUP) {
1537                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1538                            "Drop packet: duplicate packet received\n");
1539                 goto out_neigh;
1540         }
1541
1542         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1543                    "Forwarding packet: rebroadcast originator packet\n");
1544         batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet,
1545                               is_single_hop_neigh, is_from_best_next_hop,
1546                               if_incoming, if_outgoing);
1547
1548 out_neigh:
1549         if ((orig_neigh_node) && (!is_single_hop_neigh))
1550                 batadv_orig_node_free_ref(orig_neigh_node);
1551 out:
1552         if (router_ifinfo)
1553                 batadv_neigh_ifinfo_free_ref(router_ifinfo);
1554         if (router)
1555                 batadv_neigh_node_free_ref(router);
1556         if (router_router)
1557                 batadv_neigh_node_free_ref(router_router);
1558         if (orig_neigh_router)
1559                 batadv_neigh_node_free_ref(orig_neigh_router);
1560
1561         kfree_skb(skb_priv);
1562 }
1563
1564 /**
1565  * batadv_iv_ogm_process - process an incoming batman iv OGM
1566  * @skb: the skb containing the OGM
1567  * @ogm_offset: offset to the OGM which should be processed (for aggregates)
1568  * @if_incoming: the interface where this packet was receved
1569  */
1570 static void batadv_iv_ogm_process(const struct sk_buff *skb, int ogm_offset,
1571                                   struct batadv_hard_iface *if_incoming)
1572 {
1573         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1574         struct batadv_orig_node *orig_neigh_node, *orig_node;
1575         struct batadv_hard_iface *hard_iface;
1576         struct batadv_ogm_packet *ogm_packet;
1577         u32 if_incoming_seqno;
1578         bool has_directlink_flag;
1579         struct ethhdr *ethhdr;
1580         bool is_my_oldorig = false;
1581         bool is_my_addr = false;
1582         bool is_my_orig = false;
1583
1584         ogm_packet = (struct batadv_ogm_packet *)(skb->data + ogm_offset);
1585         ethhdr = eth_hdr(skb);
1586
1587         /* Silently drop when the batman packet is actually not a
1588          * correct packet.
1589          *
1590          * This might happen if a packet is padded (e.g. Ethernet has a
1591          * minimum frame length of 64 byte) and the aggregation interprets
1592          * it as an additional length.
1593          *
1594          * TODO: A more sane solution would be to have a bit in the
1595          * batadv_ogm_packet to detect whether the packet is the last
1596          * packet in an aggregation.  Here we expect that the padding
1597          * is always zero (or not 0x01)
1598          */
1599         if (ogm_packet->packet_type != BATADV_IV_OGM)
1600                 return;
1601
1602         /* could be changed by schedule_own_packet() */
1603         if_incoming_seqno = atomic_read(&if_incoming->bat_iv.ogm_seqno);
1604
1605         if (ogm_packet->flags & BATADV_DIRECTLINK)
1606                 has_directlink_flag = true;
1607         else
1608                 has_directlink_flag = false;
1609
1610         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1611                    "Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, tq %d, TTL %d, V %d, IDF %d)\n",
1612                    ethhdr->h_source, if_incoming->net_dev->name,
1613                    if_incoming->net_dev->dev_addr, ogm_packet->orig,
1614                    ogm_packet->prev_sender, ntohl(ogm_packet->seqno),
1615                    ogm_packet->tq, ogm_packet->ttl,
1616                    ogm_packet->version, has_directlink_flag);
1617
1618         rcu_read_lock();
1619         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1620                 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1621                         continue;
1622
1623                 if (hard_iface->soft_iface != if_incoming->soft_iface)
1624                         continue;
1625
1626                 if (batadv_compare_eth(ethhdr->h_source,
1627                                        hard_iface->net_dev->dev_addr))
1628                         is_my_addr = true;
1629
1630                 if (batadv_compare_eth(ogm_packet->orig,
1631                                        hard_iface->net_dev->dev_addr))
1632                         is_my_orig = true;
1633
1634                 if (batadv_compare_eth(ogm_packet->prev_sender,
1635                                        hard_iface->net_dev->dev_addr))
1636                         is_my_oldorig = true;
1637         }
1638         rcu_read_unlock();
1639
1640         if (is_my_addr) {
1641                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1642                            "Drop packet: received my own broadcast (sender: %pM)\n",
1643                            ethhdr->h_source);
1644                 return;
1645         }
1646
1647         if (is_my_orig) {
1648                 unsigned long *word;
1649                 int offset;
1650                 s32 bit_pos;
1651                 s16 if_num;
1652                 u8 *weight;
1653
1654                 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv,
1655                                                          ethhdr->h_source);
1656                 if (!orig_neigh_node)
1657                         return;
1658
1659                 /* neighbor has to indicate direct link and it has to
1660                  * come via the corresponding interface
1661                  * save packet seqno for bidirectional check
1662                  */
1663                 if (has_directlink_flag &&
1664                     batadv_compare_eth(if_incoming->net_dev->dev_addr,
1665                                        ogm_packet->orig)) {
1666                         if_num = if_incoming->if_num;
1667                         offset = if_num * BATADV_NUM_WORDS;
1668
1669                         spin_lock_bh(&orig_neigh_node->bat_iv.ogm_cnt_lock);
1670                         word = &orig_neigh_node->bat_iv.bcast_own[offset];
1671                         bit_pos = if_incoming_seqno - 2;
1672                         bit_pos -= ntohl(ogm_packet->seqno);
1673                         batadv_set_bit(word, bit_pos);
1674                         weight = &orig_neigh_node->bat_iv.bcast_own_sum[if_num];
1675                         *weight = bitmap_weight(word,
1676                                                 BATADV_TQ_LOCAL_WINDOW_SIZE);
1677                         spin_unlock_bh(&orig_neigh_node->bat_iv.ogm_cnt_lock);
1678                 }
1679
1680                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1681                            "Drop packet: originator packet from myself (via neighbor)\n");
1682                 batadv_orig_node_free_ref(orig_neigh_node);
1683                 return;
1684         }
1685
1686         if (is_my_oldorig) {
1687                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1688                            "Drop packet: ignoring all rebroadcast echos (sender: %pM)\n",
1689                            ethhdr->h_source);
1690                 return;
1691         }
1692
1693         if (ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP) {
1694                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1695                            "Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
1696                            ethhdr->h_source);
1697                 return;
1698         }
1699
1700         orig_node = batadv_iv_ogm_orig_get(bat_priv, ogm_packet->orig);
1701         if (!orig_node)
1702                 return;
1703
1704         batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node,
1705                                         if_incoming, BATADV_IF_DEFAULT);
1706
1707         rcu_read_lock();
1708         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1709                 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1710                         continue;
1711
1712                 if (hard_iface->soft_iface != bat_priv->soft_iface)
1713                         continue;
1714
1715                 batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node,
1716                                                 if_incoming, hard_iface);
1717         }
1718         rcu_read_unlock();
1719
1720         batadv_orig_node_free_ref(orig_node);
1721 }
1722
1723 static int batadv_iv_ogm_receive(struct sk_buff *skb,
1724                                  struct batadv_hard_iface *if_incoming)
1725 {
1726         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1727         struct batadv_ogm_packet *ogm_packet;
1728         u8 *packet_pos;
1729         int ogm_offset;
1730         bool ret;
1731
1732         ret = batadv_check_management_packet(skb, if_incoming, BATADV_OGM_HLEN);
1733         if (!ret)
1734                 return NET_RX_DROP;
1735
1736         /* did we receive a B.A.T.M.A.N. IV OGM packet on an interface
1737          * that does not have B.A.T.M.A.N. IV enabled ?
1738          */
1739         if (bat_priv->bat_algo_ops->bat_ogm_emit != batadv_iv_ogm_emit)
1740                 return NET_RX_DROP;
1741
1742         batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_RX);
1743         batadv_add_counter(bat_priv, BATADV_CNT_MGMT_RX_BYTES,
1744                            skb->len + ETH_HLEN);
1745
1746         ogm_offset = 0;
1747         ogm_packet = (struct batadv_ogm_packet *)skb->data;
1748
1749         /* unpack the aggregated packets and process them one by one */
1750         while (batadv_iv_ogm_aggr_packet(ogm_offset, skb_headlen(skb),
1751                                          ogm_packet->tvlv_len)) {
1752                 batadv_iv_ogm_process(skb, ogm_offset, if_incoming);
1753
1754                 ogm_offset += BATADV_OGM_HLEN;
1755                 ogm_offset += ntohs(ogm_packet->tvlv_len);
1756
1757                 packet_pos = skb->data + ogm_offset;
1758                 ogm_packet = (struct batadv_ogm_packet *)packet_pos;
1759         }
1760
1761         kfree_skb(skb);
1762         return NET_RX_SUCCESS;
1763 }
1764
1765 /**
1766  * batadv_iv_ogm_orig_print_neigh - print neighbors for the originator table
1767  * @orig_node: the orig_node for which the neighbors are printed
1768  * @if_outgoing: outgoing interface for these entries
1769  * @seq: debugfs table seq_file struct
1770  *
1771  * Must be called while holding an rcu lock.
1772  */
1773 static void
1774 batadv_iv_ogm_orig_print_neigh(struct batadv_orig_node *orig_node,
1775                                struct batadv_hard_iface *if_outgoing,
1776                                struct seq_file *seq)
1777 {
1778         struct batadv_neigh_node *neigh_node;
1779         struct batadv_neigh_ifinfo *n_ifinfo;
1780
1781         hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1782                 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
1783                 if (!n_ifinfo)
1784                         continue;
1785
1786                 seq_printf(seq, " %pM (%3i)",
1787                            neigh_node->addr,
1788                            n_ifinfo->bat_iv.tq_avg);
1789
1790                 batadv_neigh_ifinfo_free_ref(n_ifinfo);
1791         }
1792 }
1793
1794 /**
1795  * batadv_iv_ogm_orig_print - print the originator table
1796  * @bat_priv: the bat priv with all the soft interface information
1797  * @seq: debugfs table seq_file struct
1798  * @if_outgoing: the outgoing interface for which this should be printed
1799  */
1800 static void batadv_iv_ogm_orig_print(struct batadv_priv *bat_priv,
1801                                      struct seq_file *seq,
1802                                      struct batadv_hard_iface *if_outgoing)
1803 {
1804         struct batadv_neigh_node *neigh_node;
1805         struct batadv_hashtable *hash = bat_priv->orig_hash;
1806         int last_seen_msecs, last_seen_secs;
1807         struct batadv_orig_node *orig_node;
1808         struct batadv_neigh_ifinfo *n_ifinfo;
1809         unsigned long last_seen_jiffies;
1810         struct hlist_head *head;
1811         int batman_count = 0;
1812         u32 i;
1813
1814         seq_printf(seq, "  %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",
1815                    "Originator", "last-seen", "#", BATADV_TQ_MAX_VALUE,
1816                    "Nexthop", "outgoingIF", "Potential nexthops");
1817
1818         for (i = 0; i < hash->size; i++) {
1819                 head = &hash->table[i];
1820
1821                 rcu_read_lock();
1822                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
1823                         neigh_node = batadv_orig_router_get(orig_node,
1824                                                             if_outgoing);
1825                         if (!neigh_node)
1826                                 continue;
1827
1828                         n_ifinfo = batadv_neigh_ifinfo_get(neigh_node,
1829                                                            if_outgoing);
1830                         if (!n_ifinfo)
1831                                 goto next;
1832
1833                         if (n_ifinfo->bat_iv.tq_avg == 0)
1834                                 goto next;
1835
1836                         last_seen_jiffies = jiffies - orig_node->last_seen;
1837                         last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
1838                         last_seen_secs = last_seen_msecs / 1000;
1839                         last_seen_msecs = last_seen_msecs % 1000;
1840
1841                         seq_printf(seq, "%pM %4i.%03is   (%3i) %pM [%10s]:",
1842                                    orig_node->orig, last_seen_secs,
1843                                    last_seen_msecs, n_ifinfo->bat_iv.tq_avg,
1844                                    neigh_node->addr,
1845                                    neigh_node->if_incoming->net_dev->name);
1846
1847                         batadv_iv_ogm_orig_print_neigh(orig_node, if_outgoing,
1848                                                        seq);
1849                         seq_puts(seq, "\n");
1850                         batman_count++;
1851
1852 next:
1853                         batadv_neigh_node_free_ref(neigh_node);
1854                         if (n_ifinfo)
1855                                 batadv_neigh_ifinfo_free_ref(n_ifinfo);
1856                 }
1857                 rcu_read_unlock();
1858         }
1859
1860         if (batman_count == 0)
1861                 seq_puts(seq, "No batman nodes in range ...\n");
1862 }
1863
1864 /**
1865  * batadv_iv_ogm_neigh_cmp - compare the metrics of two neighbors
1866  * @neigh1: the first neighbor object of the comparison
1867  * @if_outgoing1: outgoing interface for the first neighbor
1868  * @neigh2: the second neighbor object of the comparison
1869  * @if_outgoing2: outgoing interface for the second neighbor
1870  *
1871  * Returns a value less, equal to or greater than 0 if the metric via neigh1 is
1872  * lower, the same as or higher than the metric via neigh2
1873  */
1874 static int batadv_iv_ogm_neigh_cmp(struct batadv_neigh_node *neigh1,
1875                                    struct batadv_hard_iface *if_outgoing1,
1876                                    struct batadv_neigh_node *neigh2,
1877                                    struct batadv_hard_iface *if_outgoing2)
1878 {
1879         struct batadv_neigh_ifinfo *neigh1_ifinfo, *neigh2_ifinfo;
1880         u8 tq1, tq2;
1881         int diff;
1882
1883         neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
1884         neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
1885
1886         if (!neigh1_ifinfo || !neigh2_ifinfo) {
1887                 diff = 0;
1888                 goto out;
1889         }
1890
1891         tq1 = neigh1_ifinfo->bat_iv.tq_avg;
1892         tq2 = neigh2_ifinfo->bat_iv.tq_avg;
1893         diff = tq1 - tq2;
1894
1895 out:
1896         if (neigh1_ifinfo)
1897                 batadv_neigh_ifinfo_free_ref(neigh1_ifinfo);
1898         if (neigh2_ifinfo)
1899                 batadv_neigh_ifinfo_free_ref(neigh2_ifinfo);
1900
1901         return diff;
1902 }
1903
1904 /**
1905  * batadv_iv_ogm_neigh_is_eob - check if neigh1 is equally good or better than
1906  *  neigh2 from the metric prospective
1907  * @neigh1: the first neighbor object of the comparison
1908  * @if_outgoing1: outgoing interface for the first neighbor
1909  * @neigh2: the second neighbor object of the comparison
1910  * @if_outgoing2: outgoing interface for the second neighbor
1911  *
1912  * Returns true if the metric via neigh1 is equally good or better than
1913  * the metric via neigh2, false otherwise.
1914  */
1915 static bool
1916 batadv_iv_ogm_neigh_is_eob(struct batadv_neigh_node *neigh1,
1917                            struct batadv_hard_iface *if_outgoing1,
1918                            struct batadv_neigh_node *neigh2,
1919                            struct batadv_hard_iface *if_outgoing2)
1920 {
1921         struct batadv_neigh_ifinfo *neigh1_ifinfo, *neigh2_ifinfo;
1922         u8 tq1, tq2;
1923         bool ret;
1924
1925         neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
1926         neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
1927
1928         /* we can't say that the metric is better */
1929         if (!neigh1_ifinfo || !neigh2_ifinfo) {
1930                 ret = false;
1931                 goto out;
1932         }
1933
1934         tq1 = neigh1_ifinfo->bat_iv.tq_avg;
1935         tq2 = neigh2_ifinfo->bat_iv.tq_avg;
1936         ret = (tq1 - tq2) > -BATADV_TQ_SIMILARITY_THRESHOLD;
1937
1938 out:
1939         if (neigh1_ifinfo)
1940                 batadv_neigh_ifinfo_free_ref(neigh1_ifinfo);
1941         if (neigh2_ifinfo)
1942                 batadv_neigh_ifinfo_free_ref(neigh2_ifinfo);
1943
1944         return ret;
1945 }
1946
1947 static struct batadv_algo_ops batadv_batman_iv __read_mostly = {
1948         .name = "BATMAN_IV",
1949         .bat_iface_enable = batadv_iv_ogm_iface_enable,
1950         .bat_iface_disable = batadv_iv_ogm_iface_disable,
1951         .bat_iface_update_mac = batadv_iv_ogm_iface_update_mac,
1952         .bat_primary_iface_set = batadv_iv_ogm_primary_iface_set,
1953         .bat_ogm_schedule = batadv_iv_ogm_schedule,
1954         .bat_ogm_emit = batadv_iv_ogm_emit,
1955         .bat_neigh_cmp = batadv_iv_ogm_neigh_cmp,
1956         .bat_neigh_is_equiv_or_better = batadv_iv_ogm_neigh_is_eob,
1957         .bat_orig_print = batadv_iv_ogm_orig_print,
1958         .bat_orig_free = batadv_iv_ogm_orig_free,
1959         .bat_orig_add_if = batadv_iv_ogm_orig_add_if,
1960         .bat_orig_del_if = batadv_iv_ogm_orig_del_if,
1961 };
1962
1963 int __init batadv_iv_init(void)
1964 {
1965         int ret;
1966
1967         /* batman originator packet */
1968         ret = batadv_recv_handler_register(BATADV_IV_OGM,
1969                                            batadv_iv_ogm_receive);
1970         if (ret < 0)
1971                 goto out;
1972
1973         ret = batadv_algo_register(&batadv_batman_iv);
1974         if (ret < 0)
1975                 goto handler_unregister;
1976
1977         goto out;
1978
1979 handler_unregister:
1980         batadv_recv_handler_unregister(BATADV_IV_OGM);
1981 out:
1982         return ret;
1983 }