1 files changed, 63 insertions, 55 deletions

diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c
index 19499281b695..6efd1d0da54a 100644
--- a/net/batman-adv/routing.c
+++ b/net/batman-adv/routing.c
@@ -130,7 +130,7 @@ out:
 
 static int is_bidirectional_neigh(struct orig_node *orig_node,
                                 struct orig_node *orig_neigh_node,
-                                struct batman_packet *batman_packet,
+                                struct batman_ogm_packet *batman_ogm_packet,
                                 struct hard_iface *if_incoming)
 {
         struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
@@ -209,7 +209,8 @@ static int is_bidirectional_neigh(struct orig_node *orig_node,
                                          TQ_LOCAL_WINDOW_SIZE *
                                          TQ_LOCAL_WINDOW_SIZE);
 
-        batman_packet->tq = ((batman_packet->tq * tq_own * tq_asym_penalty) /
+        batman_ogm_packet->tq = ((batman_ogm_packet->tq * tq_own
+                                                        * tq_asym_penalty) /
                                                 (TQ_MAX_VALUE * TQ_MAX_VALUE));
 
         bat_dbg(DBG_BATMAN, bat_priv,
@@ -218,11 +219,11 @@ static int is_bidirectional_neigh(struct orig_node *orig_node,
                 "real recv = %2i, local tq: %3i, asym_penalty: %3i, "
                 "total tq: %3i\n",
                 orig_node->orig, orig_neigh_node->orig, total_count,
-                neigh_rq_count, tq_own, tq_asym_penalty, batman_packet->tq);
+                neigh_rq_count, tq_own, tq_asym_penalty, batman_ogm_packet->tq);
 
         /* if link has the minimum required transmission quality
          * consider it bidirectional */
-        if (batman_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT)
+        if (batman_ogm_packet->tq >= TQ_TOTAL_BIDRECT_LIMIT)
                 ret = 1;
 
 out:
@@ -321,9 +322,10 @@ out:
 /* copy primary address for bonding */
 static void bonding_save_primary(const struct orig_node *orig_node,
                                  struct orig_node *orig_neigh_node,
-                                 const struct batman_packet *batman_packet)
+                                 const struct batman_ogm_packet
+                                                        *batman_ogm_packet)
 {
-        if (!(batman_packet->flags & PRIMARIES_FIRST_HOP))
+        if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
                 return;
 
         memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN);
@@ -331,7 +333,7 @@ static void bonding_save_primary(const struct orig_node *orig_node,
 
 static void update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
                         const struct ethhdr *ethhdr,
-                        const struct batman_packet *batman_packet,
+                        const struct batman_ogm_packet *batman_ogm_packet,
                         struct hard_iface *if_incoming,
                         const unsigned char *tt_buff, int is_duplicate)
 {
@@ -386,19 +388,19 @@ static void update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
 
         rcu_read_unlock();
 
-        orig_node->flags = batman_packet->flags;
+        orig_node->flags = batman_ogm_packet->flags;
         neigh_node->last_valid = jiffies;
 
         spin_lock_bh(&neigh_node->tq_lock);
         ring_buffer_set(neigh_node->tq_recv,
                         &neigh_node->tq_index,
-                        batman_packet->tq);
+                        batman_ogm_packet->tq);
         neigh_node->tq_avg = ring_buffer_avg(neigh_node->tq_recv);
         spin_unlock_bh(&neigh_node->tq_lock);
 
         if (!is_duplicate) {
-                orig_node->last_ttl = batman_packet->ttl;
-                neigh_node->last_ttl = batman_packet->ttl;
+                orig_node->last_ttl = batman_ogm_packet->ttl;
+                neigh_node->last_ttl = batman_ogm_packet->ttl;
         }
 
         bonding_candidate_add(orig_node, neigh_node);
@@ -437,17 +439,19 @@ static void update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
 update_tt:
         /* I have to check for transtable changes only if the OGM has been
          * sent through a primary interface */
-        if (((batman_packet->orig != ethhdr->h_source) &&
-                                (batman_packet->ttl > 2)) ||
-                                (batman_packet->flags & PRIMARIES_FIRST_HOP))
+        if (((batman_ogm_packet->orig != ethhdr->h_source) &&
+             (batman_ogm_packet->ttl > 2)) ||
+            (batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
                 tt_update_orig(bat_priv, orig_node, tt_buff,
-                               batman_packet->tt_num_changes,
-                               batman_packet->ttvn, batman_packet->tt_crc);
+                               batman_ogm_packet->tt_num_changes,
+                               batman_ogm_packet->ttvn,
+                               batman_ogm_packet->tt_crc);
 
-        if (orig_node->gw_flags != batman_packet->gw_flags)
-                gw_node_update(bat_priv, orig_node, batman_packet->gw_flags);
+        if (orig_node->gw_flags != batman_ogm_packet->gw_flags)
+                gw_node_update(bat_priv, orig_node,
+                               batman_ogm_packet->gw_flags);
 
-        orig_node->gw_flags = batman_packet->gw_flags;
+        orig_node->gw_flags = batman_ogm_packet->gw_flags;
 
         /* restart gateway selection if fast or late switching was enabled */
         if ((orig_node->gw_flags) &&
@@ -500,8 +504,8 @@ static int window_protected(struct bat_priv *bat_priv,
  *     was protected. Caller should drop it.
  */
 static int count_real_packets(const struct ethhdr *ethhdr,
-                               const struct batman_packet *batman_packet,
-                               const struct hard_iface *if_incoming)
+                              const struct batman_ogm_packet *batman_ogm_packet,
+                              const struct hard_iface *if_incoming)
 {
         struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct orig_node *orig_node;
@@ -512,12 +516,12 @@ static int count_real_packets(const struct ethhdr *ethhdr,
         int need_update = 0;
         int set_mark, ret = -1;
 
-        orig_node = get_orig_node(bat_priv, batman_packet->orig);
+        orig_node = get_orig_node(bat_priv, batman_ogm_packet->orig);
         if (!orig_node)
                 return 0;
 
         spin_lock_bh(&orig_node->ogm_cnt_lock);
-        seq_diff = batman_packet->seqno - orig_node->last_real_seqno;
+        seq_diff = batman_ogm_packet->seqno - orig_node->last_real_seqno;
 
         /* signalize caller that the packet is to be dropped. */
         if (window_protected(bat_priv, seq_diff,
@@ -530,7 +534,7 @@ static int count_real_packets(const struct ethhdr *ethhdr,
 
                 is_duplicate |= get_bit_status(tmp_neigh_node->real_bits,
                                                orig_node->last_real_seqno,
-                                               batman_packet->seqno);
+                                               batman_ogm_packet->seqno);
 
                 if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
                     (tmp_neigh_node->if_incoming == if_incoming))
@@ -551,8 +555,8 @@ static int count_real_packets(const struct ethhdr *ethhdr,
         if (need_update) {
                 bat_dbg(DBG_BATMAN, bat_priv,
                         "updating last_seqno: old %d, new %d\n",
-                        orig_node->last_real_seqno, batman_packet->seqno);
-                orig_node->last_real_seqno = batman_packet->seqno;
+                        orig_node->last_real_seqno, batman_ogm_packet->seqno);
+                orig_node->last_real_seqno = batman_ogm_packet->seqno;
         }
 
         ret = is_duplicate;
@@ -564,7 +568,7 @@ out:
 }
 
 void receive_bat_packet(const struct ethhdr *ethhdr,
-                        struct batman_packet *batman_packet,
+                        struct batman_ogm_packet *batman_ogm_packet,
                         const unsigned char *tt_buff,
                         struct hard_iface *if_incoming)
 {
@@ -587,31 +591,31 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
          * it as an additional length.
          *
          * TODO: A more sane solution would be to have a bit in the
-         * batman_packet to detect whether the packet is the last
+         * batman_ogm_packet to detect whether the packet is the last
          * packet in an aggregation.  Here we expect that the padding
          * is always zero (or not 0x01)
          */
-        if (batman_packet->packet_type != BAT_PACKET)
+        if (batman_ogm_packet->packet_type != BAT_OGM)
                 return;
 
         /* could be changed by schedule_own_packet() */
         if_incoming_seqno = atomic_read(&if_incoming->seqno);
 
-        has_directlink_flag = (batman_packet->flags & DIRECTLINK ? 1 : 0);
+        has_directlink_flag = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0);
 
         is_single_hop_neigh = (compare_eth(ethhdr->h_source,
-                                           batman_packet->orig) ? 1 : 0);
+                                           batman_ogm_packet->orig) ? 1 : 0);
 
         bat_dbg(DBG_BATMAN, bat_priv,
                 "Received BATMAN packet via NB: %pM, IF: %s [%pM] "
                 "(from OG: %pM, via prev OG: %pM, seqno %d, ttvn %u, "
                 "crc %u, changes %u, td %d, TTL %d, V %d, IDF %d)\n",
                 ethhdr->h_source, if_incoming->net_dev->name,
-                if_incoming->net_dev->dev_addr, batman_packet->orig,
-                batman_packet->prev_sender, batman_packet->seqno,
-                batman_packet->ttvn, batman_packet->tt_crc,
-                batman_packet->tt_num_changes, batman_packet->tq,
-                batman_packet->ttl, batman_packet->version,
+                if_incoming->net_dev->dev_addr, batman_ogm_packet->orig,
+                batman_ogm_packet->prev_sender, batman_ogm_packet->seqno,
+                batman_ogm_packet->ttvn, batman_ogm_packet->tt_crc,
+                batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq,
+                batman_ogm_packet->ttl, batman_ogm_packet->version,
                 has_directlink_flag);
 
         rcu_read_lock();
@@ -626,11 +630,11 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
                                 hard_iface->net_dev->dev_addr))
                         is_my_addr = 1;
 
-                if (compare_eth(batman_packet->orig,
+                if (compare_eth(batman_ogm_packet->orig,
                                 hard_iface->net_dev->dev_addr))
                         is_my_orig = 1;
 
-                if (compare_eth(batman_packet->prev_sender,
+                if (compare_eth(batman_ogm_packet->prev_sender,
                                 hard_iface->net_dev->dev_addr))
                         is_my_oldorig = 1;
 
@@ -639,10 +643,10 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
         }
         rcu_read_unlock();
 
-        if (batman_packet->version != COMPAT_VERSION) {
+        if (batman_ogm_packet->version != COMPAT_VERSION) {
                 bat_dbg(DBG_BATMAN, bat_priv,
                         "Drop packet: incompatible batman version (%i)\n",
-                        batman_packet->version);
+                        batman_ogm_packet->version);
                 return;
         }
 
@@ -674,13 +678,14 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
                 /* save packet seqno for bidirectional check */
                 if (has_directlink_flag &&
                     compare_eth(if_incoming->net_dev->dev_addr,
-                                batman_packet->orig)) {
+                                batman_ogm_packet->orig)) {
                         offset = if_incoming->if_num * NUM_WORDS;
 
                         spin_lock_bh(&orig_neigh_node->ogm_cnt_lock);
                         word = &(orig_neigh_node->bcast_own[offset]);
                         bit_mark(word,
-                                 if_incoming_seqno - batman_packet->seqno - 2);
+                                 if_incoming_seqno -
+                                                batman_ogm_packet->seqno - 2);
                         orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
                                 bit_packet_count(word);
                         spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);
@@ -699,11 +704,12 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
                 return;
         }
 
-        orig_node = get_orig_node(bat_priv, batman_packet->orig);
+        orig_node = get_orig_node(bat_priv, batman_ogm_packet->orig);
         if (!orig_node)
                 return;
 
-        is_duplicate = count_real_packets(ethhdr, batman_packet, if_incoming);
+        is_duplicate = count_real_packets(ethhdr, batman_ogm_packet,
+                                          if_incoming);
 
         if (is_duplicate == -1) {
                 bat_dbg(DBG_BATMAN, bat_priv,
@@ -712,7 +718,7 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
                 goto out;
         }
 
-        if (batman_packet->tq == 0) {
+        if (batman_ogm_packet->tq == 0) {
                 bat_dbg(DBG_BATMAN, bat_priv,
                         "Drop packet: originator packet with tq equal 0\n");
                 goto out;
@@ -724,8 +730,9 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
 
         /* avoid temporary routing loops */
         if (router && router_router &&
-            (compare_eth(router->addr, batman_packet->prev_sender)) &&
-            !(compare_eth(batman_packet->orig, batman_packet->prev_sender)) &&
+            (compare_eth(router->addr, batman_ogm_packet->prev_sender)) &&
+            !(compare_eth(batman_ogm_packet->orig,
+                          batman_ogm_packet->prev_sender)) &&
             (compare_eth(router->addr, router_router->addr))) {
                 bat_dbg(DBG_BATMAN, bat_priv,
                         "Drop packet: ignoring all rebroadcast packets that "
@@ -752,24 +759,25 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
         }
 
         is_bidirectional = is_bidirectional_neigh(orig_node, orig_neigh_node,
-                                                batman_packet, if_incoming);
+                                                  batman_ogm_packet,
+                                                  if_incoming);
 
-        bonding_save_primary(orig_node, orig_neigh_node, batman_packet);
+        bonding_save_primary(orig_node, orig_neigh_node, batman_ogm_packet);
 
         /* update ranking if it is not a duplicate or has the same
          * seqno and similar ttl as the non-duplicate */
         if (is_bidirectional &&
             (!is_duplicate ||
-             ((orig_node->last_real_seqno == batman_packet->seqno) &&
-              (orig_node->last_ttl - 3 <= batman_packet->ttl))))
-                update_orig(bat_priv, orig_node, ethhdr, batman_packet,
+             ((orig_node->last_real_seqno == batman_ogm_packet->seqno) &&
+              (orig_node->last_ttl - 3 <= batman_ogm_packet->ttl))))
+                update_orig(bat_priv, orig_node, ethhdr, batman_ogm_packet,
                             if_incoming, tt_buff, is_duplicate);
 
         /* is single hop (direct) neighbor */
         if (is_single_hop_neigh) {
 
                 /* mark direct link on incoming interface */
-                schedule_forward_packet(orig_node, ethhdr, batman_packet,
+                schedule_forward_packet(orig_node, ethhdr, batman_ogm_packet,
                                         1, if_incoming);
 
                 bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: "
@@ -792,7 +800,7 @@ void receive_bat_packet(const struct ethhdr *ethhdr,
 
         bat_dbg(DBG_BATMAN, bat_priv,
                 "Forwarding packet: rebroadcast originator packet\n");
-        schedule_forward_packet(orig_node, ethhdr, batman_packet,
+        schedule_forward_packet(orig_node, ethhdr, batman_ogm_packet,
                                 0, if_incoming);
 
 out_neigh:
@@ -814,7 +822,7 @@ int recv_bat_packet(struct sk_buff *skb, struct hard_iface *hard_iface)
         struct ethhdr *ethhdr;
 
         /* drop packet if it has not necessary minimum size */
-        if (unlikely(!pskb_may_pull(skb, sizeof(struct batman_packet))))
+        if (unlikely(!pskb_may_pull(skb, BATMAN_OGM_LEN)))
                 return NET_RX_DROP;
 
         ethhdr = (struct ethhdr *)skb_mac_header(skb);