net/batman-adv/bat_iv_ogm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2007-2019  B.A.T.M.A.N. contributors:
   3  *
   4  * Marek Lindner, Simon Wunderlich
   5  */
   6
   7 #include "bat_iv_ogm.h"
   8 #include "main.h"
   9
  10 #include <linux/atomic.h>
  11 #include <linux/bitmap.h>
  12 #include <linux/bitops.h>
  13 #include <linux/bug.h>
  14 #include <linux/byteorder/generic.h>
  15 #include <linux/cache.h>
  16 #include <linux/errno.h>
  17 #include <linux/etherdevice.h>
  18 #include <linux/gfp.h>
  19 #include <linux/if_ether.h>
  20 #include <linux/init.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/kernel.h>
  23 #include <linux/kref.h>
  24 #include <linux/list.h>
  25 #include <linux/netdevice.h>
  26 #include <linux/netlink.h>
  27 #include <linux/pkt_sched.h>
  28 #include <linux/printk.h>
  29 #include <linux/random.h>
  30 #include <linux/rculist.h>
  31 #include <linux/rcupdate.h>
  32 #include <linux/seq_file.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/types.h>
  39 #include <linux/workqueue.h>
  40 #include <net/genetlink.h>
  41 #include <net/netlink.h>
  42 #include <uapi/linux/batadv_packet.h>
  43 #include <uapi/linux/batman_adv.h>
  44
  45 #include "bat_algo.h"
  46 #include "bitarray.h"
  47 #include "gateway_client.h"
  48 #include "hard-interface.h"
  49 #include "hash.h"
  50 #include "log.h"
  51 #include "netlink.h"
  52 #include "network-coding.h"
  53 #include "originator.h"
  54 #include "routing.h"
  55 #include "send.h"
  56 #include "translation-table.h"
  57 #include "tvlv.h"
  58
  59 static void batadv_iv_send_outstanding_bat_ogm_packet(struct work_struct *work);
  60
  61 /**
  62  * enum batadv_dup_status - duplicate status
  63  */
  64 enum batadv_dup_status {
  65         /** @BATADV_NO_DUP: the packet is no duplicate */
  66         BATADV_NO_DUP = 0,
  67
  68         /**
  69          * @BATADV_ORIG_DUP: OGM is a duplicate in the originator (but not for
  70          *  the neighbor)
  71          */
  72         BATADV_ORIG_DUP,
  73
  74         /** @BATADV_NEIGH_DUP: OGM is a duplicate for the neighbor */
  75         BATADV_NEIGH_DUP,
  76
  77         /**
  78          * @BATADV_PROTECTED: originator is currently protected (after reboot)
  79          */
  80         BATADV_PROTECTED,
  81 };
  82
  83 /**
  84  * batadv_ring_buffer_set() - update the ring buffer with the given value
  85  * @lq_recv: pointer to the ring buffer
  86  * @lq_index: index to store the value at
  87  * @value: value to store in the ring buffer
  88  */
  89 static void batadv_ring_buffer_set(u8 lq_recv[], u8 *lq_index, u8 value)
  90 {
  91         lq_recv[*lq_index] = value;
  92         *lq_index = (*lq_index + 1) % BATADV_TQ_GLOBAL_WINDOW_SIZE;
  93 }
  94
  95 /**
  96  * batadv_ring_buffer_avg() - compute the average of all non-zero values stored
  97  * in the given ring buffer
  98  * @lq_recv: pointer to the ring buffer
  99  *
 100  * Return: computed average value.
 101  */
 102 static u8 batadv_ring_buffer_avg(const u8 lq_recv[])
 103 {
 104         const u8 *ptr;
 105         u16 count = 0;
 106         u16 i = 0;
 107         u16 sum = 0;
 108
 109         ptr = lq_recv;
 110
 111         while (i < BATADV_TQ_GLOBAL_WINDOW_SIZE) {
 112                 if (*ptr != 0) {
 113                         count++;
 114                         sum += *ptr;
 115                 }
 116
 117                 i++;
 118                 ptr++;
 119         }
 120
 121         if (count == 0)
 122                 return 0;
 123
 124         return (u8)(sum / count);
 125 }
 126
 127 /**
 128  * batadv_iv_ogm_orig_get() - retrieve or create (if does not exist) an
 129  *  originator
 130  * @bat_priv: the bat priv with all the soft interface information
 131  * @addr: mac address of the originator
 132  *
 133  * Return: the originator object corresponding to the passed mac address or NULL
 134  * on failure.
 135  * If the object does not exists it is created an initialised.
 136  */
 137 static struct batadv_orig_node *
 138 batadv_iv_ogm_orig_get(struct batadv_priv *bat_priv, const u8 *addr)
 139 {
 140         struct batadv_orig_node *orig_node;
 141         int hash_added;
 142
 143         orig_node = batadv_orig_hash_find(bat_priv, addr);
 144         if (orig_node)
 145                 return orig_node;
 146
 147         orig_node = batadv_orig_node_new(bat_priv, addr);
 148         if (!orig_node)
 149                 return NULL;
 150
 151         spin_lock_init(&orig_node->bat_iv.ogm_cnt_lock);
 152
 153         kref_get(&orig_node->refcount);
 154         hash_added = batadv_hash_add(bat_priv->orig_hash, batadv_compare_orig,
 155                                      batadv_choose_orig, orig_node,
 156                                      &orig_node->hash_entry);
 157         if (hash_added != 0)
 158                 goto free_orig_node_hash;
 159
 160         return orig_node;
 161
 162 free_orig_node_hash:
 163         /* reference for batadv_hash_add */
 164         batadv_orig_node_put(orig_node);
 165         /* reference from batadv_orig_node_new */
 166         batadv_orig_node_put(orig_node);
 167
 168         return NULL;
 169 }
 170
 171 static struct batadv_neigh_node *
 172 batadv_iv_ogm_neigh_new(struct batadv_hard_iface *hard_iface,
 173                         const u8 *neigh_addr,
 174                         struct batadv_orig_node *orig_node,
 175                         struct batadv_orig_node *orig_neigh)
 176 {
 177         struct batadv_neigh_node *neigh_node;
 178
 179         neigh_node = batadv_neigh_node_get_or_create(orig_node,
 180                                                      hard_iface, neigh_addr);
 181         if (!neigh_node)
 182                 goto out;
 183
 184         neigh_node->orig_node = orig_neigh;
 185
 186 out:
 187         return neigh_node;
 188 }
 189
 190 static int batadv_iv_ogm_iface_enable(struct batadv_hard_iface *hard_iface)
 191 {
 192         struct batadv_ogm_packet *batadv_ogm_packet;
 193         unsigned char *ogm_buff;
 194         u32 random_seqno;
 195
 196         /* randomize initial seqno to avoid collision */
 197         get_random_bytes(&random_seqno, sizeof(random_seqno));
 198         atomic_set(&hard_iface->bat_iv.ogm_seqno, random_seqno);
 199
 200         hard_iface->bat_iv.ogm_buff_len = BATADV_OGM_HLEN;
 201         ogm_buff = kmalloc(hard_iface->bat_iv.ogm_buff_len, GFP_ATOMIC);
 202         if (!ogm_buff)
 203                 return -ENOMEM;
 204
 205         hard_iface->bat_iv.ogm_buff = ogm_buff;
 206
 207         batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
 208         batadv_ogm_packet->packet_type = BATADV_IV_OGM;
 209         batadv_ogm_packet->version = BATADV_COMPAT_VERSION;
 210         batadv_ogm_packet->ttl = 2;
 211         batadv_ogm_packet->flags = BATADV_NO_FLAGS;
 212         batadv_ogm_packet->reserved = 0;
 213         batadv_ogm_packet->tq = BATADV_TQ_MAX_VALUE;
 214
 215         return 0;
 216 }
 217
 218 static void batadv_iv_ogm_iface_disable(struct batadv_hard_iface *hard_iface)
 219 {
 220         kfree(hard_iface->bat_iv.ogm_buff);
 221         hard_iface->bat_iv.ogm_buff = NULL;
 222 }
 223
 224 static void batadv_iv_ogm_iface_update_mac(struct batadv_hard_iface *hard_iface)
 225 {
 226         struct batadv_ogm_packet *batadv_ogm_packet;
 227         unsigned char *ogm_buff = hard_iface->bat_iv.ogm_buff;
 228
 229         batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
 230         ether_addr_copy(batadv_ogm_packet->orig,
 231                         hard_iface->net_dev->dev_addr);
 232         ether_addr_copy(batadv_ogm_packet->prev_sender,
 233                         hard_iface->net_dev->dev_addr);
 234 }
 235
 236 static void
 237 batadv_iv_ogm_primary_iface_set(struct batadv_hard_iface *hard_iface)
 238 {
 239         struct batadv_ogm_packet *batadv_ogm_packet;
 240         unsigned char *ogm_buff = hard_iface->bat_iv.ogm_buff;
 241
 242         batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
 243         batadv_ogm_packet->ttl = BATADV_TTL;
 244 }
 245
 246 /* when do we schedule our own ogm to be sent */
 247 static unsigned long
 248 batadv_iv_ogm_emit_send_time(const struct batadv_priv *bat_priv)
 249 {
 250         unsigned int msecs;
 251
 252         msecs = atomic_read(&bat_priv->orig_interval) - BATADV_JITTER;
 253         msecs += prandom_u32() % (2 * BATADV_JITTER);
 254
 255         return jiffies + msecs_to_jiffies(msecs);
 256 }
 257
 258 /* when do we schedule a ogm packet to be sent */
 259 static unsigned long batadv_iv_ogm_fwd_send_time(void)
 260 {
 261         return jiffies + msecs_to_jiffies(prandom_u32() % (BATADV_JITTER / 2));
 262 }
 263
 264 /* apply hop penalty for a normal link */
 265 static u8 batadv_hop_penalty(u8 tq, const struct batadv_priv *bat_priv)
 266 {
 267         int hop_penalty = atomic_read(&bat_priv->hop_penalty);
 268         int new_tq;
 269
 270         new_tq = tq * (BATADV_TQ_MAX_VALUE - hop_penalty);
 271         new_tq /= BATADV_TQ_MAX_VALUE;
 272
 273         return new_tq;
 274 }
 275
 276 /**
 277  * batadv_iv_ogm_aggr_packet() - checks if there is another OGM attached
 278  * @buff_pos: current position in the skb
 279  * @packet_len: total length of the skb
 280  * @tvlv_len: tvlv length of the previously considered OGM
 281  *
 282  * Return: true if there is enough space for another OGM, false otherwise.
 283  */
 284 static bool batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len,
 285                                       __be16 tvlv_len)
 286 {
 287         int next_buff_pos = 0;
 288
 289         next_buff_pos += buff_pos + BATADV_OGM_HLEN;
 290         next_buff_pos += ntohs(tvlv_len);
 291
 292         return (next_buff_pos <= packet_len) &&
 293                (next_buff_pos <= BATADV_MAX_AGGREGATION_BYTES);
 294 }
 295
 296 /* send a batman ogm to a given interface */
 297 static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet,
 298                                      struct batadv_hard_iface *hard_iface)
 299 {
 300         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 301         const char *fwd_str;
 302         u8 packet_num;
 303         s16 buff_pos;
 304         struct batadv_ogm_packet *batadv_ogm_packet;
 305         struct sk_buff *skb;
 306         u8 *packet_pos;
 307
 308         if (hard_iface->if_status != BATADV_IF_ACTIVE)
 309                 return;
 310
 311         packet_num = 0;
 312         buff_pos = 0;
 313         packet_pos = forw_packet->skb->data;
 314         batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
 315
 316         /* adjust all flags and log packets */
 317         while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
 318                                          batadv_ogm_packet->tvlv_len)) {
 319                 /* we might have aggregated direct link packets with an
 320                  * ordinary base packet
 321                  */
 322                 if (forw_packet->direct_link_flags & BIT(packet_num) &&
 323                     forw_packet->if_incoming == hard_iface)
 324                         batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
 325                 else
 326                         batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
 327
 328                 if (packet_num > 0 || !forw_packet->own)
 329                         fwd_str = "Forwarding";
 330                 else
 331                         fwd_str = "Sending own";
 332
 333                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 334                            "%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s) on interface %s [%pM]\n",
 335                            fwd_str, (packet_num > 0 ? "aggregated " : ""),
 336                            batadv_ogm_packet->orig,
 337                            ntohl(batadv_ogm_packet->seqno),
 338                            batadv_ogm_packet->tq, batadv_ogm_packet->ttl,
 339                            ((batadv_ogm_packet->flags & BATADV_DIRECTLINK) ?
 340                             "on" : "off"),
 341                            hard_iface->net_dev->name,
 342                            hard_iface->net_dev->dev_addr);
 343
 344                 buff_pos += BATADV_OGM_HLEN;
 345                 buff_pos += ntohs(batadv_ogm_packet->tvlv_len);
 346                 packet_num++;
 347                 packet_pos = forw_packet->skb->data + buff_pos;
 348                 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
 349         }
 350
 351         /* create clone because function is called more than once */
 352         skb = skb_clone(forw_packet->skb, GFP_ATOMIC);
 353         if (skb) {
 354                 batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_TX);
 355                 batadv_add_counter(bat_priv, BATADV_CNT_MGMT_TX_BYTES,
 356                                    skb->len + ETH_HLEN);
 357                 batadv_send_broadcast_skb(skb, hard_iface);
 358         }
 359 }
 360
 361 /* send a batman ogm packet */
 362 static void batadv_iv_ogm_emit(struct batadv_forw_packet *forw_packet)
 363 {
 364         struct net_device *soft_iface;
 365
 366         if (!forw_packet->if_incoming) {
 367                 pr_err("Error - can't forward packet: incoming iface not specified\n");
 368                 return;
 369         }
 370
 371         soft_iface = forw_packet->if_incoming->soft_iface;
 372
 373         if (WARN_ON(!forw_packet->if_outgoing))
 374                 return;
 375
 376         if (WARN_ON(forw_packet->if_outgoing->soft_iface != soft_iface))
 377                 return;
 378
 379         if (forw_packet->if_incoming->if_status != BATADV_IF_ACTIVE)
 380                 return;
 381
 382         /* only for one specific outgoing interface */
 383         batadv_iv_ogm_send_to_if(forw_packet, forw_packet->if_outgoing);
 384 }
 385
 386 /**
 387  * batadv_iv_ogm_can_aggregate() - find out if an OGM can be aggregated on an
 388  *  existing forward packet
 389  * @new_bat_ogm_packet: OGM packet to be aggregated
 390  * @bat_priv: the bat priv with all the soft interface information
 391  * @packet_len: (total) length of the OGM
 392  * @send_time: timestamp (jiffies) when the packet is to be sent
 393  * @directlink: true if this is a direct link packet
 394  * @if_incoming: interface where the packet was received
 395  * @if_outgoing: interface for which the retransmission should be considered
 396  * @forw_packet: the forwarded packet which should be checked
 397  *
 398  * Return: true if new_packet can be aggregated with forw_packet
 399  */
 400 static bool
 401 batadv_iv_ogm_can_aggregate(const struct batadv_ogm_packet *new_bat_ogm_packet,
 402                             struct batadv_priv *bat_priv,
 403                             int packet_len, unsigned long send_time,
 404                             bool directlink,
 405                             const struct batadv_hard_iface *if_incoming,
 406                             const struct batadv_hard_iface *if_outgoing,
 407                             const struct batadv_forw_packet *forw_packet)
 408 {
 409         struct batadv_ogm_packet *batadv_ogm_packet;
 410         int aggregated_bytes = forw_packet->packet_len + packet_len;
 411         struct batadv_hard_iface *primary_if = NULL;
 412         bool res = false;
 413         unsigned long aggregation_end_time;
 414
 415         batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data;
 416         aggregation_end_time = send_time;
 417         aggregation_end_time += msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
 418
 419         /* we can aggregate the current packet to this aggregated packet
 420          * if:
 421          *
 422          * - the send time is within our MAX_AGGREGATION_MS time
 423          * - the resulting packet wont be bigger than
 424          *   MAX_AGGREGATION_BYTES
 425          * otherwise aggregation is not possible
 426          */
 427         if (!time_before(send_time, forw_packet->send_time) ||
 428             !time_after_eq(aggregation_end_time, forw_packet->send_time))
 429                 return false;
 430
 431         if (aggregated_bytes > BATADV_MAX_AGGREGATION_BYTES)
 432                 return false;
 433
 434         /* packet is not leaving on the same interface. */
 435         if (forw_packet->if_outgoing != if_outgoing)
 436                 return false;
 437
 438         /* check aggregation compatibility
 439          * -> direct link packets are broadcasted on
 440          *    their interface only
 441          * -> aggregate packet if the current packet is
 442          *    a "global" packet as well as the base
 443          *    packet
 444          */
 445         primary_if = batadv_primary_if_get_selected(bat_priv);
 446         if (!primary_if)
 447                 return false;
 448
 449         /* packets without direct link flag and high TTL
 450          * are flooded through the net
 451          */
 452         if (!directlink &&
 453             !(batadv_ogm_packet->flags & BATADV_DIRECTLINK) &&
 454             batadv_ogm_packet->ttl != 1 &&
 455
 456             /* own packets originating non-primary
 457              * interfaces leave only that interface
 458              */
 459             (!forw_packet->own ||
 460              forw_packet->if_incoming == primary_if)) {
 461                 res = true;
 462                 goto out;
 463         }
 464
 465         /* if the incoming packet is sent via this one
 466          * interface only - we still can aggregate
 467          */
 468         if (directlink &&
 469             new_bat_ogm_packet->ttl == 1 &&
 470             forw_packet->if_incoming == if_incoming &&
 471
 472             /* packets from direct neighbors or
 473              * own secondary interface packets
 474              * (= secondary interface packets in general)
 475              */
 476             (batadv_ogm_packet->flags & BATADV_DIRECTLINK ||
 477              (forw_packet->own &&
 478               forw_packet->if_incoming != primary_if))) {
 479                 res = true;
 480                 goto out;
 481         }
 482
 483 out:
 484         if (primary_if)
 485                 batadv_hardif_put(primary_if);
 486         return res;
 487 }
 488
 489 /**
 490  * batadv_iv_ogm_aggregate_new() - create a new aggregated packet and add this
 491  *  packet to it.
 492  * @packet_buff: pointer to the OGM
 493  * @packet_len: (total) length of the OGM
 494  * @send_time: timestamp (jiffies) when the packet is to be sent
 495  * @direct_link: whether this OGM has direct link status
 496  * @if_incoming: interface where the packet was received
 497  * @if_outgoing: interface for which the retransmission should be considered
 498  * @own_packet: true if it is a self-generated ogm
 499  */
 500 static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
 501                                         int packet_len, unsigned long send_time,
 502                                         bool direct_link,
 503                                         struct batadv_hard_iface *if_incoming,
 504                                         struct batadv_hard_iface *if_outgoing,
 505                                         int own_packet)
 506 {
 507         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 508         struct batadv_forw_packet *forw_packet_aggr;
 509         struct sk_buff *skb;
 510         unsigned char *skb_buff;
 511         unsigned int skb_size;
 512         atomic_t *queue_left = own_packet ? NULL : &bat_priv->batman_queue_left;
 513
 514         if (atomic_read(&bat_priv->aggregated_ogms) &&
 515             packet_len < BATADV_MAX_AGGREGATION_BYTES)
 516                 skb_size = BATADV_MAX_AGGREGATION_BYTES;
 517         else
 518                 skb_size = packet_len;
 519
 520         skb_size += ETH_HLEN;
 521
 522         skb = netdev_alloc_skb_ip_align(NULL, skb_size);
 523         if (!skb)
 524                 return;
 525
 526         forw_packet_aggr = batadv_forw_packet_alloc(if_incoming, if_outgoing,
 527                                                     queue_left, bat_priv, skb);
 528         if (!forw_packet_aggr) {
 529                 kfree_skb(skb);
 530                 return;
 531         }
 532
 533         forw_packet_aggr->skb->priority = TC_PRIO_CONTROL;
 534         skb_reserve(forw_packet_aggr->skb, ETH_HLEN);
 535
 536         skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
 537         forw_packet_aggr->packet_len = packet_len;
 538         memcpy(skb_buff, packet_buff, packet_len);
 539
 540         forw_packet_aggr->own = own_packet;
 541         forw_packet_aggr->direct_link_flags = BATADV_NO_FLAGS;
 542         forw_packet_aggr->send_time = send_time;
 543
 544         /* save packet direct link flag status */
 545         if (direct_link)
 546                 forw_packet_aggr->direct_link_flags |= 1;
 547
 548         INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work,
 549                           batadv_iv_send_outstanding_bat_ogm_packet);
 550
 551         batadv_forw_packet_ogmv1_queue(bat_priv, forw_packet_aggr, send_time);
 552 }
 553
 554 /* aggregate a new packet into the existing ogm packet */
 555 static void batadv_iv_ogm_aggregate(struct batadv_forw_packet *forw_packet_aggr,
 556                                     const unsigned char *packet_buff,
 557                                     int packet_len, bool direct_link)
 558 {
 559         unsigned long new_direct_link_flag;
 560
 561         skb_put_data(forw_packet_aggr->skb, packet_buff, packet_len);
 562         forw_packet_aggr->packet_len += packet_len;
 563         forw_packet_aggr->num_packets++;
 564
 565         /* save packet direct link flag status */
 566         if (direct_link) {
 567                 new_direct_link_flag = BIT(forw_packet_aggr->num_packets);
 568                 forw_packet_aggr->direct_link_flags |= new_direct_link_flag;
 569         }
 570 }
 571
 572 /**
 573  * batadv_iv_ogm_queue_add() - queue up an OGM for transmission
 574  * @bat_priv: the bat priv with all the soft interface information
 575  * @packet_buff: pointer to the OGM
 576  * @packet_len: (total) length of the OGM
 577  * @if_incoming: interface where the packet was received
 578  * @if_outgoing: interface for which the retransmission should be considered
 579  * @own_packet: true if it is a self-generated ogm
 580  * @send_time: timestamp (jiffies) when the packet is to be sent
 581  */
 582 static void batadv_iv_ogm_queue_add(struct batadv_priv *bat_priv,
 583                                     unsigned char *packet_buff,
 584                                     int packet_len,
 585                                     struct batadv_hard_iface *if_incoming,
 586                                     struct batadv_hard_iface *if_outgoing,
 587                                     int own_packet, unsigned long send_time)
 588 {
 589         /* _aggr -> pointer to the packet we want to aggregate with
 590          * _pos -> pointer to the position in the queue
 591          */
 592         struct batadv_forw_packet *forw_packet_aggr = NULL;
 593         struct batadv_forw_packet *forw_packet_pos = NULL;
 594         struct batadv_ogm_packet *batadv_ogm_packet;
 595         bool direct_link;
 596         unsigned long max_aggregation_jiffies;
 597
 598         batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff;
 599         direct_link = !!(batadv_ogm_packet->flags & BATADV_DIRECTLINK);
 600         max_aggregation_jiffies = msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
 601
 602         /* find position for the packet in the forward queue */
 603         spin_lock_bh(&bat_priv->forw_bat_list_lock);
 604         /* own packets are not to be aggregated */
 605         if (atomic_read(&bat_priv->aggregated_ogms) && !own_packet) {
 606                 hlist_for_each_entry(forw_packet_pos,
 607                                      &bat_priv->forw_bat_list, list) {
 608                         if (batadv_iv_ogm_can_aggregate(batadv_ogm_packet,
 609                                                         bat_priv, packet_len,
 610                                                         send_time, direct_link,
 611                                                         if_incoming,
 612                                                         if_outgoing,
 613                                                         forw_packet_pos)) {
 614                                 forw_packet_aggr = forw_packet_pos;
 615                                 break;
 616                         }
 617                 }
 618         }
 619
 620         /* nothing to aggregate with - either aggregation disabled or no
 621          * suitable aggregation packet found
 622          */
 623         if (!forw_packet_aggr) {
 624                 /* the following section can run without the lock */
 625                 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 626
 627                 /* if we could not aggregate this packet with one of the others
 628                  * we hold it back for a while, so that it might be aggregated
 629                  * later on
 630                  */
 631                 if (!own_packet && atomic_read(&bat_priv->aggregated_ogms))
 632                         send_time += max_aggregation_jiffies;
 633
 634                 batadv_iv_ogm_aggregate_new(packet_buff, packet_len,
 635                                             send_time, direct_link,
 636                                             if_incoming, if_outgoing,
 637                                             own_packet);
 638         } else {
 639                 batadv_iv_ogm_aggregate(forw_packet_aggr, packet_buff,
 640                                         packet_len, direct_link);
 641                 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
 642         }
 643 }
 644
 645 static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node,
 646                                   const struct ethhdr *ethhdr,
 647                                   struct batadv_ogm_packet *batadv_ogm_packet,
 648                                   bool is_single_hop_neigh,
 649                                   bool is_from_best_next_hop,
 650                                   struct batadv_hard_iface *if_incoming,
 651                                   struct batadv_hard_iface *if_outgoing)
 652 {
 653         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
 654         u16 tvlv_len;
 655
 656         if (batadv_ogm_packet->ttl <= 1) {
 657                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "ttl exceeded\n");
 658                 return;
 659         }
 660
 661         if (!is_from_best_next_hop) {
 662                 /* Mark the forwarded packet when it is not coming from our
 663                  * best next hop. We still need to forward the packet for our
 664                  * neighbor link quality detection to work in case the packet
 665                  * originated from a single hop neighbor. Otherwise we can
 666                  * simply drop the ogm.
 667                  */
 668                 if (is_single_hop_neigh)
 669                         batadv_ogm_packet->flags |= BATADV_NOT_BEST_NEXT_HOP;
 670                 else
 671                         return;
 672         }
 673
 674         tvlv_len = ntohs(batadv_ogm_packet->tvlv_len);
 675
 676         batadv_ogm_packet->ttl--;
 677         ether_addr_copy(batadv_ogm_packet->prev_sender, ethhdr->h_source);
 678
 679         /* apply hop penalty */
 680         batadv_ogm_packet->tq = batadv_hop_penalty(batadv_ogm_packet->tq,
 681                                                    bat_priv);
 682
 683         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 684                    "Forwarding packet: tq: %i, ttl: %i\n",
 685                    batadv_ogm_packet->tq, batadv_ogm_packet->ttl);
 686
 687         if (is_single_hop_neigh)
 688                 batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
 689         else
 690                 batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
 691
 692         batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batadv_ogm_packet,
 693                                 BATADV_OGM_HLEN + tvlv_len,
 694                                 if_incoming, if_outgoing, 0,
 695                                 batadv_iv_ogm_fwd_send_time());
 696 }
 697
 698 /**
 699  * batadv_iv_ogm_slide_own_bcast_window() - bitshift own OGM broadcast windows
 700  *  for the given interface
 701  * @hard_iface: the interface for which the windows have to be shifted
 702  */
 703 static void
 704 batadv_iv_ogm_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)
 705 {
 706         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 707         struct batadv_hashtable *hash = bat_priv->orig_hash;
 708         struct hlist_head *head;
 709         struct batadv_orig_node *orig_node;
 710         struct batadv_orig_ifinfo *orig_ifinfo;
 711         unsigned long *word;
 712         u32 i;
 713         u8 *w;
 714
 715         for (i = 0; i < hash->size; i++) {
 716                 head = &hash->table[i];
 717
 718                 rcu_read_lock();
 719                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
 720                         hlist_for_each_entry_rcu(orig_ifinfo,
 721                                                  &orig_node->ifinfo_list,
 722                                                  list) {
 723                                 if (orig_ifinfo->if_outgoing != hard_iface)
 724                                         continue;
 725
 726                                 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 727                                 word = orig_ifinfo->bat_iv.bcast_own;
 728                                 batadv_bit_get_packet(bat_priv, word, 1, 0);
 729                                 w = &orig_ifinfo->bat_iv.bcast_own_sum;
 730                                 *w = bitmap_weight(word,
 731                                                    BATADV_TQ_LOCAL_WINDOW_SIZE);
 732                                 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 733                         }
 734                 }
 735                 rcu_read_unlock();
 736         }
 737 }
 738
 739 static void batadv_iv_ogm_schedule(struct batadv_hard_iface *hard_iface)
 740 {
 741         struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
 742         unsigned char **ogm_buff = &hard_iface->bat_iv.ogm_buff;
 743         struct batadv_ogm_packet *batadv_ogm_packet;
 744         struct batadv_hard_iface *primary_if, *tmp_hard_iface;
 745         int *ogm_buff_len = &hard_iface->bat_iv.ogm_buff_len;
 746         u32 seqno;
 747         u16 tvlv_len = 0;
 748         unsigned long send_time;
 749
 750         if (hard_iface->if_status == BATADV_IF_NOT_IN_USE ||
 751             hard_iface->if_status == BATADV_IF_TO_BE_REMOVED)
 752                 return;
 753
 754         /* the interface gets activated here to avoid race conditions between
 755          * the moment of activating the interface in
 756          * hardif_activate_interface() where the originator mac is set and
 757          * outdated packets (especially uninitialized mac addresses) in the
 758          * packet queue
 759          */
 760         if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED)
 761                 hard_iface->if_status = BATADV_IF_ACTIVE;
 762
 763         primary_if = batadv_primary_if_get_selected(bat_priv);
 764
 765         if (hard_iface == primary_if) {
 766                 /* tt changes have to be committed before the tvlv data is
 767                  * appended as it may alter the tt tvlv container
 768                  */
 769                 batadv_tt_local_commit_changes(bat_priv);
 770                 tvlv_len = batadv_tvlv_container_ogm_append(bat_priv, ogm_buff,
 771                                                             ogm_buff_len,
 772                                                             BATADV_OGM_HLEN);
 773         }
 774
 775         batadv_ogm_packet = (struct batadv_ogm_packet *)(*ogm_buff);
 776         batadv_ogm_packet->tvlv_len = htons(tvlv_len);
 777
 778         /* change sequence number to network order */
 779         seqno = (u32)atomic_read(&hard_iface->bat_iv.ogm_seqno);
 780         batadv_ogm_packet->seqno = htonl(seqno);
 781         atomic_inc(&hard_iface->bat_iv.ogm_seqno);
 782
 783         batadv_iv_ogm_slide_own_bcast_window(hard_iface);
 784
 785         send_time = batadv_iv_ogm_emit_send_time(bat_priv);
 786
 787         if (hard_iface != primary_if) {
 788                 /* OGMs from secondary interfaces are only scheduled on their
 789                  * respective interfaces.
 790                  */
 791                 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff, *ogm_buff_len,
 792                                         hard_iface, hard_iface, 1, send_time);
 793                 goto out;
 794         }
 795
 796         /* OGMs from primary interfaces are scheduled on all
 797          * interfaces.
 798          */
 799         rcu_read_lock();
 800         list_for_each_entry_rcu(tmp_hard_iface, &batadv_hardif_list, list) {
 801                 if (tmp_hard_iface->soft_iface != hard_iface->soft_iface)
 802                         continue;
 803
 804                 if (!kref_get_unless_zero(&tmp_hard_iface->refcount))
 805                         continue;
 806
 807                 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff,
 808                                         *ogm_buff_len, hard_iface,
 809                                         tmp_hard_iface, 1, send_time);
 810
 811                 batadv_hardif_put(tmp_hard_iface);
 812         }
 813         rcu_read_unlock();
 814
 815 out:
 816         if (primary_if)
 817                 batadv_hardif_put(primary_if);
 818 }
 819
 820 /**
 821  * batadv_iv_orig_ifinfo_sum() - Get bcast_own sum for originator over iterface
 822  * @orig_node: originator which reproadcasted the OGMs directly
 823  * @if_outgoing: interface which transmitted the original OGM and received the
 824  *  direct rebroadcast
 825  *
 826  * Return: Number of replied (rebroadcasted) OGMs which were transmitted by
 827  *  an originator and directly (without intermediate hop) received by a specific
 828  *  interface
 829  */
 830 static u8 batadv_iv_orig_ifinfo_sum(struct batadv_orig_node *orig_node,
 831                                     struct batadv_hard_iface *if_outgoing)
 832 {
 833         struct batadv_orig_ifinfo *orig_ifinfo;
 834         u8 sum;
 835
 836         orig_ifinfo = batadv_orig_ifinfo_get(orig_node, if_outgoing);
 837         if (!orig_ifinfo)
 838                 return 0;
 839
 840         spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 841         sum = orig_ifinfo->bat_iv.bcast_own_sum;
 842         spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
 843
 844         batadv_orig_ifinfo_put(orig_ifinfo);
 845
 846         return sum;
 847 }
 848
 849 /**
 850  * batadv_iv_ogm_orig_update() - use OGM to update corresponding data in an
 851  *  originator
 852  * @bat_priv: the bat priv with all the soft interface information
 853  * @orig_node: the orig node who originally emitted the ogm packet
 854  * @orig_ifinfo: ifinfo for the outgoing interface of the orig_node
 855  * @ethhdr: Ethernet header of the OGM
 856  * @batadv_ogm_packet: the ogm packet
 857  * @if_incoming: interface where the packet was received
 858  * @if_outgoing: interface for which the retransmission should be considered
 859  * @dup_status: the duplicate status of this ogm packet.
 860  */
 861 static void
 862 batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv,
 863                           struct batadv_orig_node *orig_node,
 864                           struct batadv_orig_ifinfo *orig_ifinfo,
 865                           const struct ethhdr *ethhdr,
 866                           const struct batadv_ogm_packet *batadv_ogm_packet,
 867                           struct batadv_hard_iface *if_incoming,
 868                           struct batadv_hard_iface *if_outgoing,
 869                           enum batadv_dup_status dup_status)
 870 {
 871         struct batadv_neigh_ifinfo *neigh_ifinfo = NULL;
 872         struct batadv_neigh_ifinfo *router_ifinfo = NULL;
 873         struct batadv_neigh_node *neigh_node = NULL;
 874         struct batadv_neigh_node *tmp_neigh_node = NULL;
 875         struct batadv_neigh_node *router = NULL;
 876         u8 sum_orig, sum_neigh;
 877         u8 *neigh_addr;
 878         u8 tq_avg;
 879
 880         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 881                    "%s(): Searching and updating originator entry of received packet\n",
 882                    __func__);
 883
 884         rcu_read_lock();
 885         hlist_for_each_entry_rcu(tmp_neigh_node,
 886                                  &orig_node->neigh_list, list) {
 887                 neigh_addr = tmp_neigh_node->addr;
 888                 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
 889                     tmp_neigh_node->if_incoming == if_incoming &&
 890                     kref_get_unless_zero(&tmp_neigh_node->refcount)) {
 891                         if (WARN(neigh_node, "too many matching neigh_nodes"))
 892                                 batadv_neigh_node_put(neigh_node);
 893                         neigh_node = tmp_neigh_node;
 894                         continue;
 895                 }
 896
 897                 if (dup_status != BATADV_NO_DUP)
 898                         continue;
 899
 900                 /* only update the entry for this outgoing interface */
 901                 neigh_ifinfo = batadv_neigh_ifinfo_get(tmp_neigh_node,
 902                                                        if_outgoing);
 903                 if (!neigh_ifinfo)
 904                         continue;
 905
 906                 spin_lock_bh(&tmp_neigh_node->ifinfo_lock);
 907                 batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv,
 908                                        &neigh_ifinfo->bat_iv.tq_index, 0);
 909                 tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv);
 910                 neigh_ifinfo->bat_iv.tq_avg = tq_avg;
 911                 spin_unlock_bh(&tmp_neigh_node->ifinfo_lock);
 912
 913                 batadv_neigh_ifinfo_put(neigh_ifinfo);
 914                 neigh_ifinfo = NULL;
 915         }
 916
 917         if (!neigh_node) {
 918                 struct batadv_orig_node *orig_tmp;
 919
 920                 orig_tmp = batadv_iv_ogm_orig_get(bat_priv, ethhdr->h_source);
 921                 if (!orig_tmp)
 922                         goto unlock;
 923
 924                 neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
 925                                                      ethhdr->h_source,
 926                                                      orig_node, orig_tmp);
 927
 928                 batadv_orig_node_put(orig_tmp);
 929                 if (!neigh_node)
 930                         goto unlock;
 931         } else {
 932                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 933                            "Updating existing last-hop neighbor of originator\n");
 934         }
 935
 936         rcu_read_unlock();
 937         neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing);
 938         if (!neigh_ifinfo)
 939                 goto out;
 940
 941         neigh_node->last_seen = jiffies;
 942
 943         spin_lock_bh(&neigh_node->ifinfo_lock);
 944         batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv,
 945                                &neigh_ifinfo->bat_iv.tq_index,
 946                                batadv_ogm_packet->tq);
 947         tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv);
 948         neigh_ifinfo->bat_iv.tq_avg = tq_avg;
 949         spin_unlock_bh(&neigh_node->ifinfo_lock);
 950
 951         if (dup_status == BATADV_NO_DUP) {
 952                 orig_ifinfo->last_ttl = batadv_ogm_packet->ttl;
 953                 neigh_ifinfo->last_ttl = batadv_ogm_packet->ttl;
 954         }
 955
 956         /* if this neighbor already is our next hop there is nothing
 957          * to change
 958          */
 959         router = batadv_orig_router_get(orig_node, if_outgoing);
 960         if (router == neigh_node)
 961                 goto out;
 962
 963         if (router) {
 964                 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing);
 965                 if (!router_ifinfo)
 966                         goto out;
 967
 968                 /* if this neighbor does not offer a better TQ we won't
 969                  * consider it
 970                  */
 971                 if (router_ifinfo->bat_iv.tq_avg > neigh_ifinfo->bat_iv.tq_avg)
 972                         goto out;
 973         }
 974
 975         /* if the TQ is the same and the link not more symmetric we
 976          * won't consider it either
 977          */
 978         if (router_ifinfo &&
 979             neigh_ifinfo->bat_iv.tq_avg == router_ifinfo->bat_iv.tq_avg) {
 980                 sum_orig = batadv_iv_orig_ifinfo_sum(router->orig_node,
 981                                                      router->if_incoming);
 982                 sum_neigh = batadv_iv_orig_ifinfo_sum(neigh_node->orig_node,
 983                                                       neigh_node->if_incoming);
 984                 if (sum_orig >= sum_neigh)
 985                         goto out;
 986         }
 987
 988         batadv_update_route(bat_priv, orig_node, if_outgoing, neigh_node);
 989         goto out;
 990
 991 unlock:
 992         rcu_read_unlock();
 993 out:
 994         if (neigh_node)
 995                 batadv_neigh_node_put(neigh_node);
 996         if (router)
 997                 batadv_neigh_node_put(router);
 998         if (neigh_ifinfo)
 999                 batadv_neigh_ifinfo_put(neigh_ifinfo);
1000         if (router_ifinfo)
1001                 batadv_neigh_ifinfo_put(router_ifinfo);
1002 }
1003
1004 /**
1005  * batadv_iv_ogm_calc_tq() - calculate tq for current received ogm packet
1006  * @orig_node: the orig node who originally emitted the ogm packet
1007  * @orig_neigh_node: the orig node struct of the neighbor who sent the packet
1008  * @batadv_ogm_packet: the ogm packet
1009  * @if_incoming: interface where the packet was received
1010  * @if_outgoing: interface for which the retransmission should be considered
1011  *
1012  * Return: true if the link can be considered bidirectional, false otherwise
1013  */
1014 static bool batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
1015                                   struct batadv_orig_node *orig_neigh_node,
1016                                   struct batadv_ogm_packet *batadv_ogm_packet,
1017                                   struct batadv_hard_iface *if_incoming,
1018                                   struct batadv_hard_iface *if_outgoing)
1019 {
1020         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1021         struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node;
1022         struct batadv_neigh_ifinfo *neigh_ifinfo;
1023         u8 total_count;
1024         u8 orig_eq_count, neigh_rq_count, neigh_rq_inv, tq_own;
1025         unsigned int neigh_rq_inv_cube, neigh_rq_max_cube;
1026         unsigned int tq_asym_penalty, inv_asym_penalty;
1027         unsigned int combined_tq;
1028         unsigned int tq_iface_penalty;
1029         bool ret = false;
1030
1031         /* find corresponding one hop neighbor */
1032         rcu_read_lock();
1033         hlist_for_each_entry_rcu(tmp_neigh_node,
1034                                  &orig_neigh_node->neigh_list, list) {
1035                 if (!batadv_compare_eth(tmp_neigh_node->addr,
1036                                         orig_neigh_node->orig))
1037                         continue;
1038
1039                 if (tmp_neigh_node->if_incoming != if_incoming)
1040                         continue;
1041
1042                 if (!kref_get_unless_zero(&tmp_neigh_node->refcount))
1043                         continue;
1044
1045                 neigh_node = tmp_neigh_node;
1046                 break;
1047         }
1048         rcu_read_unlock();
1049
1050         if (!neigh_node)
1051                 neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
1052                                                      orig_neigh_node->orig,
1053                                                      orig_neigh_node,
1054                                                      orig_neigh_node);
1055
1056         if (!neigh_node)
1057                 goto out;
1058
1059         /* if orig_node is direct neighbor update neigh_node last_seen */
1060         if (orig_node == orig_neigh_node)
1061                 neigh_node->last_seen = jiffies;
1062
1063         orig_node->last_seen = jiffies;
1064
1065         /* find packet count of corresponding one hop neighbor */
1066         orig_eq_count = batadv_iv_orig_ifinfo_sum(orig_neigh_node, if_incoming);
1067         neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing);
1068         if (neigh_ifinfo) {
1069                 neigh_rq_count = neigh_ifinfo->bat_iv.real_packet_count;
1070                 batadv_neigh_ifinfo_put(neigh_ifinfo);
1071         } else {
1072                 neigh_rq_count = 0;
1073         }
1074
1075         /* pay attention to not get a value bigger than 100 % */
1076         if (orig_eq_count > neigh_rq_count)
1077                 total_count = neigh_rq_count;
1078         else
1079                 total_count = orig_eq_count;
1080
1081         /* if we have too few packets (too less data) we set tq_own to zero
1082          * if we receive too few packets it is not considered bidirectional
1083          */
1084         if (total_count < BATADV_TQ_LOCAL_BIDRECT_SEND_MINIMUM ||
1085             neigh_rq_count < BATADV_TQ_LOCAL_BIDRECT_RECV_MINIMUM)
1086                 tq_own = 0;
1087         else
1088                 /* neigh_node->real_packet_count is never zero as we
1089                  * only purge old information when getting new
1090                  * information
1091                  */
1092                 tq_own = (BATADV_TQ_MAX_VALUE * total_count) /  neigh_rq_count;
1093
1094         /* 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does
1095          * affect the nearly-symmetric links only a little, but
1096          * punishes asymmetric links more.  This will give a value
1097          * between 0 and TQ_MAX_VALUE
1098          */
1099         neigh_rq_inv = BATADV_TQ_LOCAL_WINDOW_SIZE - neigh_rq_count;
1100         neigh_rq_inv_cube = neigh_rq_inv * neigh_rq_inv * neigh_rq_inv;
1101         neigh_rq_max_cube = BATADV_TQ_LOCAL_WINDOW_SIZE *
1102                             BATADV_TQ_LOCAL_WINDOW_SIZE *
1103                             BATADV_TQ_LOCAL_WINDOW_SIZE;
1104         inv_asym_penalty = BATADV_TQ_MAX_VALUE * neigh_rq_inv_cube;
1105         inv_asym_penalty /= neigh_rq_max_cube;
1106         tq_asym_penalty = BATADV_TQ_MAX_VALUE - inv_asym_penalty;
1107
1108         /* penalize if the OGM is forwarded on the same interface. WiFi
1109          * interfaces and other half duplex devices suffer from throughput
1110          * drops as they can't send and receive at the same time.
1111          */
1112         tq_iface_penalty = BATADV_TQ_MAX_VALUE;
1113         if (if_outgoing && if_incoming == if_outgoing &&
1114             batadv_is_wifi_hardif(if_outgoing))
1115                 tq_iface_penalty = batadv_hop_penalty(BATADV_TQ_MAX_VALUE,
1116                                                       bat_priv);
1117
1118         combined_tq = batadv_ogm_packet->tq *
1119                       tq_own *
1120                       tq_asym_penalty *
1121                       tq_iface_penalty;
1122         combined_tq /= BATADV_TQ_MAX_VALUE *
1123                        BATADV_TQ_MAX_VALUE *
1124                        BATADV_TQ_MAX_VALUE;
1125         batadv_ogm_packet->tq = combined_tq;
1126
1127         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1128                    "bidirectional: orig = %pM neigh = %pM => 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",
1129                    orig_node->orig, orig_neigh_node->orig, total_count,
1130                    neigh_rq_count, tq_own, tq_asym_penalty, tq_iface_penalty,
1131                    batadv_ogm_packet->tq, if_incoming->net_dev->name,
1132                    if_outgoing ? if_outgoing->net_dev->name : "DEFAULT");
1133
1134         /* if link has the minimum required transmission quality
1135          * consider it bidirectional
1136          */
1137         if (batadv_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT)
1138                 ret = true;
1139
1140 out:
1141         if (neigh_node)
1142                 batadv_neigh_node_put(neigh_node);
1143         return ret;
1144 }
1145
1146 /**
1147  * batadv_iv_ogm_update_seqnos() -  process a batman packet for all interfaces,
1148  *  adjust the sequence number and find out whether it is a duplicate
1149  * @ethhdr: ethernet header of the packet
1150  * @batadv_ogm_packet: OGM packet to be considered
1151  * @if_incoming: interface on which the OGM packet was received
1152  * @if_outgoing: interface for which the retransmission should be considered
1153  *
1154  * Return: duplicate status as enum batadv_dup_status
1155  */
1156 static enum batadv_dup_status
1157 batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
1158                             const struct batadv_ogm_packet *batadv_ogm_packet,
1159                             const struct batadv_hard_iface *if_incoming,
1160                             struct batadv_hard_iface *if_outgoing)
1161 {
1162         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1163         struct batadv_orig_node *orig_node;
1164         struct batadv_orig_ifinfo *orig_ifinfo = NULL;
1165         struct batadv_neigh_node *neigh_node;
1166         struct batadv_neigh_ifinfo *neigh_ifinfo;
1167         bool is_dup;
1168         s32 seq_diff;
1169         bool need_update = false;
1170         int set_mark;
1171         enum batadv_dup_status ret = BATADV_NO_DUP;
1172         u32 seqno = ntohl(batadv_ogm_packet->seqno);
1173         u8 *neigh_addr;
1174         u8 packet_count;
1175         unsigned long *bitmap;
1176
1177         orig_node = batadv_iv_ogm_orig_get(bat_priv, batadv_ogm_packet->orig);
1178         if (!orig_node)
1179                 return BATADV_NO_DUP;
1180
1181         orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing);
1182         if (WARN_ON(!orig_ifinfo)) {
1183                 batadv_orig_node_put(orig_node);
1184                 return 0;
1185         }
1186
1187         spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1188         seq_diff = seqno - orig_ifinfo->last_real_seqno;
1189
1190         /* signalize caller that the packet is to be dropped. */
1191         if (!hlist_empty(&orig_node->neigh_list) &&
1192             batadv_window_protected(bat_priv, seq_diff,
1193                                     BATADV_TQ_LOCAL_WINDOW_SIZE,
1194                                     &orig_ifinfo->batman_seqno_reset, NULL)) {
1195                 ret = BATADV_PROTECTED;
1196                 goto out;
1197         }
1198
1199         rcu_read_lock();
1200         hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1201                 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node,
1202                                                        if_outgoing);
1203                 if (!neigh_ifinfo)
1204                         continue;
1205
1206                 neigh_addr = neigh_node->addr;
1207                 is_dup = batadv_test_bit(neigh_ifinfo->bat_iv.real_bits,
1208                                          orig_ifinfo->last_real_seqno,
1209                                          seqno);
1210
1211                 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
1212                     neigh_node->if_incoming == if_incoming) {
1213                         set_mark = 1;
1214                         if (is_dup)
1215                                 ret = BATADV_NEIGH_DUP;
1216                 } else {
1217                         set_mark = 0;
1218                         if (is_dup && ret != BATADV_NEIGH_DUP)
1219                                 ret = BATADV_ORIG_DUP;
1220                 }
1221
1222                 /* if the window moved, set the update flag. */
1223                 bitmap = neigh_ifinfo->bat_iv.real_bits;
1224                 need_update |= batadv_bit_get_packet(bat_priv, bitmap,
1225                                                      seq_diff, set_mark);
1226
1227                 packet_count = bitmap_weight(bitmap,
1228                                              BATADV_TQ_LOCAL_WINDOW_SIZE);
1229                 neigh_ifinfo->bat_iv.real_packet_count = packet_count;
1230                 batadv_neigh_ifinfo_put(neigh_ifinfo);
1231         }
1232         rcu_read_unlock();
1233
1234         if (need_update) {
1235                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1236                            "%s updating last_seqno: old %u, new %u\n",
1237                            if_outgoing ? if_outgoing->net_dev->name : "DEFAULT",
1238                            orig_ifinfo->last_real_seqno, seqno);
1239                 orig_ifinfo->last_real_seqno = seqno;
1240         }
1241
1242 out:
1243         spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1244         batadv_orig_node_put(orig_node);
1245         batadv_orig_ifinfo_put(orig_ifinfo);
1246         return ret;
1247 }
1248
1249 /**
1250  * batadv_iv_ogm_process_per_outif() - process a batman iv OGM for an outgoing
1251  *  interface
1252  * @skb: the skb containing the OGM
1253  * @ogm_offset: offset from skb->data to start of ogm header
1254  * @orig_node: the (cached) orig node for the originator of this OGM
1255  * @if_incoming: the interface where this packet was received
1256  * @if_outgoing: the interface for which the packet should be considered
1257  */
1258 static void
1259 batadv_iv_ogm_process_per_outif(const struct sk_buff *skb, int ogm_offset,
1260                                 struct batadv_orig_node *orig_node,
1261                                 struct batadv_hard_iface *if_incoming,
1262                                 struct batadv_hard_iface *if_outgoing)
1263 {
1264         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1265         struct batadv_hardif_neigh_node *hardif_neigh = NULL;
1266         struct batadv_neigh_node *router = NULL;
1267         struct batadv_neigh_node *router_router = NULL;
1268         struct batadv_orig_node *orig_neigh_node;
1269         struct batadv_orig_ifinfo *orig_ifinfo;
1270         struct batadv_neigh_node *orig_neigh_router = NULL;
1271         struct batadv_neigh_ifinfo *router_ifinfo = NULL;
1272         struct batadv_ogm_packet *ogm_packet;
1273         enum batadv_dup_status dup_status;
1274         bool is_from_best_next_hop = false;
1275         bool is_single_hop_neigh = false;
1276         bool sameseq, similar_ttl;
1277         struct sk_buff *skb_priv;
1278         struct ethhdr *ethhdr;
1279         u8 *prev_sender;
1280         bool is_bidirect;
1281
1282         /* create a private copy of the skb, as some functions change tq value
1283          * and/or flags.
1284          */
1285         skb_priv = skb_copy(skb, GFP_ATOMIC);
1286         if (!skb_priv)
1287                 return;
1288
1289         ethhdr = eth_hdr(skb_priv);
1290         ogm_packet = (struct batadv_ogm_packet *)(skb_priv->data + ogm_offset);
1291
1292         dup_status = batadv_iv_ogm_update_seqnos(ethhdr, ogm_packet,
1293                                                  if_incoming, if_outgoing);
1294         if (batadv_compare_eth(ethhdr->h_source, ogm_packet->orig))
1295                 is_single_hop_neigh = true;
1296
1297         if (dup_status == BATADV_PROTECTED) {
1298                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1299                            "Drop packet: packet within seqno protection time (sender: %pM)\n",
1300                            ethhdr->h_source);
1301                 goto out;
1302         }
1303
1304         if (ogm_packet->tq == 0) {
1305                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1306                            "Drop packet: originator packet with tq equal 0\n");
1307                 goto out;
1308         }
1309
1310         if (is_single_hop_neigh) {
1311                 hardif_neigh = batadv_hardif_neigh_get(if_incoming,
1312                                                        ethhdr->h_source);
1313                 if (hardif_neigh)
1314                         hardif_neigh->last_seen = jiffies;
1315         }
1316
1317         router = batadv_orig_router_get(orig_node, if_outgoing);
1318         if (router) {
1319                 router_router = batadv_orig_router_get(router->orig_node,
1320                                                        if_outgoing);
1321                 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing);
1322         }
1323
1324         if ((router_ifinfo && router_ifinfo->bat_iv.tq_avg != 0) &&
1325             (batadv_compare_eth(router->addr, ethhdr->h_source)))
1326                 is_from_best_next_hop = true;
1327
1328         prev_sender = ogm_packet->prev_sender;
1329         /* avoid temporary routing loops */
1330         if (router && router_router &&
1331             (batadv_compare_eth(router->addr, prev_sender)) &&
1332             !(batadv_compare_eth(ogm_packet->orig, prev_sender)) &&
1333             (batadv_compare_eth(router->addr, router_router->addr))) {
1334                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1335                            "Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",
1336                            ethhdr->h_source);
1337                 goto out;
1338         }
1339
1340         if (if_outgoing == BATADV_IF_DEFAULT)
1341                 batadv_tvlv_ogm_receive(bat_priv, ogm_packet, orig_node);
1342
1343         /* if sender is a direct neighbor the sender mac equals
1344          * originator mac
1345          */
1346         if (is_single_hop_neigh)
1347                 orig_neigh_node = orig_node;
1348         else
1349                 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv,
1350                                                          ethhdr->h_source);
1351
1352         if (!orig_neigh_node)
1353                 goto out;
1354
1355         /* Update nc_nodes of the originator */
1356         batadv_nc_update_nc_node(bat_priv, orig_node, orig_neigh_node,
1357                                  ogm_packet, is_single_hop_neigh);
1358
1359         orig_neigh_router = batadv_orig_router_get(orig_neigh_node,
1360                                                    if_outgoing);
1361
1362         /* drop packet if sender is not a direct neighbor and if we
1363          * don't route towards it
1364          */
1365         if (!is_single_hop_neigh && !orig_neigh_router) {
1366                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1367                            "Drop packet: OGM via unknown neighbor!\n");
1368                 goto out_neigh;
1369         }
1370
1371         is_bidirect = batadv_iv_ogm_calc_tq(orig_node, orig_neigh_node,
1372                                             ogm_packet, if_incoming,
1373                                             if_outgoing);
1374
1375         /* update ranking if it is not a duplicate or has the same
1376          * seqno and similar ttl as the non-duplicate
1377          */
1378         orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing);
1379         if (!orig_ifinfo)
1380                 goto out_neigh;
1381
1382         sameseq = orig_ifinfo->last_real_seqno == ntohl(ogm_packet->seqno);
1383         similar_ttl = (orig_ifinfo->last_ttl - 3) <= ogm_packet->ttl;
1384
1385         if (is_bidirect && (dup_status == BATADV_NO_DUP ||
1386                             (sameseq && similar_ttl))) {
1387                 batadv_iv_ogm_orig_update(bat_priv, orig_node,
1388                                           orig_ifinfo, ethhdr,
1389                                           ogm_packet, if_incoming,
1390                                           if_outgoing, dup_status);
1391         }
1392         batadv_orig_ifinfo_put(orig_ifinfo);
1393
1394         /* only forward for specific interface, not for the default one. */
1395         if (if_outgoing == BATADV_IF_DEFAULT)
1396                 goto out_neigh;
1397
1398         /* is single hop (direct) neighbor */
1399         if (is_single_hop_neigh) {
1400                 /* OGMs from secondary interfaces should only scheduled once
1401                  * per interface where it has been received, not multiple times
1402                  */
1403                 if (ogm_packet->ttl <= 2 &&
1404                     if_incoming != if_outgoing) {
1405                         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1406                                    "Drop packet: OGM from secondary interface and wrong outgoing interface\n");
1407                         goto out_neigh;
1408                 }
1409                 /* mark direct link on incoming interface */
1410                 batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet,
1411                                       is_single_hop_neigh,
1412                                       is_from_best_next_hop, if_incoming,
1413                                       if_outgoing);
1414
1415                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1416                            "Forwarding packet: rebroadcast neighbor packet with direct link flag\n");
1417                 goto out_neigh;
1418         }
1419
1420         /* multihop originator */
1421         if (!is_bidirect) {
1422                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1423                            "Drop packet: not received via bidirectional link\n");
1424                 goto out_neigh;
1425         }
1426
1427         if (dup_status == BATADV_NEIGH_DUP) {
1428                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1429                            "Drop packet: duplicate packet received\n");
1430                 goto out_neigh;
1431         }
1432
1433         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1434                    "Forwarding packet: rebroadcast originator packet\n");
1435         batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet,
1436                               is_single_hop_neigh, is_from_best_next_hop,
1437                               if_incoming, if_outgoing);
1438
1439 out_neigh:
1440         if (orig_neigh_node && !is_single_hop_neigh)
1441                 batadv_orig_node_put(orig_neigh_node);
1442 out:
1443         if (router_ifinfo)
1444                 batadv_neigh_ifinfo_put(router_ifinfo);
1445         if (router)
1446                 batadv_neigh_node_put(router);
1447         if (router_router)
1448                 batadv_neigh_node_put(router_router);
1449         if (orig_neigh_router)
1450                 batadv_neigh_node_put(orig_neigh_router);
1451         if (hardif_neigh)
1452                 batadv_hardif_neigh_put(hardif_neigh);
1453
1454         consume_skb(skb_priv);
1455 }
1456
1457 /**
1458  * batadv_iv_ogm_process_reply() - Check OGM for direct reply and process it
1459  * @ogm_packet: rebroadcast OGM packet to process
1460  * @if_incoming: the interface where this packet was received
1461  * @orig_node: originator which reproadcasted the OGMs
1462  * @if_incoming_seqno: OGM sequence number when rebroadcast was received
1463  */
1464 static void batadv_iv_ogm_process_reply(struct batadv_ogm_packet *ogm_packet,
1465                                         struct batadv_hard_iface *if_incoming,
1466                                         struct batadv_orig_node *orig_node,
1467                                         u32 if_incoming_seqno)
1468 {
1469         struct batadv_orig_ifinfo *orig_ifinfo;
1470         s32 bit_pos;
1471         u8 *weight;
1472
1473         /* neighbor has to indicate direct link and it has to
1474          * come via the corresponding interface
1475          */
1476         if (!(ogm_packet->flags & BATADV_DIRECTLINK))
1477                 return;
1478
1479         if (!batadv_compare_eth(if_incoming->net_dev->dev_addr,
1480                                 ogm_packet->orig))
1481                 return;
1482
1483         orig_ifinfo = batadv_orig_ifinfo_get(orig_node, if_incoming);
1484         if (!orig_ifinfo)
1485                 return;
1486
1487         /* save packet seqno for bidirectional check */
1488         spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1489         bit_pos = if_incoming_seqno - 2;
1490         bit_pos -= ntohl(ogm_packet->seqno);
1491         batadv_set_bit(orig_ifinfo->bat_iv.bcast_own, bit_pos);
1492         weight = &orig_ifinfo->bat_iv.bcast_own_sum;
1493         *weight = bitmap_weight(orig_ifinfo->bat_iv.bcast_own,
1494                                 BATADV_TQ_LOCAL_WINDOW_SIZE);
1495         spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1496
1497         batadv_orig_ifinfo_put(orig_ifinfo);
1498 }
1499
1500 /**
1501  * batadv_iv_ogm_process() - process an incoming batman iv OGM
1502  * @skb: the skb containing the OGM
1503  * @ogm_offset: offset to the OGM which should be processed (for aggregates)
1504  * @if_incoming: the interface where this packet was receved
1505  */
1506 static void batadv_iv_ogm_process(const struct sk_buff *skb, int ogm_offset,
1507                                   struct batadv_hard_iface *if_incoming)
1508 {
1509         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1510         struct batadv_orig_node *orig_neigh_node, *orig_node;
1511         struct batadv_hard_iface *hard_iface;
1512         struct batadv_ogm_packet *ogm_packet;
1513         u32 if_incoming_seqno;
1514         bool has_directlink_flag;
1515         struct ethhdr *ethhdr;
1516         bool is_my_oldorig = false;
1517         bool is_my_addr = false;
1518         bool is_my_orig = false;
1519
1520         ogm_packet = (struct batadv_ogm_packet *)(skb->data + ogm_offset);
1521         ethhdr = eth_hdr(skb);
1522
1523         /* Silently drop when the batman packet is actually not a
1524          * correct packet.
1525          *
1526          * This might happen if a packet is padded (e.g. Ethernet has a
1527          * minimum frame length of 64 byte) and the aggregation interprets
1528          * it as an additional length.
1529          *
1530          * TODO: A more sane solution would be to have a bit in the
1531          * batadv_ogm_packet to detect whether the packet is the last
1532          * packet in an aggregation.  Here we expect that the padding
1533          * is always zero (or not 0x01)
1534          */
1535         if (ogm_packet->packet_type != BATADV_IV_OGM)
1536                 return;
1537
1538         /* could be changed by schedule_own_packet() */
1539         if_incoming_seqno = atomic_read(&if_incoming->bat_iv.ogm_seqno);
1540
1541         if (ogm_packet->flags & BATADV_DIRECTLINK)
1542                 has_directlink_flag = true;
1543         else
1544                 has_directlink_flag = false;
1545
1546         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1547                    "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",
1548                    ethhdr->h_source, if_incoming->net_dev->name,
1549                    if_incoming->net_dev->dev_addr, ogm_packet->orig,
1550                    ogm_packet->prev_sender, ntohl(ogm_packet->seqno),
1551                    ogm_packet->tq, ogm_packet->ttl,
1552                    ogm_packet->version, has_directlink_flag);
1553
1554         rcu_read_lock();
1555         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1556                 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1557                         continue;
1558
1559                 if (hard_iface->soft_iface != if_incoming->soft_iface)
1560                         continue;
1561
1562                 if (batadv_compare_eth(ethhdr->h_source,
1563                                        hard_iface->net_dev->dev_addr))
1564                         is_my_addr = true;
1565
1566                 if (batadv_compare_eth(ogm_packet->orig,
1567                                        hard_iface->net_dev->dev_addr))
1568                         is_my_orig = true;
1569
1570                 if (batadv_compare_eth(ogm_packet->prev_sender,
1571                                        hard_iface->net_dev->dev_addr))
1572                         is_my_oldorig = true;
1573         }
1574         rcu_read_unlock();
1575
1576         if (is_my_addr) {
1577                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1578                            "Drop packet: received my own broadcast (sender: %pM)\n",
1579                            ethhdr->h_source);
1580                 return;
1581         }
1582
1583         if (is_my_orig) {
1584                 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv,
1585                                                          ethhdr->h_source);
1586                 if (!orig_neigh_node)
1587                         return;
1588
1589                 batadv_iv_ogm_process_reply(ogm_packet, if_incoming,
1590                                             orig_neigh_node, if_incoming_seqno);
1591
1592                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1593                            "Drop packet: originator packet from myself (via neighbor)\n");
1594                 batadv_orig_node_put(orig_neigh_node);
1595                 return;
1596         }
1597
1598         if (is_my_oldorig) {
1599                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1600                            "Drop packet: ignoring all rebroadcast echos (sender: %pM)\n",
1601                            ethhdr->h_source);
1602                 return;
1603         }
1604
1605         if (ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP) {
1606                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1607                            "Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
1608                            ethhdr->h_source);
1609                 return;
1610         }
1611
1612         orig_node = batadv_iv_ogm_orig_get(bat_priv, ogm_packet->orig);
1613         if (!orig_node)
1614                 return;
1615
1616         batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node,
1617                                         if_incoming, BATADV_IF_DEFAULT);
1618
1619         rcu_read_lock();
1620         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1621                 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1622                         continue;
1623
1624                 if (hard_iface->soft_iface != bat_priv->soft_iface)
1625                         continue;
1626
1627                 if (!kref_get_unless_zero(&hard_iface->refcount))
1628                         continue;
1629
1630                 batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node,
1631                                                 if_incoming, hard_iface);
1632
1633                 batadv_hardif_put(hard_iface);
1634         }
1635         rcu_read_unlock();
1636
1637         batadv_orig_node_put(orig_node);
1638 }
1639
1640 static void batadv_iv_send_outstanding_bat_ogm_packet(struct work_struct *work)
1641 {
1642         struct delayed_work *delayed_work;
1643         struct batadv_forw_packet *forw_packet;
1644         struct batadv_priv *bat_priv;
1645         bool dropped = false;
1646
1647         delayed_work = to_delayed_work(work);
1648         forw_packet = container_of(delayed_work, struct batadv_forw_packet,
1649                                    delayed_work);
1650         bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface);
1651
1652         if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) {
1653                 dropped = true;
1654                 goto out;
1655         }
1656
1657         batadv_iv_ogm_emit(forw_packet);
1658
1659         /* we have to have at least one packet in the queue to determine the
1660          * queues wake up time unless we are shutting down.
1661          *
1662          * only re-schedule if this is the "original" copy, e.g. the OGM of the
1663          * primary interface should only be rescheduled once per period, but
1664          * this function will be called for the forw_packet instances of the
1665          * other secondary interfaces as well.
1666          */
1667         if (forw_packet->own &&
1668             forw_packet->if_incoming == forw_packet->if_outgoing)
1669                 batadv_iv_ogm_schedule(forw_packet->if_incoming);
1670
1671 out:
1672         /* do we get something for free()? */
1673         if (batadv_forw_packet_steal(forw_packet,
1674                                      &bat_priv->forw_bat_list_lock))
1675                 batadv_forw_packet_free(forw_packet, dropped);
1676 }
1677
1678 static int batadv_iv_ogm_receive(struct sk_buff *skb,
1679                                  struct batadv_hard_iface *if_incoming)
1680 {
1681         struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1682         struct batadv_ogm_packet *ogm_packet;
1683         u8 *packet_pos;
1684         int ogm_offset;
1685         bool res;
1686         int ret = NET_RX_DROP;
1687
1688         res = batadv_check_management_packet(skb, if_incoming, BATADV_OGM_HLEN);
1689         if (!res)
1690                 goto free_skb;
1691
1692         /* did we receive a B.A.T.M.A.N. IV OGM packet on an interface
1693          * that does not have B.A.T.M.A.N. IV enabled ?
1694          */
1695         if (bat_priv->algo_ops->iface.enable != batadv_iv_ogm_iface_enable)
1696                 goto free_skb;
1697
1698         batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_RX);
1699         batadv_add_counter(bat_priv, BATADV_CNT_MGMT_RX_BYTES,
1700                            skb->len + ETH_HLEN);
1701
1702         ogm_offset = 0;
1703         ogm_packet = (struct batadv_ogm_packet *)skb->data;
1704
1705         /* unpack the aggregated packets and process them one by one */
1706         while (batadv_iv_ogm_aggr_packet(ogm_offset, skb_headlen(skb),
1707                                          ogm_packet->tvlv_len)) {
1708                 batadv_iv_ogm_process(skb, ogm_offset, if_incoming);
1709
1710                 ogm_offset += BATADV_OGM_HLEN;
1711                 ogm_offset += ntohs(ogm_packet->tvlv_len);
1712
1713                 packet_pos = skb->data + ogm_offset;
1714                 ogm_packet = (struct batadv_ogm_packet *)packet_pos;
1715         }
1716
1717         ret = NET_RX_SUCCESS;
1718
1719 free_skb:
1720         if (ret == NET_RX_SUCCESS)
1721                 consume_skb(skb);
1722         else
1723                 kfree_skb(skb);
1724
1725         return ret;
1726 }
1727
1728 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
1729 /**
1730  * batadv_iv_ogm_orig_print_neigh() - print neighbors for the originator table
1731  * @orig_node: the orig_node for which the neighbors are printed
1732  * @if_outgoing: outgoing interface for these entries
1733  * @seq: debugfs table seq_file struct
1734  *
1735  * Must be called while holding an rcu lock.
1736  */
1737 static void
1738 batadv_iv_ogm_orig_print_neigh(struct batadv_orig_node *orig_node,
1739                                struct batadv_hard_iface *if_outgoing,
1740                                struct seq_file *seq)
1741 {
1742         struct batadv_neigh_node *neigh_node;
1743         struct batadv_neigh_ifinfo *n_ifinfo;
1744
1745         hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1746                 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
1747                 if (!n_ifinfo)
1748                         continue;
1749
1750                 seq_printf(seq, " %pM (%3i)",
1751                            neigh_node->addr,
1752                            n_ifinfo->bat_iv.tq_avg);
1753
1754                 batadv_neigh_ifinfo_put(n_ifinfo);
1755         }
1756 }
1757
1758 /**
1759  * batadv_iv_ogm_orig_print() - print the originator table
1760  * @bat_priv: the bat priv with all the soft interface information
1761  * @seq: debugfs table seq_file struct
1762  * @if_outgoing: the outgoing interface for which this should be printed
1763  */
1764 static void batadv_iv_ogm_orig_print(struct batadv_priv *bat_priv,
1765                                      struct seq_file *seq,
1766                                      struct batadv_hard_iface *if_outgoing)
1767 {
1768         struct batadv_neigh_node *neigh_node;
1769         struct batadv_hashtable *hash = bat_priv->orig_hash;
1770         int last_seen_msecs, last_seen_secs;
1771         struct batadv_orig_node *orig_node;
1772         struct batadv_neigh_ifinfo *n_ifinfo;
1773         unsigned long last_seen_jiffies;
1774         struct hlist_head *head;
1775         int batman_count = 0;
1776         u32 i;
1777
1778         seq_puts(seq,
1779                  "  Originator      last-seen (#/255)           Nexthop [outgoingIF]:   Potential nexthops ...\n");
1780
1781         for (i = 0; i < hash->size; i++) {
1782                 head = &hash->table[i];
1783
1784                 rcu_read_lock();
1785                 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
1786                         neigh_node = batadv_orig_router_get(orig_node,
1787                                                             if_outgoing);
1788                         if (!neigh_node)
1789                                 continue;
1790
1791                         n_ifinfo = batadv_neigh_ifinfo_get(neigh_node,
1792                                                            if_outgoing);
1793                         if (!n_ifinfo)
1794                                 goto next;
1795
1796                         if (n_ifinfo->bat_iv.tq_avg == 0)
1797                                 goto next;
1798
1799                         last_seen_jiffies = jiffies - orig_node->last_seen;
1800                         last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
1801                         last_seen_secs = last_seen_msecs / 1000;
1802                         last_seen_msecs = last_seen_msecs % 1000;
1803
1804                         seq_printf(seq, "%pM %4i.%03is   (%3i) %pM [%10s]:",
1805                                    orig_node->orig, last_seen_secs,
1806                                    last_seen_msecs, n_ifinfo->bat_iv.tq_avg,
1807                                    neigh_node->addr,
1808                                    neigh_node->if_incoming->net_dev->name);
1809
1810                         batadv_iv_ogm_orig_print_neigh(orig_node, if_outgoing,
1811                                                        seq);
1812                         seq_putc(seq, '\n');
1813                         batman_count++;
1814
1815 next:
1816                         batadv_neigh_node_put(neigh_node);
1817                         if (n_ifinfo)
1818                                 batadv_neigh_ifinfo_put(n_ifinfo);
1819                 }
1820                 rcu_read_unlock();
1821         }
1822
1823         if (batman_count == 0)
1824                 seq_puts(seq, "No batman nodes in range ...\n");
1825 }
1826 #endif
1827
1828 /**
1829  * batadv_iv_ogm_neigh_get_tq_avg() - Get the TQ average for a neighbour on a
1830  *  given outgoing interface.
1831  * @neigh_node: Neighbour of interest
1832  * @if_outgoing: Outgoing interface of interest
1833  * @tq_avg: Pointer of where to store the TQ average
1834  *
1835  * Return: False if no average TQ available, otherwise true.
1836  */
1837 static bool
1838 batadv_iv_ogm_neigh_get_tq_avg(struct batadv_neigh_node *neigh_node,
1839                                struct batadv_hard_iface *if_outgoing,
1840                                u8 *tq_avg)
1841 {
1842         struct batadv_neigh_ifinfo *n_ifinfo;
1843
1844         n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
1845         if (!n_ifinfo)
1846                 return false;
1847
1848         *tq_avg = n_ifinfo->bat_iv.tq_avg;
1849         batadv_neigh_ifinfo_put(n_ifinfo);
1850
1851         return true;
1852 }
1853
1854 /**
1855  * batadv_iv_ogm_orig_dump_subentry() - Dump an originator subentry into a
1856  *  message
1857  * @msg: Netlink message to dump into
1858  * @portid: Port making netlink request
1859  * @seq: Sequence number of netlink message
1860  * @bat_priv: The bat priv with all the soft interface information
1861  * @if_outgoing: Limit dump to entries with this outgoing interface
1862  * @orig_node: Originator to dump
1863  * @neigh_node: Single hops neighbour
1864  * @best: Is the best originator
1865  *
1866  * Return: Error code, or 0 on success
1867  */
1868 static int
1869 batadv_iv_ogm_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
1870                                  struct batadv_priv *bat_priv,
1871                                  struct batadv_hard_iface *if_outgoing,
1872                                  struct batadv_orig_node *orig_node,
1873                                  struct batadv_neigh_node *neigh_node,
1874                                  bool best)
1875 {
1876         void *hdr;
1877         u8 tq_avg;
1878         unsigned int last_seen_msecs;
1879
1880         last_seen_msecs = jiffies_to_msecs(jiffies - orig_node->last_seen);
1881
1882         if (!batadv_iv_ogm_neigh_get_tq_avg(neigh_node, if_outgoing, &tq_avg))
1883                 return 0;
1884
1885         if (if_outgoing != BATADV_IF_DEFAULT &&
1886             if_outgoing != neigh_node->if_incoming)
1887                 return 0;
1888
1889         hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
1890                           NLM_F_MULTI, BATADV_CMD_GET_ORIGINATORS);
1891         if (!hdr)
1892                 return -ENOBUFS;
1893
1894         if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
1895                     orig_node->orig) ||
1896             nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
1897                     neigh_node->addr) ||
1898             nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
1899                         neigh_node->if_incoming->net_dev->ifindex) ||
1900             nla_put_u8(msg, BATADV_ATTR_TQ, tq_avg) ||
1901             nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
1902                         last_seen_msecs))
1903                 goto nla_put_failure;
1904
1905         if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
1906                 goto nla_put_failure;
1907
1908         genlmsg_end(msg, hdr);
1909         return 0;
1910
1911  nla_put_failure:
1912         genlmsg_cancel(msg, hdr);
1913         return -EMSGSIZE;
1914 }
1915
1916 /**
1917  * batadv_iv_ogm_orig_dump_entry() - Dump an originator entry into a message
1918  * @msg: Netlink message to dump into
1919  * @portid: Port making netlink request
1920  * @seq: Sequence number of netlink message
1921  * @bat_priv: The bat priv with all the soft interface information
1922  * @if_outgoing: Limit dump to entries with this outgoing interface
1923  * @orig_node: Originator to dump
1924  * @sub_s: Number of sub entries to skip
1925  *
1926  * This function assumes the caller holds rcu_read_lock().
1927  *
1928  * Return: Error code, or 0 on success
1929  */
1930 static int
1931 batadv_iv_ogm_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
1932                               struct batadv_priv *bat_priv,
1933                               struct batadv_hard_iface *if_outgoing,
1934                               struct batadv_orig_node *orig_node, int *sub_s)
1935 {
1936         struct batadv_neigh_node *neigh_node_best;
1937         struct batadv_neigh_node *neigh_node;
1938         int sub = 0;
1939         bool best;
1940         u8 tq_avg_best;
1941
1942         neigh_node_best = batadv_orig_router_get(orig_node, if_outgoing);
1943         if (!neigh_node_best)
1944                 goto out;
1945
1946         if (!batadv_iv_ogm_neigh_get_tq_avg(neigh_node_best, if_outgoing,
1947                                             &tq_avg_best))
1948                 goto out;
1949
1950         if (tq_avg_best == 0)
1951                 goto out;
1952
1953         hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1954                 if (sub++ < *sub_s)
1955                         continue;
1956
1957                 best = (neigh_node == neigh_node_best);
1958
1959                 if (batadv_iv_ogm_orig_dump_subentry(msg, portid, seq,
1960                                                      bat_priv, if_outgoing,
1961                                                      orig_node, neigh_node,
1962                                                      best)) {
1963                         batadv_neigh_node_put(neigh_node_best);
1964
1965                         *sub_s = sub - 1;
1966                         return -EMSGSIZE;
1967                 }
1968         }
1969
1970  out:
1971         if (neigh_node_best)
1972                 batadv_neigh_node_put(neigh_node_best);
1973
1974         *sub_s = 0;
1975         return 0;
1976 }
1977
1978 /**
1979  * batadv_iv_ogm_orig_dump_bucket() - Dump an originator bucket into a
1980  *  message
1981  * @msg: Netlink message to dump into
1982  * @portid: Port making netlink request
1983  * @seq: Sequence number of netlink message
1984  * @bat_priv: The bat priv with all the soft interface information
1985  * @if_outgoing: Limit dump to entries with this outgoing interface
1986  * @head: Bucket to be dumped
1987  * @idx_s: Number of entries to be skipped
1988  * @sub: Number of sub entries to be skipped
1989  *
1990  * Return: Error code, or 0 on success
1991  */
1992 static int
1993 batadv_iv_ogm_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
1994                                struct batadv_priv *bat_priv,
1995                                struct batadv_hard_iface *if_outgoing,
1996                                struct hlist_head *head, int *idx_s, int *sub)
1997 {
1998         struct batadv_orig_node *orig_node;
1999         int idx = 0;
2000
2001         rcu_read_lock();
2002         hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
2003                 if (idx++ < *idx_s)
2004                         continue;
2005
2006                 if (batadv_iv_ogm_orig_dump_entry(msg, portid, seq, bat_priv,
2007                                                   if_outgoing, orig_node,
2008                                                   sub)) {
2009                         rcu_read_unlock();
2010                         *idx_s = idx - 1;
2011                         return -EMSGSIZE;
2012                 }
2013         }
2014         rcu_read_unlock();
2015
2016         *idx_s = 0;
2017         *sub = 0;
2018         return 0;
2019 }
2020
2021 /**
2022  * batadv_iv_ogm_orig_dump() - Dump the originators into a message
2023  * @msg: Netlink message to dump into
2024  * @cb: Control block containing additional options
2025  * @bat_priv: The bat priv with all the soft interface information
2026  * @if_outgoing: Limit dump to entries with this outgoing interface
2027  */
2028 static void
2029 batadv_iv_ogm_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
2030                         struct batadv_priv *bat_priv,
2031                         struct batadv_hard_iface *if_outgoing)
2032 {
2033         struct batadv_hashtable *hash = bat_priv->orig_hash;
2034         struct hlist_head *head;
2035         int bucket = cb->args[0];
2036         int idx = cb->args[1];
2037         int sub = cb->args[2];
2038         int portid = NETLINK_CB(cb->skb).portid;
2039
2040         while (bucket < hash->size) {
2041                 head = &hash->table[bucket];
2042
2043                 if (batadv_iv_ogm_orig_dump_bucket(msg, portid,
2044                                                    cb->nlh->nlmsg_seq,
2045                                                    bat_priv, if_outgoing, head,
2046                                                    &idx, &sub))
2047                         break;
2048
2049                 bucket++;
2050         }
2051
2052         cb->args[0] = bucket;
2053         cb->args[1] = idx;
2054         cb->args[2] = sub;
2055 }
2056
2057 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2058 /**
2059  * batadv_iv_hardif_neigh_print() - print a single hop neighbour node
2060  * @seq: neighbour table seq_file struct
2061  * @hardif_neigh: hardif neighbour information
2062  */
2063 static void
2064 batadv_iv_hardif_neigh_print(struct seq_file *seq,
2065                              struct batadv_hardif_neigh_node *hardif_neigh)
2066 {
2067         int last_secs, last_msecs;
2068
2069         last_secs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen) / 1000;
2070         last_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen) % 1000;
2071
2072         seq_printf(seq, "   %10s   %pM %4i.%03is\n",
2073                    hardif_neigh->if_incoming->net_dev->name,
2074                    hardif_neigh->addr, last_secs, last_msecs);
2075 }
2076
2077 /**
2078  * batadv_iv_ogm_neigh_print() - print the single hop neighbour list
2079  * @bat_priv: the bat priv with all the soft interface information
2080  * @seq: neighbour table seq_file struct
2081  */
2082 static void batadv_iv_neigh_print(struct batadv_priv *bat_priv,
2083                                   struct seq_file *seq)
2084 {
2085         struct net_device *net_dev = (struct net_device *)seq->private;
2086         struct batadv_hardif_neigh_node *hardif_neigh;
2087         struct batadv_hard_iface *hard_iface;
2088         int batman_count = 0;
2089
2090         seq_puts(seq, "           IF        Neighbor      last-seen\n");
2091
2092         rcu_read_lock();
2093         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
2094                 if (hard_iface->soft_iface != net_dev)
2095                         continue;
2096
2097                 hlist_for_each_entry_rcu(hardif_neigh,
2098                                          &hard_iface->neigh_list, list) {
2099                         batadv_iv_hardif_neigh_print(seq, hardif_neigh);
2100                         batman_count++;
2101                 }
2102         }
2103         rcu_read_unlock();
2104
2105         if (batman_count == 0)
2106                 seq_puts(seq, "No batman nodes in range ...\n");
2107 }
2108 #endif
2109
2110 /**
2111  * batadv_iv_ogm_neigh_diff() - calculate tq difference of two neighbors
2112  * @neigh1: the first neighbor object of the comparison
2113  * @if_outgoing1: outgoing interface for the first neighbor
2114  * @neigh2: the second neighbor object of the comparison
2115  * @if_outgoing2: outgoing interface for the second neighbor
2116  * @diff: pointer to integer receiving the calculated difference
2117  *
2118  * The content of *@diff is only valid when this function returns true.
2119  * It is less, equal to or greater than 0 if the metric via neigh1 is lower,
2120  * the same as or higher than the metric via neigh2
2121  *
2122  * Return: true when the difference could be calculated, false otherwise
2123  */
2124 static bool batadv_iv_ogm_neigh_diff(struct batadv_neigh_node *neigh1,
2125                                      struct batadv_hard_iface *if_outgoing1,
2126                                      struct batadv_neigh_node *neigh2,
2127                                      struct batadv_hard_iface *if_outgoing2,
2128                                      int *diff)
2129 {
2130         struct batadv_neigh_ifinfo *neigh1_ifinfo, *neigh2_ifinfo;
2131         u8 tq1, tq2;
2132         bool ret = true;
2133
2134         neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
2135         neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
2136
2137         if (!neigh1_ifinfo || !neigh2_ifinfo) {
2138                 ret = false;
2139                 goto out;
2140         }
2141
2142         tq1 = neigh1_ifinfo->bat_iv.tq_avg;
2143         tq2 = neigh2_ifinfo->bat_iv.tq_avg;
2144         *diff = (int)tq1 - (int)tq2;
2145
2146 out:
2147         if (neigh1_ifinfo)
2148                 batadv_neigh_ifinfo_put(neigh1_ifinfo);
2149         if (neigh2_ifinfo)
2150                 batadv_neigh_ifinfo_put(neigh2_ifinfo);
2151
2152         return ret;
2153 }
2154
2155 /**
2156  * batadv_iv_ogm_neigh_dump_neigh() - Dump a neighbour into a netlink message
2157  * @msg: Netlink message to dump into
2158  * @portid: Port making netlink request
2159  * @seq: Sequence number of netlink message
2160  * @hardif_neigh: Neighbour to be dumped
2161  *
2162  * Return: Error code, or 0 on success
2163  */
2164 static int
2165 batadv_iv_ogm_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
2166                                struct batadv_hardif_neigh_node *hardif_neigh)
2167 {
2168         void *hdr;
2169         unsigned int last_seen_msecs;
2170
2171         last_seen_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen);
2172
2173         hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
2174                           NLM_F_MULTI, BATADV_CMD_GET_NEIGHBORS);
2175         if (!hdr)
2176                 return -ENOBUFS;
2177
2178         if (nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
2179                     hardif_neigh->addr) ||
2180             nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
2181                         hardif_neigh->if_incoming->net_dev->ifindex) ||
2182             nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
2183                         last_seen_msecs))
2184                 goto nla_put_failure;
2185
2186         genlmsg_end(msg, hdr);
2187         return 0;
2188
2189  nla_put_failure:
2190         genlmsg_cancel(msg, hdr);
2191         return -EMSGSIZE;
2192 }
2193
2194 /**
2195  * batadv_iv_ogm_neigh_dump_hardif() - Dump the neighbours of a hard interface
2196  *  into a message
2197  * @msg: Netlink message to dump into
2198  * @portid: Port making netlink request
2199  * @seq: Sequence number of netlink message
2200  * @bat_priv: The bat priv with all the soft interface information
2201  * @hard_iface: Hard interface to dump the neighbours for
2202  * @idx_s: Number of entries to skip
2203  *
2204  * This function assumes the caller holds rcu_read_lock().
2205  *
2206  * Return: Error code, or 0 on success
2207  */
2208 static int
2209 batadv_iv_ogm_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
2210                                 struct batadv_priv *bat_priv,
2211                                 struct batadv_hard_iface *hard_iface,
2212                                 int *idx_s)
2213 {
2214         struct batadv_hardif_neigh_node *hardif_neigh;
2215         int idx = 0;
2216
2217         hlist_for_each_entry_rcu(hardif_neigh,
2218                                  &hard_iface->neigh_list, list) {
2219                 if (idx++ < *idx_s)
2220                         continue;
2221
2222                 if (batadv_iv_ogm_neigh_dump_neigh(msg, portid, seq,
2223                                                    hardif_neigh)) {
2224                         *idx_s = idx - 1;
2225                         return -EMSGSIZE;
2226                 }
2227         }
2228
2229         *idx_s = 0;
2230         return 0;
2231 }
2232
2233 /**
2234  * batadv_iv_ogm_neigh_dump() - Dump the neighbours into a message
2235  * @msg: Netlink message to dump into
2236  * @cb: Control block containing additional options
2237  * @bat_priv: The bat priv with all the soft interface information
2238  * @single_hardif: Limit dump to this hard interfaace
2239  */
2240 static void
2241 batadv_iv_ogm_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
2242                          struct batadv_priv *bat_priv,
2243                          struct batadv_hard_iface *single_hardif)
2244 {
2245         struct batadv_hard_iface *hard_iface;
2246         int i_hardif = 0;
2247         int i_hardif_s = cb->args[0];
2248         int idx = cb->args[1];
2249         int portid = NETLINK_CB(cb->skb).portid;
2250
2251         rcu_read_lock();
2252         if (single_hardif) {
2253                 if (i_hardif_s == 0) {
2254                         if (batadv_iv_ogm_neigh_dump_hardif(msg, portid,
2255                                                             cb->nlh->nlmsg_seq,
2256                                                             bat_priv,
2257                                                             single_hardif,
2258                                                             &idx) == 0)
2259                                 i_hardif++;
2260                 }
2261         } else {
2262                 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list,
2263                                         list) {
2264                         if (hard_iface->soft_iface != bat_priv->soft_iface)
2265                                 continue;
2266
2267                         if (i_hardif++ < i_hardif_s)
2268                                 continue;
2269
2270                         if (batadv_iv_ogm_neigh_dump_hardif(msg, portid,
2271                                                             cb->nlh->nlmsg_seq,
2272                                                             bat_priv,
2273                                                             hard_iface, &idx)) {
2274                                 i_hardif--;
2275                                 break;
2276                         }
2277                 }
2278         }
2279         rcu_read_unlock();
2280
2281         cb->args[0] = i_hardif;
2282         cb->args[1] = idx;
2283 }
2284
2285 /**
2286  * batadv_iv_ogm_neigh_cmp() - compare the metrics of two neighbors
2287  * @neigh1: the first neighbor object of the comparison
2288  * @if_outgoing1: outgoing interface for the first neighbor
2289  * @neigh2: the second neighbor object of the comparison
2290  * @if_outgoing2: outgoing interface for the second neighbor
2291  *
2292  * Return: a value less, equal to or greater than 0 if the metric via neigh1 is
2293  * lower, the same as or higher than the metric via neigh2
2294  */
2295 static int batadv_iv_ogm_neigh_cmp(struct batadv_neigh_node *neigh1,
2296                                    struct batadv_hard_iface *if_outgoing1,
2297                                    struct batadv_neigh_node *neigh2,
2298                                    struct batadv_hard_iface *if_outgoing2)
2299 {
2300         bool ret;
2301         int diff;
2302
2303         ret = batadv_iv_ogm_neigh_diff(neigh1, if_outgoing1, neigh2,
2304                                        if_outgoing2, &diff);
2305         if (!ret)
2306                 return 0;
2307
2308         return diff;
2309 }
2310
2311 /**
2312  * batadv_iv_ogm_neigh_is_sob() - check if neigh1 is similarly good or better
2313  *  than neigh2 from the metric prospective
2314  * @neigh1: the first neighbor object of the comparison
2315  * @if_outgoing1: outgoing interface for the first neighbor
2316  * @neigh2: the second neighbor object of the comparison
2317  * @if_outgoing2: outgoing interface for the second neighbor
2318  *
2319  * Return: true if the metric via neigh1 is equally good or better than
2320  * the metric via neigh2, false otherwise.
2321  */
2322 static bool
2323 batadv_iv_ogm_neigh_is_sob(struct batadv_neigh_node *neigh1,
2324                            struct batadv_hard_iface *if_outgoing1,
2325                            struct batadv_neigh_node *neigh2,
2326                            struct batadv_hard_iface *if_outgoing2)
2327 {
2328         bool ret;
2329         int diff;
2330
2331         ret = batadv_iv_ogm_neigh_diff(neigh1, if_outgoing1, neigh2,
2332                                        if_outgoing2, &diff);
2333         if (!ret)
2334                 return false;
2335
2336         ret = diff > -BATADV_TQ_SIMILARITY_THRESHOLD;
2337         return ret;
2338 }
2339
2340 static void batadv_iv_iface_enabled(struct batadv_hard_iface *hard_iface)
2341 {
2342         /* begin scheduling originator messages on that interface */
2343         batadv_iv_ogm_schedule(hard_iface);
2344 }
2345
2346 /**
2347  * batadv_iv_init_sel_class() - initialize GW selection class
2348  * @bat_priv: the bat priv with all the soft interface information
2349  */
2350 static void batadv_iv_init_sel_class(struct batadv_priv *bat_priv)
2351 {
2352         /* set default TQ difference threshold to 20 */
2353         atomic_set(&bat_priv->gw.sel_class, 20);
2354 }
2355
2356 static struct batadv_gw_node *
2357 batadv_iv_gw_get_best_gw_node(struct batadv_priv *bat_priv)
2358 {
2359         struct batadv_neigh_node *router;
2360         struct batadv_neigh_ifinfo *router_ifinfo;
2361         struct batadv_gw_node *gw_node, *curr_gw = NULL;
2362         u64 max_gw_factor = 0;
2363         u64 tmp_gw_factor = 0;
2364         u8 max_tq = 0;
2365         u8 tq_avg;
2366         struct batadv_orig_node *orig_node;
2367
2368         rcu_read_lock();
2369         hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) {
2370                 orig_node = gw_node->orig_node;
2371                 router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
2372                 if (!router)
2373                         continue;
2374
2375                 router_ifinfo = batadv_neigh_ifinfo_get(router,
2376                                                         BATADV_IF_DEFAULT);
2377                 if (!router_ifinfo)
2378                         goto next;
2379
2380                 if (!kref_get_unless_zero(&gw_node->refcount))
2381                         goto next;
2382
2383                 tq_avg = router_ifinfo->bat_iv.tq_avg;
2384
2385                 switch (atomic_read(&bat_priv->gw.sel_class)) {
2386                 case 1: /* fast connection */
2387                         tmp_gw_factor = tq_avg * tq_avg;
2388                         tmp_gw_factor *= gw_node->bandwidth_down;
2389                         tmp_gw_factor *= 100 * 100;
2390                         tmp_gw_factor >>= 18;
2391
2392                         if (tmp_gw_factor > max_gw_factor ||
2393                             (tmp_gw_factor == max_gw_factor &&
2394                              tq_avg > max_tq)) {
2395                                 if (curr_gw)
2396                                         batadv_gw_node_put(curr_gw);
2397                                 curr_gw = gw_node;
2398                                 kref_get(&curr_gw->refcount);
2399                         }
2400                         break;
2401
2402                 default: /* 2:  stable connection (use best statistic)
2403                           * 3:  fast-switch (use best statistic but change as
2404                           *     soon as a better gateway appears)
2405                           * XX: late-switch (use best statistic but change as
2406                           *     soon as a better gateway appears which has
2407                           *     $routing_class more tq points)
2408                           */
2409                         if (tq_avg > max_tq) {
2410                                 if (curr_gw)
2411                                         batadv_gw_node_put(curr_gw);
2412                                 curr_gw = gw_node;
2413                                 kref_get(&curr_gw->refcount);
2414                         }
2415                         break;
2416                 }
2417
2418                 if (tq_avg > max_tq)
2419                         max_tq = tq_avg;
2420
2421                 if (tmp_gw_factor > max_gw_factor)
2422                         max_gw_factor = tmp_gw_factor;
2423
2424                 batadv_gw_node_put(gw_node);
2425
2426 next:
2427                 batadv_neigh_node_put(router);
2428                 if (router_ifinfo)
2429                         batadv_neigh_ifinfo_put(router_ifinfo);
2430         }
2431         rcu_read_unlock();
2432
2433         return curr_gw;
2434 }
2435
2436 static bool batadv_iv_gw_is_eligible(struct batadv_priv *bat_priv,
2437                                      struct batadv_orig_node *curr_gw_orig,
2438                                      struct batadv_orig_node *orig_node)
2439 {
2440         struct batadv_neigh_ifinfo *router_orig_ifinfo = NULL;
2441         struct batadv_neigh_ifinfo *router_gw_ifinfo = NULL;
2442         struct batadv_neigh_node *router_gw = NULL;
2443         struct batadv_neigh_node *router_orig = NULL;
2444         u8 gw_tq_avg, orig_tq_avg;
2445         bool ret = false;
2446
2447         /* dynamic re-election is performed only on fast or late switch */
2448         if (atomic_read(&bat_priv->gw.sel_class) <= 2)
2449                 return false;
2450
2451         router_gw = batadv_orig_router_get(curr_gw_orig, BATADV_IF_DEFAULT);
2452         if (!router_gw) {
2453                 ret = true;
2454                 goto out;
2455         }
2456
2457         router_gw_ifinfo = batadv_neigh_ifinfo_get(router_gw,
2458                                                    BATADV_IF_DEFAULT);
2459         if (!router_gw_ifinfo) {
2460                 ret = true;
2461                 goto out;
2462         }
2463
2464         router_orig = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
2465         if (!router_orig)
2466                 goto out;
2467
2468         router_orig_ifinfo = batadv_neigh_ifinfo_get(router_orig,
2469                                                      BATADV_IF_DEFAULT);
2470         if (!router_orig_ifinfo)
2471                 goto out;
2472
2473         gw_tq_avg = router_gw_ifinfo->bat_iv.tq_avg;
2474         orig_tq_avg = router_orig_ifinfo->bat_iv.tq_avg;
2475
2476         /* the TQ value has to be better */
2477         if (orig_tq_avg < gw_tq_avg)
2478                 goto out;
2479
2480         /* if the routing class is greater than 3 the value tells us how much
2481          * greater the TQ value of the new gateway must be
2482          */
2483         if ((atomic_read(&bat_priv->gw.sel_class) > 3) &&
2484             (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw.sel_class)))
2485                 goto out;
2486
2487         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
2488                    "Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n",
2489                    gw_tq_avg, orig_tq_avg);
2490
2491         ret = true;
2492 out:
2493         if (router_gw_ifinfo)
2494                 batadv_neigh_ifinfo_put(router_gw_ifinfo);
2495         if (router_orig_ifinfo)
2496                 batadv_neigh_ifinfo_put(router_orig_ifinfo);
2497         if (router_gw)
2498                 batadv_neigh_node_put(router_gw);
2499         if (router_orig)
2500                 batadv_neigh_node_put(router_orig);
2501
2502         return ret;
2503 }
2504
2505 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2506 /* fails if orig_node has no router */
2507 static int batadv_iv_gw_write_buffer_text(struct batadv_priv *bat_priv,
2508                                           struct seq_file *seq,
2509                                           const struct batadv_gw_node *gw_node)
2510 {
2511         struct batadv_gw_node *curr_gw;
2512         struct batadv_neigh_node *router;
2513         struct batadv_neigh_ifinfo *router_ifinfo = NULL;
2514         int ret = -1;
2515
2516         router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
2517         if (!router)
2518                 goto out;
2519
2520         router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
2521         if (!router_ifinfo)
2522                 goto out;
2523
2524         curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
2525
2526         seq_printf(seq, "%s %pM (%3i) %pM [%10s]: %u.%u/%u.%u MBit\n",
2527                    (curr_gw == gw_node ? "=>" : "  "),
2528                    gw_node->orig_node->orig,
2529                    router_ifinfo->bat_iv.tq_avg, router->addr,
2530                    router->if_incoming->net_dev->name,
2531                    gw_node->bandwidth_down / 10,
2532                    gw_node->bandwidth_down % 10,
2533                    gw_node->bandwidth_up / 10,
2534                    gw_node->bandwidth_up % 10);
2535         ret = seq_has_overflowed(seq) ? -1 : 0;
2536
2537         if (curr_gw)
2538                 batadv_gw_node_put(curr_gw);
2539 out:
2540         if (router_ifinfo)
2541                 batadv_neigh_ifinfo_put(router_ifinfo);
2542         if (router)
2543                 batadv_neigh_node_put(router);
2544         return ret;
2545 }
2546
2547 static void batadv_iv_gw_print(struct batadv_priv *bat_priv,
2548                                struct seq_file *seq)
2549 {
2550         struct batadv_gw_node *gw_node;
2551         int gw_count = 0;
2552
2553         seq_puts(seq,
2554                  "      Gateway      (#/255)           Nexthop [outgoingIF]: advertised uplink bandwidth\n");
2555
2556         rcu_read_lock();
2557         hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) {
2558                 /* fails if orig_node has no router */
2559                 if (batadv_iv_gw_write_buffer_text(bat_priv, seq, gw_node) < 0)
2560                         continue;
2561
2562                 gw_count++;
2563         }
2564         rcu_read_unlock();
2565
2566         if (gw_count == 0)
2567                 seq_puts(seq, "No gateways in range ...\n");
2568 }
2569 #endif
2570
2571 /**
2572  * batadv_iv_gw_dump_entry() - Dump a gateway into a message
2573  * @msg: Netlink message to dump into
2574  * @portid: Port making netlink request
2575  * @cb: Control block containing additional options
2576  * @bat_priv: The bat priv with all the soft interface information
2577  * @gw_node: Gateway to be dumped
2578  *
2579  * Return: Error code, or 0 on success
2580  */
2581 static int batadv_iv_gw_dump_entry(struct sk_buff *msg, u32 portid,
2582                                    struct netlink_callback *cb,
2583                                    struct batadv_priv *bat_priv,
2584                                    struct batadv_gw_node *gw_node)
2585 {
2586         struct batadv_neigh_ifinfo *router_ifinfo = NULL;
2587         struct batadv_neigh_node *router;
2588         struct batadv_gw_node *curr_gw = NULL;
2589         int ret = 0;
2590         void *hdr;
2591
2592         router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
2593         if (!router)
2594                 goto out;
2595
2596         router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
2597         if (!router_ifinfo)
2598                 goto out;
2599
2600         curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
2601
2602         hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2603                           &batadv_netlink_family, NLM_F_MULTI,
2604                           BATADV_CMD_GET_GATEWAYS);
2605         if (!hdr) {
2606                 ret = -ENOBUFS;
2607                 goto out;
2608         }
2609
2610         genl_dump_check_consistent(cb, hdr);
2611
2612         ret = -EMSGSIZE;
2613
2614         if (curr_gw == gw_node)
2615                 if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) {
2616                         genlmsg_cancel(msg, hdr);
2617                         goto out;
2618                 }
2619
2620         if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
2621                     gw_node->orig_node->orig) ||
2622             nla_put_u8(msg, BATADV_ATTR_TQ, router_ifinfo->bat_iv.tq_avg) ||
2623             nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN,
2624                     router->addr) ||
2625             nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
2626                            router->if_incoming->net_dev->name) ||
2627             nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN,
2628                         gw_node->bandwidth_down) ||
2629             nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP,
2630                         gw_node->bandwidth_up)) {
2631                 genlmsg_cancel(msg, hdr);
2632                 goto out;
2633         }
2634
2635         genlmsg_end(msg, hdr);
2636         ret = 0;
2637
2638 out:
2639         if (curr_gw)
2640                 batadv_gw_node_put(curr_gw);
2641         if (router_ifinfo)
2642                 batadv_neigh_ifinfo_put(router_ifinfo);
2643         if (router)
2644                 batadv_neigh_node_put(router);
2645         return ret;
2646 }
2647
2648 /**
2649  * batadv_iv_gw_dump() - Dump gateways into a message
2650  * @msg: Netlink message to dump into
2651  * @cb: Control block containing additional options
2652  * @bat_priv: The bat priv with all the soft interface information
2653  */
2654 static void batadv_iv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb,
2655                               struct batadv_priv *bat_priv)
2656 {
2657         int portid = NETLINK_CB(cb->skb).portid;
2658         struct batadv_gw_node *gw_node;
2659         int idx_skip = cb->args[0];
2660         int idx = 0;
2661
2662         spin_lock_bh(&bat_priv->gw.list_lock);
2663         cb->seq = bat_priv->gw.generation << 1 | 1;
2664
2665         hlist_for_each_entry(gw_node, &bat_priv->gw.gateway_list, list) {
2666                 if (idx++ < idx_skip)
2667                         continue;
2668
2669                 if (batadv_iv_gw_dump_entry(msg, portid, cb, bat_priv,
2670                                             gw_node)) {
2671                         idx_skip = idx - 1;
2672                         goto unlock;
2673                 }
2674         }
2675
2676         idx_skip = idx;
2677 unlock:
2678         spin_unlock_bh(&bat_priv->gw.list_lock);
2679
2680         cb->args[0] = idx_skip;
2681 }
2682
2683 static struct batadv_algo_ops batadv_batman_iv __read_mostly = {
2684         .name = "BATMAN_IV",
2685         .iface = {
2686                 .enable = batadv_iv_ogm_iface_enable,
2687                 .enabled = batadv_iv_iface_enabled,
2688                 .disable = batadv_iv_ogm_iface_disable,
2689                 .update_mac = batadv_iv_ogm_iface_update_mac,
2690                 .primary_set = batadv_iv_ogm_primary_iface_set,
2691         },
2692         .neigh = {
2693                 .cmp = batadv_iv_ogm_neigh_cmp,
2694                 .is_similar_or_better = batadv_iv_ogm_neigh_is_sob,
2695 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2696                 .print = batadv_iv_neigh_print,
2697 #endif
2698                 .dump = batadv_iv_ogm_neigh_dump,
2699         },
2700         .orig = {
2701 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2702                 .print = batadv_iv_ogm_orig_print,
2703 #endif
2704                 .dump = batadv_iv_ogm_orig_dump,
2705         },
2706         .gw = {
2707                 .init_sel_class = batadv_iv_init_sel_class,
2708                 .get_best_gw_node = batadv_iv_gw_get_best_gw_node,
2709                 .is_eligible = batadv_iv_gw_is_eligible,
2710 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
2711                 .print = batadv_iv_gw_print,
2712 #endif
2713                 .dump = batadv_iv_gw_dump,
2714         },
2715 };
2716
2717 /**
2718  * batadv_iv_init() - B.A.T.M.A.N. IV initialization function
2719  *
2720  * Return: 0 on success or negative error number in case of failure
2721  */
2722 int __init batadv_iv_init(void)
2723 {
2724         int ret;
2725
2726         /* batman originator packet */
2727         ret = batadv_recv_handler_register(BATADV_IV_OGM,
2728                                            batadv_iv_ogm_receive);
2729         if (ret < 0)
2730                 goto out;
2731
2732         ret = batadv_algo_register(&batadv_batman_iv);
2733         if (ret < 0)
2734                 goto handler_unregister;
2735
2736         goto out;
2737
2738 handler_unregister:
2739         batadv_recv_handler_unregister(BATADV_IV_OGM);
2740 out:
2741         return ret;
2742 }