1 files changed, 251 insertions, 239 deletions

diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index 94859d45ed6e..ca6466574c46 100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -28,11 +28,11 @@
 #include "send.h"
 #include "bat_algo.h"
 
-static struct neigh_node *bat_iv_ogm_neigh_new(struct hard_iface *hard_iface,
-                                               const uint8_t *neigh_addr,
-                                               struct orig_node *orig_node,
-                                               struct orig_node *orig_neigh,
-                                               __be32 seqno)
+static struct neigh_node *batadv_iv_ogm_neigh_new(struct hard_iface *hard_iface,
+                                                  const uint8_t *neigh_addr,
+                                                  struct orig_node *orig_node,
+                                                  struct orig_node *orig_neigh,
+                                                  __be32 seqno)
 {
         struct neigh_node *neigh_node;
 
@@ -54,7 +54,7 @@ out:
         return neigh_node;
 }
 
-static int bat_iv_ogm_iface_enable(struct hard_iface *hard_iface)
+static int batadv_iv_ogm_iface_enable(struct hard_iface *hard_iface)
 {
         struct batman_ogm_packet *batman_ogm_packet;
         uint32_t random_seqno;
@@ -85,13 +85,13 @@ out:
         return res;
 }
 
-static void bat_iv_ogm_iface_disable(struct hard_iface *hard_iface)
+static void batadv_iv_ogm_iface_disable(struct hard_iface *hard_iface)
 {
         kfree(hard_iface->packet_buff);
         hard_iface->packet_buff = NULL;
 }
 
-static void bat_iv_ogm_iface_update_mac(struct hard_iface *hard_iface)
+static void batadv_iv_ogm_iface_update_mac(struct hard_iface *hard_iface)
 {
         struct batman_ogm_packet *batman_ogm_packet;
 
@@ -102,7 +102,7 @@ static void bat_iv_ogm_iface_update_mac(struct hard_iface *hard_iface)
                hard_iface->net_dev->dev_addr, ETH_ALEN);
 }
 
-static void bat_iv_ogm_primary_iface_set(struct hard_iface *hard_iface)
+static void batadv_iv_ogm_primary_iface_set(struct hard_iface *hard_iface)
 {
         struct batman_ogm_packet *batman_ogm_packet;
 
@@ -112,7 +112,8 @@ static void bat_iv_ogm_primary_iface_set(struct hard_iface *hard_iface)
 }
 
 /* when do we schedule our own ogm to be sent */
-static unsigned long bat_iv_ogm_emit_send_time(const struct bat_priv *bat_priv)
+static unsigned long
+batadv_iv_ogm_emit_send_time(const struct bat_priv *bat_priv)
 {
         return jiffies + msecs_to_jiffies(
                    atomic_read(&bat_priv->orig_interval) -
@@ -120,21 +121,21 @@ static unsigned long bat_iv_ogm_emit_send_time(const struct bat_priv *bat_priv)
 }
 
 /* when do we schedule a ogm packet to be sent */
-static unsigned long bat_iv_ogm_fwd_send_time(void)
+static unsigned long batadv_iv_ogm_fwd_send_time(void)
 {
         return jiffies + msecs_to_jiffies(random32() % (JITTER/2));
 }
 
 /* apply hop penalty for a normal link */
-static uint8_t hop_penalty(uint8_t tq, const struct bat_priv *bat_priv)
+static uint8_t batadv_hop_penalty(uint8_t tq, const struct bat_priv *bat_priv)
 {
         int hop_penalty = atomic_read(&bat_priv->hop_penalty);
         return (tq * (TQ_MAX_VALUE - hop_penalty)) / (TQ_MAX_VALUE);
 }
 
 /* is there another aggregated packet here? */
-static int bat_iv_ogm_aggr_packet(int buff_pos, int packet_len,
-                                  int tt_num_changes)
+static int batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len,
+                                     int tt_num_changes)
 {
         int next_buff_pos = 0;
 
@@ -146,7 +147,7 @@ static int bat_iv_ogm_aggr_packet(int buff_pos, int packet_len,
 }
 
 /* send a batman ogm to a given interface */
-static void bat_iv_ogm_send_to_if(struct forw_packet *forw_packet,
+static void batadv_iv_ogm_send_to_if(struct forw_packet *forw_packet,
                                   struct hard_iface *hard_iface)
 {
         struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
@@ -164,8 +165,8 @@ static void bat_iv_ogm_send_to_if(struct forw_packet *forw_packet,
         batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data;
 
         /* adjust all flags and log packets */
-        while (bat_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
-                                      batman_ogm_packet->tt_num_changes)) {
+        while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
+                                         batman_ogm_packet->tt_num_changes)) {
 
                 /* we might have aggregated direct link packets with an
                  * ordinary base packet
@@ -179,16 +180,16 @@ static void bat_iv_ogm_send_to_if(struct forw_packet *forw_packet,
                 fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ?
                                                             "Sending own" :
                                                             "Forwarding"));
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s, ttvn %d) on interface %s [%pM]\n",
-                        fwd_str, (packet_num > 0 ? "aggregated " : ""),
-                        batman_ogm_packet->orig,
-                        ntohl(batman_ogm_packet->seqno),
-                        batman_ogm_packet->tq, batman_ogm_packet->header.ttl,
-                        (batman_ogm_packet->flags & DIRECTLINK ?
-                         "on" : "off"),
-                        batman_ogm_packet->ttvn, hard_iface->net_dev->name,
-                        hard_iface->net_dev->dev_addr);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s, ttvn %d) on interface %s [%pM]\n",
+                           fwd_str, (packet_num > 0 ? "aggregated " : ""),
+                           batman_ogm_packet->orig,
+                           ntohl(batman_ogm_packet->seqno),
+                           batman_ogm_packet->tq, batman_ogm_packet->header.ttl,
+                           (batman_ogm_packet->flags & DIRECTLINK ?
+                            "on" : "off"),
+                           batman_ogm_packet->ttvn, hard_iface->net_dev->name,
+                           hard_iface->net_dev->dev_addr);
 
                 buff_pos += BATMAN_OGM_HLEN;
                 buff_pos += batadv_tt_len(batman_ogm_packet->tt_num_changes);
@@ -208,7 +209,7 @@ static void bat_iv_ogm_send_to_if(struct forw_packet *forw_packet,
 }
 
 /* send a batman ogm packet */
-static void bat_iv_ogm_emit(struct forw_packet *forw_packet)
+static void batadv_iv_ogm_emit(struct forw_packet *forw_packet)
 {
         struct hard_iface *hard_iface;
         struct net_device *soft_iface;
@@ -232,7 +233,7 @@ static void bat_iv_ogm_emit(struct forw_packet *forw_packet)
         if (forw_packet->if_incoming->if_status != IF_ACTIVE)
                 goto out;
 
-        primary_if = primary_if_get_selected(bat_priv);
+        primary_if = batadv_primary_if_get_selected(bat_priv);
         if (!primary_if)
                 goto out;
 
@@ -243,14 +244,14 @@ static void bat_iv_ogm_emit(struct forw_packet *forw_packet)
             (forw_packet->own && (forw_packet->if_incoming != primary_if))) {
 
                 /* FIXME: what about aggregated packets ? */
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "%s packet (originator %pM, seqno %u, TTL %d) on interface %s [%pM]\n",
-                        (forw_packet->own ? "Sending own" : "Forwarding"),
-                        batman_ogm_packet->orig,
-                        ntohl(batman_ogm_packet->seqno),
-                        batman_ogm_packet->header.ttl,
-                        forw_packet->if_incoming->net_dev->name,
-                        forw_packet->if_incoming->net_dev->dev_addr);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "%s packet (originator %pM, seqno %u, TTL %d) on interface %s [%pM]\n",
+                           (forw_packet->own ? "Sending own" : "Forwarding"),
+                           batman_ogm_packet->orig,
+                           ntohl(batman_ogm_packet->seqno),
+                           batman_ogm_packet->header.ttl,
+                           forw_packet->if_incoming->net_dev->name,
+                           forw_packet->if_incoming->net_dev->dev_addr);
 
                 /* skb is only used once and than forw_packet is free'd */
                 batadv_send_skb_packet(forw_packet->skb,
@@ -267,23 +268,23 @@ static void bat_iv_ogm_emit(struct forw_packet *forw_packet)
                 if (hard_iface->soft_iface != soft_iface)
                         continue;
 
-                bat_iv_ogm_send_to_if(forw_packet, hard_iface);
+                batadv_iv_ogm_send_to_if(forw_packet, hard_iface);
         }
         rcu_read_unlock();
 
 out:
         if (primary_if)
-                hardif_free_ref(primary_if);
+                batadv_hardif_free_ref(primary_if);
 }
 
 /* return true if new_packet can be aggregated with forw_packet */
-static bool bat_iv_ogm_can_aggregate(const struct batman_ogm_packet
-                                                        *new_batman_ogm_packet,
-                                     struct bat_priv *bat_priv,
-                                     int packet_len, unsigned long send_time,
-                                     bool directlink,
-                                     const struct hard_iface *if_incoming,
-                                     const struct forw_packet *forw_packet)
+static bool
+batadv_iv_ogm_can_aggregate(const struct batman_ogm_packet *new_bat_ogm_packet,
+                            struct bat_priv *bat_priv,
+                            int packet_len, unsigned long send_time,
+                            bool directlink,
+                            const struct hard_iface *if_incoming,
+                            const struct forw_packet *forw_packet)
 {
         struct batman_ogm_packet *batman_ogm_packet;
         int aggregated_bytes = forw_packet->packet_len + packet_len;
@@ -311,7 +312,7 @@ static bool bat_iv_ogm_can_aggregate(const struct batman_ogm_packet
                  *    a "global" packet as well as the base
                  *    packet
                  */
-                primary_if = primary_if_get_selected(bat_priv);
+                primary_if = batadv_primary_if_get_selected(bat_priv);
                 if (!primary_if)
                         goto out;
 
@@ -335,7 +336,7 @@ static bool bat_iv_ogm_can_aggregate(const struct batman_ogm_packet
                  * interface only - we still can aggregate
                  */
                 if ((directlink) &&
-                    (new_batman_ogm_packet->header.ttl == 1) &&
+                    (new_bat_ogm_packet->header.ttl == 1) &&
                     (forw_packet->if_incoming == if_incoming) &&
 
                     /* packets from direct neighbors or
@@ -352,16 +353,16 @@ static bool bat_iv_ogm_can_aggregate(const struct batman_ogm_packet
 
 out:
         if (primary_if)
-                hardif_free_ref(primary_if);
+                batadv_hardif_free_ref(primary_if);
         return res;
 }
 
 /* create a new aggregated packet and add this packet to it */
-static void bat_iv_ogm_aggregate_new(const unsigned char *packet_buff,
-                                     int packet_len, unsigned long send_time,
-                                     bool direct_link,
-                                     struct hard_iface *if_incoming,
-                                     int own_packet)
+static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
+                                        int packet_len, unsigned long send_time,
+                                        bool direct_link,
+                                        struct hard_iface *if_incoming,
+                                        int own_packet)
 {
         struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct forw_packet *forw_packet_aggr;
@@ -373,8 +374,8 @@ static void bat_iv_ogm_aggregate_new(const unsigned char *packet_buff,
         /* own packet should always be scheduled */
         if (!own_packet) {
                 if (!atomic_dec_not_zero(&bat_priv->batman_queue_left)) {
-                        bat_dbg(DBG_BATMAN, bat_priv,
-                                "batman packet queue full\n");
+                        batadv_dbg(DBG_BATMAN, bat_priv,
+                                   "batman packet queue full\n");
                         goto out;
                 }
         }
@@ -431,13 +432,13 @@ static void bat_iv_ogm_aggregate_new(const unsigned char *packet_buff,
 
         return;
 out:
-        hardif_free_ref(if_incoming);
+        batadv_hardif_free_ref(if_incoming);
 }
 
 /* aggregate a new packet into the existing ogm packet */
-static void bat_iv_ogm_aggregate(struct forw_packet *forw_packet_aggr,
-                                 const unsigned char *packet_buff,
-                                 int packet_len, bool direct_link)
+static void batadv_iv_ogm_aggregate(struct forw_packet *forw_packet_aggr,
+                                    const unsigned char *packet_buff,
+                                    int packet_len, bool direct_link)
 {
         unsigned char *skb_buff;
 
@@ -452,10 +453,11 @@ static void bat_iv_ogm_aggregate(struct forw_packet *forw_packet_aggr,
                         (1 << forw_packet_aggr->num_packets);
 }
 
-static void bat_iv_ogm_queue_add(struct bat_priv *bat_priv,
-                                 unsigned char *packet_buff,
-                                 int packet_len, struct hard_iface *if_incoming,
-                                 int own_packet, unsigned long send_time)
+static void batadv_iv_ogm_queue_add(struct bat_priv *bat_priv,
+                                    unsigned char *packet_buff,
+                                    int packet_len,
+                                    struct hard_iface *if_incoming,
+                                    int own_packet, unsigned long send_time)
 {
         /* _aggr -> pointer to the packet we want to aggregate with
          * _pos -> pointer to the position in the queue
@@ -474,11 +476,11 @@ static void bat_iv_ogm_queue_add(struct bat_priv *bat_priv,
         if ((atomic_read(&bat_priv->aggregated_ogms)) && (!own_packet)) {
                 hlist_for_each_entry(forw_packet_pos, tmp_node,
                                      &bat_priv->forw_bat_list, list) {
-                        if (bat_iv_ogm_can_aggregate(batman_ogm_packet,
-                                                     bat_priv, packet_len,
-                                                     send_time, direct_link,
-                                                     if_incoming,
-                                                     forw_packet_pos)) {
+                        if (batadv_iv_ogm_can_aggregate(batman_ogm_packet,
+                                                        bat_priv, packet_len,
+                                                        send_time, direct_link,
+                                                        if_incoming,
+                                                        forw_packet_pos)) {
                                 forw_packet_aggr = forw_packet_pos;
                                 break;
                         }
@@ -500,28 +502,28 @@ static void bat_iv_ogm_queue_add(struct bat_priv *bat_priv,
                     (atomic_read(&bat_priv->aggregated_ogms)))
                         send_time += msecs_to_jiffies(MAX_AGGREGATION_MS);
 
-                bat_iv_ogm_aggregate_new(packet_buff, packet_len,
-                                         send_time, direct_link,
-                                         if_incoming, own_packet);
+                batadv_iv_ogm_aggregate_new(packet_buff, packet_len,
+                                            send_time, direct_link,
+                                            if_incoming, own_packet);
         } else {
-                bat_iv_ogm_aggregate(forw_packet_aggr, packet_buff,
-                                     packet_len, direct_link);
+                batadv_iv_ogm_aggregate(forw_packet_aggr, packet_buff,
+                                        packet_len, direct_link);
                 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
         }
 }
 
-static void bat_iv_ogm_forward(struct orig_node *orig_node,
-                               const struct ethhdr *ethhdr,
-                               struct batman_ogm_packet *batman_ogm_packet,
-                               bool is_single_hop_neigh,
-                               bool is_from_best_next_hop,
-                               struct hard_iface *if_incoming)
+static void batadv_iv_ogm_forward(struct orig_node *orig_node,
+                                  const struct ethhdr *ethhdr,
+                                  struct batman_ogm_packet *batman_ogm_packet,
+                                  bool is_single_hop_neigh,
+                                  bool is_from_best_next_hop,
+                                  struct hard_iface *if_incoming)
 {
         struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         uint8_t tt_num_changes;
 
         if (batman_ogm_packet->header.ttl <= 1) {
-                bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
+                batadv_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
                 return;
         }
 
@@ -544,11 +546,12 @@ static void bat_iv_ogm_forward(struct orig_node *orig_node,
         memcpy(batman_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN);
 
         /* apply hop penalty */
-        batman_ogm_packet->tq = hop_penalty(batman_ogm_packet->tq, bat_priv);
+        batman_ogm_packet->tq = batadv_hop_penalty(batman_ogm_packet->tq,
+                                                   bat_priv);
 
-        bat_dbg(DBG_BATMAN, bat_priv,
-                "Forwarding packet: tq: %i, ttl: %i\n",
-                batman_ogm_packet->tq, batman_ogm_packet->header.ttl);
+        batadv_dbg(DBG_BATMAN, bat_priv,
+                   "Forwarding packet: tq: %i, ttl: %i\n",
+                   batman_ogm_packet->tq, batman_ogm_packet->header.ttl);
 
         /* switch of primaries first hop flag when forwarding */
         batman_ogm_packet->flags &= ~PRIMARIES_FIRST_HOP;
@@ -557,12 +560,12 @@ static void bat_iv_ogm_forward(struct orig_node *orig_node,
         else
                 batman_ogm_packet->flags &= ~DIRECTLINK;
 
-        bat_iv_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet,
-                             BATMAN_OGM_HLEN + batadv_tt_len(tt_num_changes),
-                             if_incoming, 0, bat_iv_ogm_fwd_send_time());
+        batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet,
+                                BATMAN_OGM_HLEN + batadv_tt_len(tt_num_changes),
+                                if_incoming, 0, batadv_iv_ogm_fwd_send_time());
 }
 
-static void bat_iv_ogm_schedule(struct hard_iface *hard_iface)
+static void batadv_iv_ogm_schedule(struct hard_iface *hard_iface)
 {
         struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
         struct batman_ogm_packet *batman_ogm_packet;
@@ -570,7 +573,7 @@ static void bat_iv_ogm_schedule(struct hard_iface *hard_iface)
         int vis_server, tt_num_changes = 0;
 
         vis_server = atomic_read(&bat_priv->vis_mode);
-        primary_if = primary_if_get_selected(bat_priv);
+        primary_if = batadv_primary_if_get_selected(bat_priv);
 
         if (hard_iface == primary_if)
                 tt_num_changes = batadv_tt_append_diff(bat_priv,
@@ -603,38 +606,40 @@ static void bat_iv_ogm_schedule(struct hard_iface *hard_iface)
                 batman_ogm_packet->gw_flags = NO_FLAGS;
 
         batadv_slide_own_bcast_window(hard_iface);
-        bat_iv_ogm_queue_add(bat_priv, hard_iface->packet_buff,
-                             hard_iface->packet_len, hard_iface, 1,
-                             bat_iv_ogm_emit_send_time(bat_priv));
+        batadv_iv_ogm_queue_add(bat_priv, hard_iface->packet_buff,
+                                hard_iface->packet_len, hard_iface, 1,
+                                batadv_iv_ogm_emit_send_time(bat_priv));
 
         if (primary_if)
-                hardif_free_ref(primary_if);
+                batadv_hardif_free_ref(primary_if);
 }
 
-static void bat_iv_ogm_orig_update(struct bat_priv *bat_priv,
-                                   struct orig_node *orig_node,
-                                   const struct ethhdr *ethhdr,
-                                   const struct batman_ogm_packet
-                                                        *batman_ogm_packet,
-                                   struct hard_iface *if_incoming,
-                                   const unsigned char *tt_buff,
-                                   int is_duplicate)
+static void
+batadv_iv_ogm_orig_update(struct bat_priv *bat_priv,
+                          struct orig_node *orig_node,
+                          const struct ethhdr *ethhdr,
+                          const struct batman_ogm_packet *batman_ogm_packet,
+                          struct hard_iface *if_incoming,
+                          const unsigned char *tt_buff,
+                          int is_duplicate)
 {
         struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL;
         struct neigh_node *router = NULL;
         struct orig_node *orig_node_tmp;
         struct hlist_node *node;
         uint8_t bcast_own_sum_orig, bcast_own_sum_neigh;
+        uint8_t *neigh_addr;
 
-        bat_dbg(DBG_BATMAN, bat_priv,
-                "update_originator(): Searching and updating originator entry of received packet\n");
+        batadv_dbg(DBG_BATMAN, bat_priv,
+                   "update_originator(): Searching and updating originator entry of received packet\n");
 
         rcu_read_lock();
         hlist_for_each_entry_rcu(tmp_neigh_node, node,
                                  &orig_node->neigh_list, list) {
-                if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
-                    (tmp_neigh_node->if_incoming == if_incoming) &&
-                     atomic_inc_not_zero(&tmp_neigh_node->refcount)) {
+                neigh_addr = tmp_neigh_node->addr;
+                if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
+                    tmp_neigh_node->if_incoming == if_incoming &&
+                    atomic_inc_not_zero(&tmp_neigh_node->refcount)) {
                         if (neigh_node)
                                 batadv_neigh_node_free_ref(neigh_node);
                         neigh_node = tmp_neigh_node;
@@ -659,16 +664,17 @@ static void bat_iv_ogm_orig_update(struct bat_priv *bat_priv,
                 if (!orig_tmp)
                         goto unlock;
 
-                neigh_node = bat_iv_ogm_neigh_new(if_incoming, ethhdr->h_source,
-                                                  orig_node, orig_tmp,
-                                                  batman_ogm_packet->seqno);
+                neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
+                                                     ethhdr->h_source,
+                                                     orig_node, orig_tmp,
+                                                     batman_ogm_packet->seqno);
 
                 batadv_orig_node_free_ref(orig_tmp);
                 if (!neigh_node)
                         goto unlock;
         } else
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Updating existing last-hop neighbor of originator\n");
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Updating existing last-hop neighbor of originator\n");
 
         rcu_read_unlock();
 
@@ -757,10 +763,10 @@ out:
                 batadv_neigh_node_free_ref(router);
 }
 
-static int bat_iv_ogm_calc_tq(struct orig_node *orig_node,
-                              struct orig_node *orig_neigh_node,
-                              struct batman_ogm_packet *batman_ogm_packet,
-                              struct hard_iface *if_incoming)
+static int batadv_iv_ogm_calc_tq(struct orig_node *orig_node,
+                                 struct orig_node *orig_neigh_node,
+                                 struct batman_ogm_packet *batman_ogm_packet,
+                                 struct hard_iface *if_incoming)
 {
         struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct neigh_node *neigh_node = NULL, *tmp_neigh_node;
@@ -774,7 +780,8 @@ static int bat_iv_ogm_calc_tq(struct orig_node *orig_node,
         hlist_for_each_entry_rcu(tmp_neigh_node, node,
                                  &orig_neigh_node->neigh_list, list) {
 
-                if (!compare_eth(tmp_neigh_node->addr, orig_neigh_node->orig))
+                if (!batadv_compare_eth(tmp_neigh_node->addr,
+                                        orig_neigh_node->orig))
                         continue;
 
                 if (tmp_neigh_node->if_incoming != if_incoming)
@@ -789,11 +796,11 @@ static int bat_iv_ogm_calc_tq(struct orig_node *orig_node,
         rcu_read_unlock();
 
         if (!neigh_node)
-                neigh_node = bat_iv_ogm_neigh_new(if_incoming,
-                                                  orig_neigh_node->orig,
-                                                  orig_neigh_node,
-                                                  orig_neigh_node,
-                                                  batman_ogm_packet->seqno);
+                neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
+                                                     orig_neigh_node->orig,
+                                                     orig_neigh_node,
+                                                     orig_neigh_node,
+                                                     batman_ogm_packet->seqno);
 
         if (!neigh_node)
                 goto out;
@@ -844,10 +851,11 @@ static int bat_iv_ogm_calc_tq(struct orig_node *orig_node,
                                                         * tq_asym_penalty) /
                                                 (TQ_MAX_VALUE * TQ_MAX_VALUE));
 
-        bat_dbg(DBG_BATMAN, bat_priv,
-                "bidirectional: orig = %-15pM neigh = %-15pM => own_bcast = %2i, 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_ogm_packet->tq);
+        batadv_dbg(DBG_BATMAN, bat_priv,
+                   "bidirectional: orig = %-15pM neigh = %-15pM => own_bcast = %2i, 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_ogm_packet->tq);
 
         /* if link has the minimum required transmission quality
          * consider it bidirectional
@@ -869,10 +877,10 @@ out:
  *  -1 the packet is old and has been received while the seqno window
  *     was protected. Caller should drop it.
  */
-static int bat_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
-                                    const struct batman_ogm_packet
-                                                        *batman_ogm_packet,
-                                    const struct hard_iface *if_incoming)
+static int
+batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
+                            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;
@@ -883,6 +891,7 @@ static int bat_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
         int need_update = 0;
         int set_mark, ret = -1;
         uint32_t seqno = ntohl(batman_ogm_packet->seqno);
+        uint8_t *neigh_addr;
 
         orig_node = batadv_get_orig_node(bat_priv, batman_ogm_packet->orig);
         if (!orig_node)
@@ -901,12 +910,13 @@ static int bat_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
         hlist_for_each_entry_rcu(tmp_neigh_node, node,
                                  &orig_node->neigh_list, list) {
 
-                is_duplicate |= bat_test_bit(tmp_neigh_node->real_bits,
-                                             orig_node->last_real_seqno,
-                                             seqno);
+                is_duplicate |= batadv_test_bit(tmp_neigh_node->real_bits,
+                                                orig_node->last_real_seqno,
+                                                seqno);
 
-                if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&
-                    (tmp_neigh_node->if_incoming == if_incoming))
+                neigh_addr = tmp_neigh_node->addr;
+                if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
+                    tmp_neigh_node->if_incoming == if_incoming)
                         set_mark = 1;
                 else
                         set_mark = 0;
@@ -923,9 +933,9 @@ static int bat_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
         rcu_read_unlock();
 
         if (need_update) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "updating last_seqno: old %u, new %u\n",
-                        orig_node->last_real_seqno, seqno);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "updating last_seqno: old %u, new %u\n",
+                           orig_node->last_real_seqno, seqno);
                 orig_node->last_real_seqno = seqno;
         }
 
@@ -937,10 +947,10 @@ out:
         return ret;
 }
 
-static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
-                               struct batman_ogm_packet *batman_ogm_packet,
-                               const unsigned char *tt_buff,
-                               struct hard_iface *if_incoming)
+static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
+                                  struct batman_ogm_packet *batman_ogm_packet,
+                                  const unsigned char *tt_buff,
+                                  struct hard_iface *if_incoming)
 {
         struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct hard_iface *hard_iface;
@@ -949,11 +959,12 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
         struct neigh_node *orig_neigh_router = NULL;
         int has_directlink_flag;
         int is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0;
-        int is_broadcast = 0, is_bidirectional;
+        int is_broadcast = 0, is_bidirect;
         bool is_single_hop_neigh = false;
         bool is_from_best_next_hop = false;
-        int is_duplicate;
+        int is_duplicate, sameseq, simlar_ttl;
         uint32_t if_incoming_seqno;
+        uint8_t *prev_sender;
 
         /* Silently drop when the batman packet is actually not a
          * correct packet.
@@ -975,18 +986,19 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
 
         has_directlink_flag = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0);
 
-        if (compare_eth(ethhdr->h_source, batman_ogm_packet->orig))
+        if (batadv_compare_eth(ethhdr->h_source, batman_ogm_packet->orig))
                 is_single_hop_neigh = true;
 
-        bat_dbg(DBG_BATMAN, bat_priv,
-                "Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, 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_ogm_packet->orig,
-                batman_ogm_packet->prev_sender, ntohl(batman_ogm_packet->seqno),
-                batman_ogm_packet->ttvn, ntohs(batman_ogm_packet->tt_crc),
-                batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq,
-                batman_ogm_packet->header.ttl,
-                batman_ogm_packet->header.version, has_directlink_flag);
+        batadv_dbg(DBG_BATMAN, bat_priv,
+                   "Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, 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_ogm_packet->orig,
+                   batman_ogm_packet->prev_sender,
+                   ntohl(batman_ogm_packet->seqno), batman_ogm_packet->ttvn,
+                   ntohs(batman_ogm_packet->tt_crc),
+                   batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq,
+                   batman_ogm_packet->header.ttl,
+                   batman_ogm_packet->header.version, has_directlink_flag);
 
         rcu_read_lock();
         list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
@@ -996,16 +1008,16 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
                 if (hard_iface->soft_iface != if_incoming->soft_iface)
                         continue;
 
-                if (compare_eth(ethhdr->h_source,
-                                hard_iface->net_dev->dev_addr))
+                if (batadv_compare_eth(ethhdr->h_source,
+                                       hard_iface->net_dev->dev_addr))
                         is_my_addr = 1;
 
-                if (compare_eth(batman_ogm_packet->orig,
-                                hard_iface->net_dev->dev_addr))
+                if (batadv_compare_eth(batman_ogm_packet->orig,
+                                       hard_iface->net_dev->dev_addr))
                         is_my_orig = 1;
 
-                if (compare_eth(batman_ogm_packet->prev_sender,
-                                hard_iface->net_dev->dev_addr))
+                if (batadv_compare_eth(batman_ogm_packet->prev_sender,
+                                       hard_iface->net_dev->dev_addr))
                         is_my_oldorig = 1;
 
                 if (is_broadcast_ether_addr(ethhdr->h_source))
@@ -1014,29 +1026,30 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
         rcu_read_unlock();
 
         if (batman_ogm_packet->header.version != COMPAT_VERSION) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: incompatible batman version (%i)\n",
-                        batman_ogm_packet->header.version);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: incompatible batman version (%i)\n",
+                           batman_ogm_packet->header.version);
                 return;
         }
 
         if (is_my_addr) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: received my own broadcast (sender: %pM)\n",
-                        ethhdr->h_source);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: received my own broadcast (sender: %pM)\n",
+                           ethhdr->h_source);
                 return;
         }
 
         if (is_broadcast) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: ignoring all packets with broadcast source addr (sender: %pM)\n",
-                        ethhdr->h_source);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: ignoring all packets with broadcast source addr (sender: %pM)\n",
+                           ethhdr->h_source);
                 return;
         }
 
         if (is_my_orig) {
                 unsigned long *word;
                 int offset;
+                int32_t bit_pos;
 
                 orig_neigh_node = batadv_get_orig_node(bat_priv,
                                                        ethhdr->h_source);
@@ -1048,37 +1061,37 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
                  * save packet seqno for bidirectional check
                  */
                 if (has_directlink_flag &&
-                    compare_eth(if_incoming->net_dev->dev_addr,
-                                batman_ogm_packet->orig)) {
+                    batadv_compare_eth(if_incoming->net_dev->dev_addr,
+                                       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]);
-                        bat_set_bit(word,
-                                    if_incoming_seqno -
-                                        ntohl(batman_ogm_packet->seqno) - 2);
+                        bit_pos = if_incoming_seqno - 2;
+                        bit_pos -= ntohl(batman_ogm_packet->seqno);
+                        batadv_set_bit(word, bit_pos);
                         orig_neigh_node->bcast_own_sum[if_incoming->if_num] =
                                 bitmap_weight(word, TQ_LOCAL_WINDOW_SIZE);
                         spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);
                 }
 
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: originator packet from myself (via neighbor)\n");
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: originator packet from myself (via neighbor)\n");
                 batadv_orig_node_free_ref(orig_neigh_node);
                 return;
         }
 
         if (is_my_oldorig) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: ignoring all rebroadcast echos (sender: %pM)\n",
-                        ethhdr->h_source);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: ignoring all rebroadcast echos (sender: %pM)\n",
+                           ethhdr->h_source);
                 return;
         }
 
         if (batman_ogm_packet->flags & NOT_BEST_NEXT_HOP) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
-                        ethhdr->h_source);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
+                           ethhdr->h_source);
                 return;
         }
 
@@ -1086,19 +1099,19 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
         if (!orig_node)
                 return;
 
-        is_duplicate = bat_iv_ogm_update_seqnos(ethhdr, batman_ogm_packet,
-                                                if_incoming);
+        is_duplicate = batadv_iv_ogm_update_seqnos(ethhdr, batman_ogm_packet,
+                                                   if_incoming);
 
         if (is_duplicate == -1) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: packet within seqno protection time (sender: %pM)\n",
-                        ethhdr->h_source);
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: packet within seqno protection time (sender: %pM)\n",
+                           ethhdr->h_source);
                 goto out;
         }
 
         if (batman_ogm_packet->tq == 0) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: originator packet with tq equal 0\n");
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: originator packet with tq equal 0\n");
                 goto out;
         }
 
@@ -1107,18 +1120,18 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
                 router_router = batadv_orig_node_get_router(router->orig_node);
 
         if ((router && router->tq_avg != 0) &&
-            (compare_eth(router->addr, ethhdr->h_source)))
+            (batadv_compare_eth(router->addr, ethhdr->h_source)))
                 is_from_best_next_hop = true;
 
+        prev_sender = batman_ogm_packet->prev_sender;
         /* avoid temporary routing loops */
         if (router && router_router &&
-            (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 may make me loop (sender: %pM)\n",
-                        ethhdr->h_source);
+            (batadv_compare_eth(router->addr, prev_sender)) &&
+            !(batadv_compare_eth(batman_ogm_packet->orig, prev_sender)) &&
+            (batadv_compare_eth(router->addr, router_router->addr))) {
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",
+                           ethhdr->h_source);
                 goto out;
         }
 
@@ -1137,13 +1150,13 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
          * don't route towards it
          */
         if (!is_single_hop_neigh && (!orig_neigh_router)) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: OGM via unknown neighbor!\n");
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: OGM via unknown neighbor!\n");
                 goto out_neigh;
         }
 
-        is_bidirectional = bat_iv_ogm_calc_tq(orig_node, orig_neigh_node,
-                                              batman_ogm_packet, if_incoming);
+        is_bidirect = batadv_iv_ogm_calc_tq(orig_node, orig_neigh_node,
+                                            batman_ogm_packet, if_incoming);
 
         batadv_bonding_save_primary(orig_node, orig_neigh_node,
                                     batman_ogm_packet);
@@ -1151,45 +1164,44 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
         /* 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 == ntohl(batman_ogm_packet->seqno)) &&
-              (orig_node->last_ttl - 3 <= batman_ogm_packet->header.ttl))))
-                bat_iv_ogm_orig_update(bat_priv, orig_node, ethhdr,
-                                       batman_ogm_packet, if_incoming,
-                                       tt_buff, is_duplicate);
+        sameseq = orig_node->last_real_seqno == ntohl(batman_ogm_packet->seqno);
+        simlar_ttl = orig_node->last_ttl - 3 <= batman_ogm_packet->header.ttl;
+        if (is_bidirect && (!is_duplicate || (sameseq && simlar_ttl)))
+                batadv_iv_ogm_orig_update(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 */
-                bat_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
-                                   is_single_hop_neigh, is_from_best_next_hop,
-                                   if_incoming);
+                batadv_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
+                                      is_single_hop_neigh,
+                                      is_from_best_next_hop, if_incoming);
 
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Forwarding packet: rebroadcast neighbor packet with direct link flag\n");
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Forwarding packet: rebroadcast neighbor packet with direct link flag\n");
                 goto out_neigh;
         }
 
         /* multihop originator */
-        if (!is_bidirectional) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: not received via bidirectional link\n");
+        if (!is_bidirect) {
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: not received via bidirectional link\n");
                 goto out_neigh;
         }
 
         if (is_duplicate) {
-                bat_dbg(DBG_BATMAN, bat_priv,
-                        "Drop packet: duplicate packet received\n");
+                batadv_dbg(DBG_BATMAN, bat_priv,
+                           "Drop packet: duplicate packet received\n");
                 goto out_neigh;
         }
 
-        bat_dbg(DBG_BATMAN, bat_priv,
-                "Forwarding packet: rebroadcast originator packet\n");
-        bat_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
-                           is_single_hop_neigh, is_from_best_next_hop,
-                           if_incoming);
+        batadv_dbg(DBG_BATMAN, bat_priv,
+                   "Forwarding packet: rebroadcast originator packet\n");
+        batadv_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
+                              is_single_hop_neigh, is_from_best_next_hop,
+                              if_incoming);
 
 out_neigh:
         if ((orig_neigh_node) && (!is_single_hop_neigh))
@@ -1205,8 +1217,8 @@ out:
         batadv_orig_node_free_ref(orig_node);
 }
 
-static int bat_iv_ogm_receive(struct sk_buff *skb,
-                              struct hard_iface *if_incoming)
+static int batadv_iv_ogm_receive(struct sk_buff *skb,
+                                 struct hard_iface *if_incoming)
 {
         struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
         struct batman_ogm_packet *batman_ogm_packet;
@@ -1222,7 +1234,7 @@ static int bat_iv_ogm_receive(struct sk_buff *skb,
         /* did we receive a B.A.T.M.A.N. IV OGM packet on an interface
          * that does not have B.A.T.M.A.N. IV enabled ?
          */
-        if (bat_priv->bat_algo_ops->bat_ogm_emit != bat_iv_ogm_emit)
+        if (bat_priv->bat_algo_ops->bat_ogm_emit != batadv_iv_ogm_emit)
                 return NET_RX_DROP;
 
         batadv_inc_counter(bat_priv, BAT_CNT_MGMT_RX);
@@ -1238,29 +1250,29 @@ static int bat_iv_ogm_receive(struct sk_buff *skb,
         do {
                 tt_buff = packet_buff + buff_pos + BATMAN_OGM_HLEN;
 
-                bat_iv_ogm_process(ethhdr, batman_ogm_packet,
-                                   tt_buff, if_incoming);
+                batadv_iv_ogm_process(ethhdr, batman_ogm_packet, tt_buff,
+                                      if_incoming);
 
                 buff_pos += BATMAN_OGM_HLEN;
                 buff_pos += batadv_tt_len(batman_ogm_packet->tt_num_changes);
 
                 batman_ogm_packet = (struct batman_ogm_packet *)
                                                 (packet_buff + buff_pos);
-        } while (bat_iv_ogm_aggr_packet(buff_pos, packet_len,
-                                        batman_ogm_packet->tt_num_changes));
+        } while (batadv_iv_ogm_aggr_packet(buff_pos, packet_len,
+                                           batman_ogm_packet->tt_num_changes));
 
         kfree_skb(skb);
         return NET_RX_SUCCESS;
 }
 
-static struct bat_algo_ops batman_iv __read_mostly = {
+static struct bat_algo_ops batadv_batman_iv __read_mostly = {
         .name = "BATMAN_IV",
-        .bat_iface_enable = bat_iv_ogm_iface_enable,
-        .bat_iface_disable = bat_iv_ogm_iface_disable,
-        .bat_iface_update_mac = bat_iv_ogm_iface_update_mac,
-        .bat_primary_iface_set = bat_iv_ogm_primary_iface_set,
-        .bat_ogm_schedule = bat_iv_ogm_schedule,
-        .bat_ogm_emit = bat_iv_ogm_emit,
+        .bat_iface_enable = batadv_iv_ogm_iface_enable,
+        .bat_iface_disable = batadv_iv_ogm_iface_disable,
+        .bat_iface_update_mac = batadv_iv_ogm_iface_update_mac,
+        .bat_primary_iface_set = batadv_iv_ogm_primary_iface_set,
+        .bat_ogm_schedule = batadv_iv_ogm_schedule,
+        .bat_ogm_emit = batadv_iv_ogm_emit,
 };
 
 int __init batadv_iv_init(void)
@@ -1268,11 +1280,11 @@ int __init batadv_iv_init(void)
         int ret;
 
         /* batman originator packet */
-        ret = batadv_recv_handler_register(BAT_IV_OGM, bat_iv_ogm_receive);
+        ret = batadv_recv_handler_register(BAT_IV_OGM, batadv_iv_ogm_receive);
         if (ret < 0)
                 goto out;
 
-        ret = batadv_algo_register(&batman_iv);
+        ret = batadv_algo_register(&batadv_batman_iv);
         if (ret < 0)
                 goto handler_unregister;