batman-adv: improved client announcement mechanism

The client announcement mechanism informs every mesh node in the network
of any connected non-mesh client, in order to find the path towards that
client from any given point in the mesh.

The old implementation was based on the simple idea of appending a data
buffer to each OGM containing all the client MAC addresses the node is
serving. All other nodes can populate their global translation tables
(table which links client MAC addresses to node addresses) using this
MAC address buffer and linking it to the node's address contained in the
OGM. A node that wants to contact a client has to lookup the node the
client is connected to and its address in the global translation table.

It is easy to understand that this implementation suffers from several
issues:
 - big overhead (each and every OGM contains the entire list of
   connected clients)
 - high latencies for client route updates due to long OGM trip time and
   OGM losses

The new implementation addresses these issues by appending client
changes (new client joined or a client left) to the OGM instead of
filling it with all the client addresses each time. In this way nodes
can modify their global tables by means of "updates", thus reducing the
overhead within the OGMs.

To keep the entire network in sync each node maintains a translation
table version number (ttvn) and a translation table checksum. These
values are spread with the OGM to allow all the network participants to
determine whether or not they need to update their translation table
information.

When a translation table lookup is performed in order to send a packet
to a client attached to another node, the destination's ttvn is added to
the payload packet. Forwarding nodes can compare the packet's ttvn with
their destination's ttvn (this node could have a fresher information
than the source) and re-route the packet if necessary. This greatly
reduces the packet loss of clients roaming from one AP to the next.

Signed-off-by: Antonio Quartulli <ordex@autistici.org>
Signed-off-by: Marek Lindner <lindner_marek@yahoo.de>
Signed-off-by: Sven Eckelmann <sven@narfation.org>

1 files changed, 67 insertions, 20 deletions

diff --git a/net/batman-adv/send.c b/net/batman-adv/send.c
index be0d581a62a9..6b1407570e44 100644
--- a/net/batman-adv/send.c
+++ b/net/batman-adv/send.c
@@ -120,7 +120,7 @@ static void send_packet_to_if(struct forw_packet *forw_packet,
         /* adjust all flags and log packets */
         while (aggregated_packet(buff_pos,
                                  forw_packet->packet_len,
-                                 batman_packet->num_tt)) {
+                                 batman_packet->tt_num_changes)) {
 
                 /* we might have aggregated direct link packets with an
                  * ordinary base packet */
@@ -135,17 +135,17 @@ static void send_packet_to_if(struct forw_packet *forw_packet,
                                                             "Forwarding"));
                 bat_dbg(DBG_BATMAN, bat_priv,
                         "%s %spacket (originator %pM, seqno %d, TQ %d, TTL %d,"
-                        " IDF %s) on interface %s [%pM]\n",
+                        " IDF %s, hvn %d) on interface %s [%pM]\n",
                         fwd_str, (packet_num > 0 ? "aggregated " : ""),
                         batman_packet->orig, ntohl(batman_packet->seqno),
                         batman_packet->tq, batman_packet->ttl,
                         (batman_packet->flags & DIRECTLINK ?
                          "on" : "off"),
-                        hard_iface->net_dev->name,
+                        batman_packet->ttvn, hard_iface->net_dev->name,
                         hard_iface->net_dev->dev_addr);
 
                 buff_pos += sizeof(*batman_packet) +
-                        (batman_packet->num_tt * ETH_ALEN);
+                        tt_len(batman_packet->tt_num_changes);
                 packet_num++;
                 batman_packet = (struct batman_packet *)
                         (forw_packet->skb->data + buff_pos);
@@ -213,25 +213,18 @@ static void send_packet(struct forw_packet *forw_packet)
         rcu_read_unlock();
 }
 
-static void rebuild_batman_packet(struct bat_priv *bat_priv,
-                                  struct hard_iface *hard_iface)
+static void realloc_packet_buffer(struct hard_iface *hard_iface,
+                                int new_len)
 {
-        int new_len;
         unsigned char *new_buff;
         struct batman_packet *batman_packet;
 
-        new_len = sizeof(*batman_packet) + (bat_priv->num_local_tt * ETH_ALEN);
         new_buff = kmalloc(new_len, GFP_ATOMIC);
 
         /* keep old buffer if kmalloc should fail */
         if (new_buff) {
                 memcpy(new_buff, hard_iface->packet_buff,
                        sizeof(*batman_packet));
-                batman_packet = (struct batman_packet *)new_buff;
-
-                batman_packet->num_tt = tt_local_fill_buffer(bat_priv,
-                                        new_buff + sizeof(*batman_packet),
-                                        new_len - sizeof(*batman_packet));
 
                 kfree(hard_iface->packet_buff);
                 hard_iface->packet_buff = new_buff;
@@ -239,6 +232,46 @@ static void rebuild_batman_packet(struct bat_priv *bat_priv,
         }
 }
 
+/* when calling this function (hard_iface == primary_if) has to be true */
+static void prepare_packet_buffer(struct bat_priv *bat_priv,
+                                  struct hard_iface *hard_iface)
+{
+        int new_len;
+        struct batman_packet *batman_packet;
+
+        new_len = BAT_PACKET_LEN +
+                  tt_len((uint8_t)atomic_read(&bat_priv->tt_local_changes));
+
+        /* if we have too many changes for one packet don't send any
+         * and wait for the tt table request which will be fragmented */
+        if (new_len > hard_iface->soft_iface->mtu)
+                new_len = BAT_PACKET_LEN;
+
+        realloc_packet_buffer(hard_iface, new_len);
+        batman_packet = (struct batman_packet *)hard_iface->packet_buff;
+
+        atomic_set(&bat_priv->tt_crc, tt_local_crc(bat_priv));
+
+        /* reset the sending counter */
+        atomic_set(&bat_priv->tt_ogm_append_cnt, TT_OGM_APPEND_MAX);
+
+        batman_packet->tt_num_changes = tt_changes_fill_buffer(bat_priv,
+                                hard_iface->packet_buff + BAT_PACKET_LEN,
+                                hard_iface->packet_len - BAT_PACKET_LEN);
+
+}
+
+static void reset_packet_buffer(struct bat_priv *bat_priv,
+        struct hard_iface *hard_iface)
+{
+        struct batman_packet *batman_packet;
+
+        realloc_packet_buffer(hard_iface, BAT_PACKET_LEN);
+
+        batman_packet = (struct batman_packet *)hard_iface->packet_buff;
+        batman_packet->tt_num_changes = 0;
+}
+
 void schedule_own_packet(struct hard_iface *hard_iface)
 {
         struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
@@ -264,14 +297,22 @@ void schedule_own_packet(struct hard_iface *hard_iface)
         if (hard_iface->if_status == IF_TO_BE_ACTIVATED)
                 hard_iface->if_status = IF_ACTIVE;
 
-        /* if local tt has changed and interface is a primary interface */
-        if ((atomic_read(&bat_priv->tt_local_changed)) &&
-            (hard_iface == primary_if))
-                rebuild_batman_packet(bat_priv, hard_iface);
+        if (hard_iface == primary_if) {
+                /* if at least one change happened */
+                if (atomic_read(&bat_priv->tt_local_changes) > 0) {
+                        prepare_packet_buffer(bat_priv, hard_iface);
+                        /* Increment the TTVN only once per OGM interval */
+                        atomic_inc(&bat_priv->ttvn);
+                }
+
+                /* if the changes have been sent enough times */
+                if (!atomic_dec_not_zero(&bat_priv->tt_ogm_append_cnt))
+                        reset_packet_buffer(bat_priv, hard_iface);
+        }
 
         /**
          * NOTE: packet_buff might just have been re-allocated in
-         * rebuild_batman_packet()
+         * prepare_packet_buffer() or in reset_packet_buffer()
          */
         batman_packet = (struct batman_packet *)hard_iface->packet_buff;
 
@@ -279,6 +320,9 @@ void schedule_own_packet(struct hard_iface *hard_iface)
         batman_packet->seqno =
                 htonl((uint32_t)atomic_read(&hard_iface->seqno));
 
+        batman_packet->ttvn = atomic_read(&bat_priv->ttvn);
+        batman_packet->tt_crc = htons((uint16_t)atomic_read(&bat_priv->tt_crc));
+
         if (vis_server == VIS_TYPE_SERVER_SYNC)
                 batman_packet->flags |= VIS_SERVER;
         else
@@ -307,13 +351,14 @@ void schedule_own_packet(struct hard_iface *hard_iface)
 void schedule_forward_packet(struct orig_node *orig_node,
                              const struct ethhdr *ethhdr,
                              struct batman_packet *batman_packet,
-                             int directlink, int tt_buff_len,
+                             int directlink,
                              struct hard_iface *if_incoming)
 {
         struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct neigh_node *router;
         uint8_t in_tq, in_ttl, tq_avg = 0;
         unsigned long send_time;
+        uint8_t tt_num_changes;
 
         if (batman_packet->ttl <= 1) {
                 bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
@@ -324,6 +369,7 @@ void schedule_forward_packet(struct orig_node *orig_node,
 
         in_tq = batman_packet->tq;
         in_ttl = batman_packet->ttl;
+        tt_num_changes = batman_packet->tt_num_changes;
 
         batman_packet->ttl--;
         memcpy(batman_packet->prev_sender, ethhdr->h_source, ETH_ALEN);
@@ -356,6 +402,7 @@ void schedule_forward_packet(struct orig_node *orig_node,
                 batman_packet->ttl);
 
         batman_packet->seqno = htonl(batman_packet->seqno);
+        batman_packet->tt_crc = htons(batman_packet->tt_crc);
 
         /* switch of primaries first hop flag when forwarding */
         batman_packet->flags &= ~PRIMARIES_FIRST_HOP;
@@ -367,7 +414,7 @@ void schedule_forward_packet(struct orig_node *orig_node,
         send_time = forward_send_time();
         add_bat_packet_to_list(bat_priv,
                                (unsigned char *)batman_packet,
-                               sizeof(*batman_packet) + tt_buff_len,
+                               sizeof(*batman_packet) + tt_len(tt_num_changes),
                                if_incoming, 0, send_time);
 }