net/batman-adv/bat_iv_ogm.c

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