[commits] batman-adv; branch, next, updated. v2012.2.0-129-gd03cfc8

22 Jun 2012

The following commit has been merged in the next branch:
commit d03cfc8f9a24ca036e655a4bc8ba7e834ea71943
Merge: de2a45e29e4c048f800d8b8e12d4549c81acd7c9 d1f13e24ec3ebdadc2bc08c9d4708197279096fa
Author: Marek Lindner lindner_marek@yahoo.de
Date:   Fri Jun 22 21:00:19 2012 +0200
Merge branch 'maint' into next
Conflicts:
    	translation-table.c
diff --combined translation-table.c
index ab7618a,2ab83d7..245cc9a

--- a/translation-table.c
+++ b/translation-table.c
@@@ -1,4 -1,5 +1,4 @@@
 -/*
 - * Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
 +/* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
   *
   * Marek Lindner, Simon Wunderlich, Antonio Quartulli
   *
@@@ -15,6 -16,7 +15,6 @@@
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   * 02110-1301, USA
 - *
   */
#include "main.h"
@@@ -29,46 -31,44 +29,46 @@@
#include <linux/crc16.h>
-static void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
 -			  struct orig_node *orig_node);
 -static void tt_purge(struct work_struct *work);
 -static void tt_global_del_orig_list(struct tt_global_entry *tt_global_entry);
 +static void batadv_send_roam_adv(struct batadv_priv *bat_priv, uint8_t *client,
 +				 struct batadv_orig_node *orig_node);
 +static void batadv_tt_purge(struct work_struct *work);
 +static void
 +batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);
/* returns 1 if they are the same mac addr */
 -static int compare_tt(const struct hlist_node *node, const void *data2)
 +static int batadv_compare_tt(const struct hlist_node *node, const void *data2)
  {
 -	const void *data1 = container_of(node, struct tt_common_entry,
 +	const void *data1 = container_of(node, struct batadv_tt_common_entry,
    				 hash_entry);
return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
  }
-static void tt_start_timer(struct bat_priv *bat_priv)
 +static void batadv_tt_start_timer(struct batadv_priv *bat_priv)
  {
 -	INIT_DELAYED_WORK(&bat_priv->tt_work, tt_purge);
 -	queue_delayed_work(bat_event_workqueue, &bat_priv->tt_work,
 +	INIT_DELAYED_WORK(&bat_priv->tt_work, batadv_tt_purge);
 +	queue_delayed_work(batadv_event_workqueue, &bat_priv->tt_work,
    		   msecs_to_jiffies(5000));
  }
-static struct tt_common_entry *tt_hash_find(struct hashtable_t *hash,
 -					    const void *data)
 +static struct batadv_tt_common_entry *
 +batadv_tt_hash_find(struct batadv_hashtable *hash, const void *data)
  {
    struct hlist_head *head;
    struct hlist_node *node;
 -	struct tt_common_entry *tt_common_entry, *tt_common_entry_tmp = NULL;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_common_entry *tt_common_entry_tmp = NULL;
    uint32_t index;
if (!hash)
    	return NULL;
-	index = choose_orig(data, hash->size);
 +	index = batadv_choose_orig(data, hash->size);
    head = &hash->table[index];
rcu_read_lock();
    hlist_for_each_entry_rcu(tt_common_entry, node, head, hash_entry) {
 -		if (!compare_eth(tt_common_entry, data))
 +		if (!batadv_compare_eth(tt_common_entry, data))
    		continue;
if (!atomic_inc_not_zero(&tt_common_entry->refcount))
@@@ -82,86 -82,80 +82,87 @@@
    return tt_common_entry_tmp;
  }
-static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
 -						 const void *data)
 +static struct batadv_tt_local_entry *
 +batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const void *data)
  {
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_local_entry *tt_local_entry = NULL;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_local_entry *tt_local_entry = NULL;
-	tt_common_entry = tt_hash_find(bat_priv->tt_local_hash, data);
 +	tt_common_entry = batadv_tt_hash_find(bat_priv->tt_local_hash, data);
    if (tt_common_entry)
    	tt_local_entry = container_of(tt_common_entry,
 -					      struct tt_local_entry, common);
 +					      struct batadv_tt_local_entry,
 +					      common);
    return tt_local_entry;
  }
-static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
 -						   const void *data)
 +static struct batadv_tt_global_entry *
 +batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const void *data)
  {
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_global_entry *tt_global_entry = NULL;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_global_entry *tt_global_entry = NULL;
-	tt_common_entry = tt_hash_find(bat_priv->tt_global_hash, data);
 +	tt_common_entry = batadv_tt_hash_find(bat_priv->tt_global_hash, data);
    if (tt_common_entry)
    	tt_global_entry = container_of(tt_common_entry,
 -					       struct tt_global_entry, common);
 +					       struct batadv_tt_global_entry,
 +					       common);
    return tt_global_entry;
}
-static void tt_local_entry_free_ref(struct tt_local_entry *tt_local_entry)
 +static void
 +batadv_tt_local_entry_free_ref(struct batadv_tt_local_entry *tt_local_entry)
  {
    if (atomic_dec_and_test(&tt_local_entry->common.refcount))
    	kfree_rcu(tt_local_entry, common.rcu);
  }
-static void tt_global_entry_free_rcu(struct rcu_head *rcu)
 +static void batadv_tt_global_entry_free_rcu(struct rcu_head *rcu)
  {
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_global_entry *tt_global_entry;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_global_entry *tt_global_entry;
-	tt_common_entry = container_of(rcu, struct tt_common_entry, rcu);
 -	tt_global_entry = container_of(tt_common_entry, struct tt_global_entry,
 -				       common);
 +	tt_common_entry = container_of(rcu, struct batadv_tt_common_entry, rcu);
 +	tt_global_entry = container_of(tt_common_entry,
 +				       struct batadv_tt_global_entry, common);
kfree(tt_global_entry);
  }
-static void tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry)
 +static void
 +batadv_tt_global_entry_free_ref(struct batadv_tt_global_entry *tt_global_entry)
  {
    if (atomic_dec_and_test(&tt_global_entry->common.refcount)) {
 -		tt_global_del_orig_list(tt_global_entry);
 +		batadv_tt_global_del_orig_list(tt_global_entry);
    	call_rcu(&tt_global_entry->common.rcu,
 -			 tt_global_entry_free_rcu);
 +			 batadv_tt_global_entry_free_rcu);
    }
  }
-static void tt_orig_list_entry_free_rcu(struct rcu_head *rcu)
 +static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)
  {
 -	struct tt_orig_list_entry *orig_entry;
 +	struct batadv_tt_orig_list_entry *orig_entry;
-	orig_entry = container_of(rcu, struct tt_orig_list_entry, rcu);
 -	orig_node_free_ref(orig_entry->orig_node);
 +	orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);
- 	atomic_dec(&orig_entry->orig_node->tt_size);
 +	batadv_orig_node_free_ref(orig_entry->orig_node);
    kfree(orig_entry);
  }
-static void tt_orig_list_entry_free_ref(struct tt_orig_list_entry *orig_entry)
 +static void
 +batadv_tt_orig_list_entry_free_ref(struct batadv_tt_orig_list_entry *orig_entry)
  {
+ 	/* to avoid race conditions, immediately decrease the tt counter */
+ 	atomic_dec(&orig_entry->orig_node->tt_size);
 -	call_rcu(&orig_entry->rcu, tt_orig_list_entry_free_rcu);
 +	call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);
  }
-static void tt_local_event(struct bat_priv *bat_priv, const uint8_t *addr,
 -			   uint8_t flags)
 +static void batadv_tt_local_event(struct batadv_priv *bat_priv,
 +				  const uint8_t *addr, uint8_t flags)
  {
 -	struct tt_change_node *tt_change_node;
 +	struct batadv_tt_change_node *tt_change_node, *entry, *safe;
 +	bool event_removed = false;
 +	bool del_op_requested, del_op_entry;
tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);
@@@ -171,82 -165,50 +172,82 @@@
    tt_change_node->change.flags = flags;
    memcpy(tt_change_node->change.addr, addr, ETH_ALEN);
+	del_op_requested = flags & BATADV_TT_CLIENT_DEL;
 +
 +	/* check for ADD+DEL or DEL+ADD events */
    spin_lock_bh(&bat_priv->tt_changes_list_lock);
 +	list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
 +				 list) {
 +		if (!batadv_compare_eth(entry->change.addr, addr))
 +			continue;
 +
 +		/* DEL+ADD in the same orig interval have no effect and can be
 +		 * removed to avoid silly behaviour on the receiver side. The
 +		 * other way around (ADD+DEL) can happen in case of roaming of
 +		 * a client still in the NEW state. Roaming of NEW clients is
 +		 * now possible due to automatically recognition of "temporary"
 +		 * clients
 +		 */
 +		del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;
 +		if (!del_op_requested && del_op_entry)
 +			goto del;
 +		if (del_op_requested && !del_op_entry)
 +			goto del;
 +		continue;
 +del:
 +		list_del(&entry->list);
 +		kfree(entry);
 +		event_removed = true;
 +		goto unlock;
 +	}
 +
    /* track the change in the OGMinterval list */
    list_add_tail(&tt_change_node->list, &bat_priv->tt_changes_list);
 -	atomic_inc(&bat_priv->tt_local_changes);
 +
 +unlock:
    spin_unlock_bh(&bat_priv->tt_changes_list_lock);
-	atomic_set(&bat_priv->tt_ogm_append_cnt, 0);
 +	if (event_removed)
 +		atomic_dec(&bat_priv->tt_local_changes);
 +	else
 +		atomic_inc(&bat_priv->tt_local_changes);
  }
-int tt_len(int changes_num)
 +int batadv_tt_len(int changes_num)
  {
 -	return changes_num * sizeof(struct tt_change);
 +	return changes_num * sizeof(struct batadv_tt_change);
  }
-static int tt_local_init(struct bat_priv *bat_priv)
 +static int batadv_tt_local_init(struct batadv_priv *bat_priv)
  {
    if (bat_priv->tt_local_hash)
 -		return 1;
 +		return 0;
-	bat_priv->tt_local_hash = hash_new(1024);
 +	bat_priv->tt_local_hash = batadv_hash_new(1024);
if (!bat_priv->tt_local_hash)
 -		return 0;
 +		return -ENOMEM;
-	return 1;
 +	return 0;
  }
-void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
 -		  int ifindex)
 +void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
 +			 int ifindex)
  {
 -	struct bat_priv *bat_priv = netdev_priv(soft_iface);
 -	struct tt_local_entry *tt_local_entry = NULL;
 -	struct tt_global_entry *tt_global_entry = NULL;
 +	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 +	struct batadv_tt_local_entry *tt_local_entry = NULL;
 +	struct batadv_tt_global_entry *tt_global_entry = NULL;
    struct hlist_head *head;
    struct hlist_node *node;
 -	struct tt_orig_list_entry *orig_entry;
 +	struct batadv_tt_orig_list_entry *orig_entry;
    int hash_added;
-	tt_local_entry = tt_local_hash_find(bat_priv, addr);
 +	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr);
if (tt_local_entry) {
    	tt_local_entry->last_seen = jiffies;
 -		/* possibly unset the TT_CLIENT_PENDING flag */
 -		tt_local_entry->common.flags &= ~TT_CLIENT_PENDING;
 +		/* possibly unset the BATADV_TT_CLIENT_PENDING flag */
 +		tt_local_entry->common.flags &= ~BATADV_TT_CLIENT_PENDING;
    	goto out;
    }
@@@ -254,42 -216,40 +255,42 @@@
    if (!tt_local_entry)
    	goto out;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Creating new local tt entry: %pM (ttvn: %d)\n", addr,
 -		(uint8_t)atomic_read(&bat_priv->ttvn));
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Creating new local tt entry: %pM (ttvn: %d)\n", addr,
 +		   (uint8_t)atomic_read(&bat_priv->ttvn));
memcpy(tt_local_entry->common.addr, addr, ETH_ALEN);
 -	tt_local_entry->common.flags = NO_FLAGS;
 -	if (is_wifi_iface(ifindex))
 -		tt_local_entry->common.flags |= TT_CLIENT_WIFI;
 +	tt_local_entry->common.flags = BATADV_NO_FLAGS;
 +	if (batadv_is_wifi_iface(ifindex))
 +		tt_local_entry->common.flags |= BATADV_TT_CLIENT_WIFI;
    atomic_set(&tt_local_entry->common.refcount, 2);
    tt_local_entry->last_seen = jiffies;
/* the batman interface mac address should never be purged */
 -	if (compare_eth(addr, soft_iface->dev_addr))
 -		tt_local_entry->common.flags |= TT_CLIENT_NOPURGE;
 +	if (batadv_compare_eth(addr, soft_iface->dev_addr))
 +		tt_local_entry->common.flags |= BATADV_TT_CLIENT_NOPURGE;
/* The local entry has to be marked as NEW to avoid to send it in
     * a full table response going out before the next ttvn increment
 -	 * (consistency check) */
 -	tt_local_entry->common.flags |= TT_CLIENT_NEW;
 +	 * (consistency check)
 +	 */
 +	tt_local_entry->common.flags |= BATADV_TT_CLIENT_NEW;
-	hash_added = hash_add(bat_priv->tt_local_hash, compare_tt, choose_orig,
 -			 &tt_local_entry->common,
 -			 &tt_local_entry->common.hash_entry);
 +	hash_added = batadv_hash_add(bat_priv->tt_local_hash, batadv_compare_tt,
 +				     batadv_choose_orig,
 +				     &tt_local_entry->common,
 +				     &tt_local_entry->common.hash_entry);
if (unlikely(hash_added != 0)) {
    	/* remove the reference for the hash */
 -		tt_local_entry_free_ref(tt_local_entry);
 +		batadv_tt_local_entry_free_ref(tt_local_entry);
    	goto out;
    }
-	tt_local_event(bat_priv, addr, tt_local_entry->common.flags);
 +	batadv_tt_local_event(bat_priv, addr, tt_local_entry->common.flags);
/* remove address from global hash if present */
 -	tt_global_entry = tt_global_hash_find(bat_priv, addr);
 +	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr);
/* Check whether it is a roaming! */
    if (tt_global_entry) {
@@@ -299,85 -259,31 +300,85 @@@
    	hlist_for_each_entry_rcu(orig_entry, node, head, list) {
    		orig_entry->orig_node->tt_poss_change = true;
-			send_roam_adv(bat_priv, tt_global_entry->common.addr,
 -				      orig_entry->orig_node);
 +			batadv_send_roam_adv(bat_priv,
 +					     tt_global_entry->common.addr,
 +					     orig_entry->orig_node);
    	}
    	rcu_read_unlock();
    	/* The global entry has to be marked as ROAMING and
    	 * has to be kept for consistency purpose
    	 */
 -		tt_global_entry->common.flags |= TT_CLIENT_ROAM;
 +		tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
    	tt_global_entry->roam_at = jiffies;
    }
  out:
    if (tt_local_entry)
 -		tt_local_entry_free_ref(tt_local_entry);
 +		batadv_tt_local_entry_free_ref(tt_local_entry);
    if (tt_global_entry)
 -		tt_global_entry_free_ref(tt_global_entry);
 +		batadv_tt_global_entry_free_ref(tt_global_entry);
 +}
 +
 +static void batadv_tt_realloc_packet_buff(unsigned char **packet_buff,
 +					  int *packet_buff_len,
 +					  int min_packet_len,
 +					  int new_packet_len)
 +{
 +	unsigned char *new_buff;
 +
 +	new_buff = kmalloc(new_packet_len, GFP_ATOMIC);
 +
 +	/* keep old buffer if kmalloc should fail */
 +	if (new_buff) {
 +		memcpy(new_buff, *packet_buff, min_packet_len);
 +		kfree(*packet_buff);
 +		*packet_buff = new_buff;
 +		*packet_buff_len = new_packet_len;
 +	}
 +}
 +
 +static void batadv_tt_prepare_packet_buff(struct batadv_priv *bat_priv,
 +					  unsigned char **packet_buff,
 +					  int *packet_buff_len,
 +					  int min_packet_len)
 +{
 +	struct batadv_hard_iface *primary_if;
 +	int req_len;
 +
 +	primary_if = batadv_primary_if_get_selected(bat_priv);
 +
 +	req_len = min_packet_len;
 +	req_len += batadv_tt_len(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 ((!primary_if) || (req_len > primary_if->soft_iface->mtu))
 +		req_len = min_packet_len;
 +
 +	batadv_tt_realloc_packet_buff(packet_buff, packet_buff_len,
 +				      min_packet_len, req_len);
 +
 +	if (primary_if)
 +		batadv_hardif_free_ref(primary_if);
  }
-int tt_changes_fill_buffer(struct bat_priv *bat_priv,
 -			   unsigned char *buff, int buff_len)
 +static int batadv_tt_changes_fill_buff(struct batadv_priv *bat_priv,
 +				       unsigned char **packet_buff,
 +				       int *packet_buff_len,
 +				       int min_packet_len)
  {
 -	int count = 0, tot_changes = 0;
 -	struct tt_change_node *entry, *safe;
 +	struct batadv_tt_change_node *entry, *safe;
 +	int count = 0, tot_changes = 0, new_len;
 +	unsigned char *tt_buff;
-	if (buff_len > 0)
 -		tot_changes = buff_len / tt_len(1);
 +	batadv_tt_prepare_packet_buff(bat_priv, packet_buff,
 +				      packet_buff_len, min_packet_len);
 +
 +	new_len = *packet_buff_len - min_packet_len;
 +	tt_buff = *packet_buff + min_packet_len;
 +
 +	if (new_len > 0)
 +		tot_changes = new_len / batadv_tt_len(1);
spin_lock_bh(&bat_priv->tt_changes_list_lock);
    atomic_set(&bat_priv->tt_local_changes, 0);
@@@ -385,8 -291,8 +386,8 @@@
    list_for_each_entry_safe(entry, safe, &bat_priv->tt_changes_list,
    			 list) {
    	if (count < tot_changes) {
 -			memcpy(buff + tt_len(count),
 -			       &entry->change, sizeof(struct tt_change));
 +			memcpy(tt_buff + batadv_tt_len(count),
 +			       &entry->change, sizeof(struct batadv_tt_change));
    		count++;
    	}
    	list_del(&entry->list);
@@@ -399,35 -305,37 +400,35 @@@
    kfree(bat_priv->tt_buff);
    bat_priv->tt_buff_len = 0;
    bat_priv->tt_buff = NULL;
 -	/* We check whether this new OGM has no changes due to size
 -	 * problems */
 -	if (buff_len > 0) {
 -		/**
 -		 * if kmalloc() fails we will reply with the full table
 +	/* check whether this new OGM has no changes due to size problems */
 +	if (new_len > 0) {
 +		/* if kmalloc() fails we will reply with the full table
    	 * instead of providing the diff
    	 */
 -		bat_priv->tt_buff = kmalloc(buff_len, GFP_ATOMIC);
 +		bat_priv->tt_buff = kmalloc(new_len, GFP_ATOMIC);
    	if (bat_priv->tt_buff) {
 -			memcpy(bat_priv->tt_buff, buff, buff_len);
 -			bat_priv->tt_buff_len = buff_len;
 +			memcpy(bat_priv->tt_buff, tt_buff, new_len);
 +			bat_priv->tt_buff_len = new_len;
    	}
    }
    spin_unlock_bh(&bat_priv->tt_buff_lock);
-	return tot_changes;
 +	return count;
  }
-int tt_local_seq_print_text(struct seq_file *seq, void *offset)
 +int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)
  {
    struct net_device *net_dev = (struct net_device *)seq->private;
 -	struct bat_priv *bat_priv = netdev_priv(net_dev);
 -	struct hashtable_t *hash = bat_priv->tt_local_hash;
 -	struct tt_common_entry *tt_common_entry;
 -	struct hard_iface *primary_if;
 +	struct batadv_priv *bat_priv = netdev_priv(net_dev);
 +	struct batadv_hashtable *hash = bat_priv->tt_local_hash;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_hard_iface *primary_if;
    struct hlist_node *node;
    struct hlist_head *head;
    uint32_t i;
    int ret = 0;
-	primary_if = primary_if_get_selected(bat_priv);
 +	primary_if = batadv_primary_if_get_selected(bat_priv);
    if (!primary_if) {
    	ret = seq_printf(seq,
    			 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
@@@ -435,7 -343,7 +436,7 @@@
    	goto out;
    }
-	if (primary_if->if_status != IF_ACTIVE) {
 +	if (primary_if->if_status != BATADV_IF_ACTIVE) {
    	ret = seq_printf(seq,
    			 "BATMAN mesh %s disabled - primary interface not active\n",
    			 net_dev->name);
@@@ -455,94 -363,63 +456,94 @@@
    		seq_printf(seq, " * %pM [%c%c%c%c%c]\n",
    			   tt_common_entry->addr,
    			   (tt_common_entry->flags &
 -				    TT_CLIENT_ROAM ? 'R' : '.'),
 +				    BATADV_TT_CLIENT_ROAM ? 'R' : '.'),
    			   (tt_common_entry->flags &
 -				    TT_CLIENT_NOPURGE ? 'P' : '.'),
 +				    BATADV_TT_CLIENT_NOPURGE ? 'P' : '.'),
    			   (tt_common_entry->flags &
 -				    TT_CLIENT_NEW ? 'N' : '.'),
 +				    BATADV_TT_CLIENT_NEW ? 'N' : '.'),
    			   (tt_common_entry->flags &
 -				    TT_CLIENT_PENDING ? 'X' : '.'),
 +				    BATADV_TT_CLIENT_PENDING ? 'X' : '.'),
    			   (tt_common_entry->flags &
 -				    TT_CLIENT_WIFI ? 'W' : '.'));
 +				    BATADV_TT_CLIENT_WIFI ? 'W' : '.'));
    	}
    	rcu_read_unlock();
    }
  out:
    if (primary_if)
 -		hardif_free_ref(primary_if);
 +		batadv_hardif_free_ref(primary_if);
    return ret;
  }
-static void tt_local_set_pending(struct bat_priv *bat_priv,
 -				 struct tt_local_entry *tt_local_entry,
 -				 uint16_t flags, const char *message)
 +static void
 +batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
 +			    struct batadv_tt_local_entry *tt_local_entry,
 +			    uint16_t flags, const char *message)
  {
 -	tt_local_event(bat_priv, tt_local_entry->common.addr,
 -		       tt_local_entry->common.flags | flags);
 +	batadv_tt_local_event(bat_priv, tt_local_entry->common.addr,
 +			      tt_local_entry->common.flags | flags);
/* The local client has to be marked as "pending to be removed" but has
     * to be kept in the table in order to send it in a full table
 -	 * response issued before the net ttvn increment (consistency check) */
 -	tt_local_entry->common.flags |= TT_CLIENT_PENDING;
 +	 * response issued before the net ttvn increment (consistency check)
 +	 */
 +	tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Local tt entry (%pM) pending to be removed: %s\n",
 -		tt_local_entry->common.addr, message);
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Local tt entry (%pM) pending to be removed: %s\n",
 +		   tt_local_entry->common.addr, message);
  }
-void tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr,
 -		     const char *message, bool roaming)
 +void batadv_tt_local_remove(struct batadv_priv *bat_priv, const uint8_t *addr,
 +			    const char *message, bool roaming)
  {
 -	struct tt_local_entry *tt_local_entry = NULL;
 +	struct batadv_tt_local_entry *tt_local_entry = NULL;
 +	uint16_t flags;
-	tt_local_entry = tt_local_hash_find(bat_priv, addr);
 +	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr);
    if (!tt_local_entry)
    	goto out;
-	tt_local_set_pending(bat_priv, tt_local_entry, TT_CLIENT_DEL |
 -			     (roaming ? TT_CLIENT_ROAM : NO_FLAGS), message);
 +	flags = BATADV_TT_CLIENT_DEL;
 +	if (roaming)
 +		flags |= BATADV_TT_CLIENT_ROAM;
 +
 +	batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags, message);
  out:
    if (tt_local_entry)
 -		tt_local_entry_free_ref(tt_local_entry);
 +		batadv_tt_local_entry_free_ref(tt_local_entry);
  }
-static void tt_local_purge(struct bat_priv *bat_priv)
 +static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,
 +				       struct hlist_head *head)
  {
 -	struct hashtable_t *hash = bat_priv->tt_local_hash;
 -	struct tt_local_entry *tt_local_entry;
 -	struct tt_common_entry *tt_common_entry;
 +	struct batadv_tt_local_entry *tt_local_entry;
 +	struct batadv_tt_common_entry *tt_common_entry;
    struct hlist_node *node, *node_tmp;
 +
 +	hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, head,
 +				  hash_entry) {
 +		tt_local_entry = container_of(tt_common_entry,
 +					      struct batadv_tt_local_entry,
 +					      common);
 +		if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)
 +			continue;
 +
 +		/* entry already marked for deletion */
 +		if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
 +			continue;
 +
 +		if (!batadv_has_timed_out(tt_local_entry->last_seen,
 +					  BATADV_TT_LOCAL_TIMEOUT))
 +			continue;
 +
 +		batadv_tt_local_set_pending(bat_priv, tt_local_entry,
 +					    BATADV_TT_CLIENT_DEL, "timed out");
 +	}
 +}
 +
 +static void batadv_tt_local_purge(struct batadv_priv *bat_priv)
 +{
 +	struct batadv_hashtable *hash = bat_priv->tt_local_hash;
    struct hlist_head *head;
    spinlock_t *list_lock; /* protects write access to the hash lists */
    uint32_t i;
@@@ -552,18 -429,36 +553,18 @@@
    	list_lock = &hash->list_locks[i];
spin_lock_bh(list_lock);
 -		hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
 -					  head, hash_entry) {
 -			tt_local_entry = container_of(tt_common_entry,
 -						      struct tt_local_entry,
 -						      common);
 -			if (tt_local_entry->common.flags & TT_CLIENT_NOPURGE)
 -				continue;
 -
 -			/* entry already marked for deletion */
 -			if (tt_local_entry->common.flags & TT_CLIENT_PENDING)
 -				continue;
 -
 -			if (!has_timed_out(tt_local_entry->last_seen,
 -					   TT_LOCAL_TIMEOUT))
 -				continue;
 -
 -			tt_local_set_pending(bat_priv, tt_local_entry,
 -					     TT_CLIENT_DEL, "timed out");
 -		}
 +		batadv_tt_local_purge_list(bat_priv, head);
    	spin_unlock_bh(list_lock);
    }
}
-static void tt_local_table_free(struct bat_priv *bat_priv)
 +static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
  {
 -	struct hashtable_t *hash;
 +	struct batadv_hashtable *hash;
    spinlock_t *list_lock; /* protects write access to the hash lists */
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_local_entry *tt_local_entry;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_local_entry *tt_local;
    struct hlist_node *node, *node_tmp;
    struct hlist_head *head;
    uint32_t i;
@@@ -581,35 -476,35 +582,35 @@@
    	hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
    				  head, hash_entry) {
    		hlist_del_rcu(node);
 -			tt_local_entry = container_of(tt_common_entry,
 -						      struct tt_local_entry,
 -						      common);
 -			tt_local_entry_free_ref(tt_local_entry);
 +			tt_local = container_of(tt_common_entry,
 +						struct batadv_tt_local_entry,
 +						common);
 +			batadv_tt_local_entry_free_ref(tt_local);
    	}
    	spin_unlock_bh(list_lock);
    }
-	hash_destroy(hash);
 +	batadv_hash_destroy(hash);
bat_priv->tt_local_hash = NULL;
  }
-static int tt_global_init(struct bat_priv *bat_priv)
 +static int batadv_tt_global_init(struct batadv_priv *bat_priv)
  {
    if (bat_priv->tt_global_hash)
 -		return 1;
 +		return 0;
-	bat_priv->tt_global_hash = hash_new(1024);
 +	bat_priv->tt_global_hash = batadv_hash_new(1024);
if (!bat_priv->tt_global_hash)
 -		return 0;
 +		return -ENOMEM;
-	return 1;
 +	return 0;
  }
-static void tt_changes_list_free(struct bat_priv *bat_priv)
 +static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)
  {
 -	struct tt_change_node *entry, *safe;
 +	struct batadv_tt_change_node *entry, *safe;
spin_lock_bh(&bat_priv->tt_changes_list_lock);
@@@ -626,11 -521,10 +627,11 @@@
  /* find out if an orig_node is already in the list of a tt_global_entry.
   * returns 1 if found, 0 otherwise
   */
 -static bool tt_global_entry_has_orig(const struct tt_global_entry *entry,
 -				     const struct orig_node *orig_node)
 +static bool
 +batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,
 +				const struct batadv_orig_node *orig_node)
  {
 -	struct tt_orig_list_entry *tmp_orig_entry;
 +	struct batadv_tt_orig_list_entry *tmp_orig_entry;
    const struct hlist_head *head;
    struct hlist_node *node;
    bool found = false;
@@@ -647,11 -541,11 +648,11 @@@
    return found;
  }
-static void tt_global_add_orig_entry(struct tt_global_entry *tt_global_entry,
 -				     struct orig_node *orig_node,
 -				     int ttvn)
 +static void
 +batadv_tt_global_add_orig_entry(struct batadv_tt_global_entry *tt_global_entry,
 +				struct batadv_orig_node *orig_node, int ttvn)
  {
 -	struct tt_orig_list_entry *orig_entry;
 +	struct batadv_tt_orig_list_entry *orig_entry;
orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);
    if (!orig_entry)
@@@ -670,95 -564,91 +671,95 @@@
  }
/* caller must hold orig_node refcount */
 -int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node,
 -		  const unsigned char *tt_addr, uint8_t ttvn, bool roaming,
 -		  bool wifi)
 +int batadv_tt_global_add(struct batadv_priv *bat_priv,
 +			 struct batadv_orig_node *orig_node,
 +			 const unsigned char *tt_addr, uint8_t flags,
 +			 uint8_t ttvn)
  {
 -	struct tt_global_entry *tt_global_entry = NULL;
 +	struct batadv_tt_global_entry *tt_global_entry = NULL;
    int ret = 0;
    int hash_added;
 +	struct batadv_tt_common_entry *common;
-	tt_global_entry = tt_global_hash_find(bat_priv, tt_addr);
 +	tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr);
if (!tt_global_entry) {
 -		tt_global_entry = kzalloc(sizeof(*tt_global_entry),
 -					  GFP_ATOMIC);
 +		tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC);
    	if (!tt_global_entry)
    		goto out;
-		memcpy(tt_global_entry->common.addr, tt_addr, ETH_ALEN);
 +		common = &tt_global_entry->common;
 +		memcpy(common->addr, tt_addr, ETH_ALEN);
-		tt_global_entry->common.flags = NO_FLAGS;
 +		common->flags = flags;
    	tt_global_entry->roam_at = 0;
 -		atomic_set(&tt_global_entry->common.refcount, 2);
 +		atomic_set(&common->refcount, 2);
INIT_HLIST_HEAD(&tt_global_entry->orig_list);
    	spin_lock_init(&tt_global_entry->list_lock);
-		hash_added = hash_add(bat_priv->tt_global_hash, compare_tt,
 -				 choose_orig, &tt_global_entry->common,
 -				 &tt_global_entry->common.hash_entry);
 +		hash_added = batadv_hash_add(bat_priv->tt_global_hash,
 +					     batadv_compare_tt,
 +					     batadv_choose_orig, common,
 +					     &common->hash_entry);
if (unlikely(hash_added != 0)) {
    		/* remove the reference for the hash */
 -			tt_global_entry_free_ref(tt_global_entry);
 +			batadv_tt_global_entry_free_ref(tt_global_entry);
    		goto out_remove;
    	}
-		tt_global_add_orig_entry(tt_global_entry, orig_node, ttvn);
 +		batadv_tt_global_add_orig_entry(tt_global_entry, orig_node,
 +						ttvn);
    } else {
    	/* there is already a global entry, use this one. */
-		/* If there is the TT_CLIENT_ROAM flag set, there is only one
 -		 * originator left in the list and we previously received a
 +		/* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only
 +		 * one originator left in the list and we previously received a
    	 * delete + roaming change for this originator.
    	 *
    	 * We should first delete the old originator before adding the
    	 * new one.
    	 */
 -		if (tt_global_entry->common.flags & TT_CLIENT_ROAM) {
 -			tt_global_del_orig_list(tt_global_entry);
 -			tt_global_entry->common.flags &= ~TT_CLIENT_ROAM;
 +		if (tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM) {
 +			batadv_tt_global_del_orig_list(tt_global_entry);
 +			tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;
    		tt_global_entry->roam_at = 0;
    	}
-		if (!tt_global_entry_has_orig(tt_global_entry, orig_node))
 -			tt_global_add_orig_entry(tt_global_entry, orig_node,
 -						 ttvn);
 +		if (!batadv_tt_global_entry_has_orig(tt_global_entry,
 +						     orig_node))
 +			batadv_tt_global_add_orig_entry(tt_global_entry,
 +							orig_node, ttvn);
    }
-	if (wifi)
 -		tt_global_entry->common.flags |= TT_CLIENT_WIFI;
 -
 -	bat_dbg(DBG_TT, bat_priv,
 -		"Creating new global tt entry: %pM (via %pM)\n",
 -		tt_global_entry->common.addr, orig_node->orig);
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Creating new global tt entry: %pM (via %pM)\n",
 +		   tt_global_entry->common.addr, orig_node->orig);
out_remove:
    /* remove address from local hash if present */
 -	tt_local_remove(bat_priv, tt_global_entry->common.addr,
 -			"global tt received", roaming);
 +	batadv_tt_local_remove(bat_priv, tt_global_entry->common.addr,
 +			       "global tt received",
 +			       flags & BATADV_TT_CLIENT_ROAM);
    ret = 1;
  out:
    if (tt_global_entry)
 -		tt_global_entry_free_ref(tt_global_entry);
 +		batadv_tt_global_entry_free_ref(tt_global_entry);
    return ret;
  }
/* print all orig nodes who announce the address for this global entry.
   * it is assumed that the caller holds rcu_read_lock();
   */
 -static void tt_global_print_entry(struct tt_global_entry *tt_global_entry,
 -				  struct seq_file *seq)
 +static void
 +batadv_tt_global_print_entry(struct batadv_tt_global_entry *tt_global_entry,
 +			     struct seq_file *seq)
  {
    struct hlist_head *head;
    struct hlist_node *node;
 -	struct tt_orig_list_entry *orig_entry;
 -	struct tt_common_entry *tt_common_entry;
 +	struct batadv_tt_orig_list_entry *orig_entry;
 +	struct batadv_tt_common_entry *tt_common_entry;
    uint16_t flags;
    uint8_t last_ttvn;
@@@ -772,25 -662,25 +773,25 @@@
    	seq_printf(seq, " * %pM  (%3u) via %pM     (%3u)   [%c%c]\n",
    		   tt_global_entry->common.addr, orig_entry->ttvn,
    		   orig_entry->orig_node->orig, last_ttvn,
 -			   (flags & TT_CLIENT_ROAM ? 'R' : '.'),
 -			   (flags & TT_CLIENT_WIFI ? 'W' : '.'));
 +			   (flags & BATADV_TT_CLIENT_ROAM ? 'R' : '.'),
 +			   (flags & BATADV_TT_CLIENT_WIFI ? 'W' : '.'));
    }
  }
-int tt_global_seq_print_text(struct seq_file *seq, void *offset)
 +int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)
  {
    struct net_device *net_dev = (struct net_device *)seq->private;
 -	struct bat_priv *bat_priv = netdev_priv(net_dev);
 -	struct hashtable_t *hash = bat_priv->tt_global_hash;
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_global_entry *tt_global_entry;
 -	struct hard_iface *primary_if;
 +	struct batadv_priv *bat_priv = netdev_priv(net_dev);
 +	struct batadv_hashtable *hash = bat_priv->tt_global_hash;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_global_entry *tt_global;
 +	struct batadv_hard_iface *primary_if;
    struct hlist_node *node;
    struct hlist_head *head;
    uint32_t i;
    int ret = 0;
-	primary_if = primary_if_get_selected(bat_priv);
 +	primary_if = batadv_primary_if_get_selected(bat_priv);
    if (!primary_if) {
    	ret = seq_printf(seq,
    			 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
@@@ -798,7 -688,7 +799,7 @@@
    	goto out;
    }
-	if (primary_if->if_status != IF_ACTIVE) {
 +	if (primary_if->if_status != BATADV_IF_ACTIVE) {
    	ret = seq_printf(seq,
    			 "BATMAN mesh %s disabled - primary interface not active\n",
    			 net_dev->name);
@@@ -817,91 -707,87 +818,91 @@@
    	rcu_read_lock();
    	hlist_for_each_entry_rcu(tt_common_entry, node,
    				 head, hash_entry) {
 -			tt_global_entry = container_of(tt_common_entry,
 -						       struct tt_global_entry,
 -						       common);
 -			tt_global_print_entry(tt_global_entry, seq);
 +			tt_global = container_of(tt_common_entry,
 +						 struct batadv_tt_global_entry,
 +						 common);
 +			batadv_tt_global_print_entry(tt_global, seq);
    	}
    	rcu_read_unlock();
    }
  out:
    if (primary_if)
 -		hardif_free_ref(primary_if);
 +		batadv_hardif_free_ref(primary_if);
    return ret;
  }
/* deletes the orig list of a tt_global_entry */
 -static void tt_global_del_orig_list(struct tt_global_entry *tt_global_entry)
 +static void
 +batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)
  {
    struct hlist_head *head;
    struct hlist_node *node, *safe;
 -	struct tt_orig_list_entry *orig_entry;
 +	struct batadv_tt_orig_list_entry *orig_entry;
spin_lock_bh(&tt_global_entry->list_lock);
    head = &tt_global_entry->orig_list;
    hlist_for_each_entry_safe(orig_entry, node, safe, head, list) {
    	hlist_del_rcu(node);
 -		tt_orig_list_entry_free_ref(orig_entry);
 +		batadv_tt_orig_list_entry_free_ref(orig_entry);
    }
    spin_unlock_bh(&tt_global_entry->list_lock);
}
-static void tt_global_del_orig_entry(struct bat_priv *bat_priv,
 -				     struct tt_global_entry *tt_global_entry,
 -				     struct orig_node *orig_node,
 -				     const char *message)
 +static void
 +batadv_tt_global_del_orig_entry(struct batadv_priv *bat_priv,
 +				struct batadv_tt_global_entry *tt_global_entry,
 +				struct batadv_orig_node *orig_node,
 +				const char *message)
  {
    struct hlist_head *head;
    struct hlist_node *node, *safe;
 -	struct tt_orig_list_entry *orig_entry;
 +	struct batadv_tt_orig_list_entry *orig_entry;
spin_lock_bh(&tt_global_entry->list_lock);
    head = &tt_global_entry->orig_list;
    hlist_for_each_entry_safe(orig_entry, node, safe, head, list) {
    	if (orig_entry->orig_node == orig_node) {
 -			bat_dbg(DBG_TT, bat_priv,
 -				"Deleting %pM from global tt entry %pM: %s\n",
 -				orig_node->orig, tt_global_entry->common.addr,
 -				message);
 +			batadv_dbg(BATADV_DBG_TT, bat_priv,
 +				   "Deleting %pM from global tt entry %pM: %s\n",
 +				   orig_node->orig,
 +				   tt_global_entry->common.addr, message);
    		hlist_del_rcu(node);
 -			tt_orig_list_entry_free_ref(orig_entry);
 +			batadv_tt_orig_list_entry_free_ref(orig_entry);
    	}
    }
    spin_unlock_bh(&tt_global_entry->list_lock);
  }
-static void tt_global_del_struct(struct bat_priv *bat_priv,
 -				 struct tt_global_entry *tt_global_entry,
 -				 const char *message)
 +static void
 +batadv_tt_global_del_struct(struct batadv_priv *bat_priv,
 +			    struct batadv_tt_global_entry *tt_global_entry,
 +			    const char *message)
  {
 -	bat_dbg(DBG_TT, bat_priv,
 -		"Deleting global tt entry %pM: %s\n",
 -		tt_global_entry->common.addr, message);
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Deleting global tt entry %pM: %s\n",
 +		   tt_global_entry->common.addr, message);
-	hash_remove(bat_priv->tt_global_hash, compare_tt, choose_orig,
 -		    tt_global_entry->common.addr);
 -	tt_global_entry_free_ref(tt_global_entry);
 +	batadv_hash_remove(bat_priv->tt_global_hash, batadv_compare_tt,
 +			   batadv_choose_orig, tt_global_entry->common.addr);
 +	batadv_tt_global_entry_free_ref(tt_global_entry);
}
/* If the client is to be deleted, we check if it is the last origantor entry
 - * within tt_global entry. If yes, we set the TT_CLIENT_ROAM flag and the timer,
 - * otherwise we simply remove the originator scheduled for deletion.
 + * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the
 + * timer, otherwise we simply remove the originator scheduled for deletion.
   */
 -static void tt_global_del_roaming(struct bat_priv *bat_priv,
 -				  struct tt_global_entry *tt_global_entry,
 -				  struct orig_node *orig_node,
 -				  const char *message)
 +static void
 +batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
 +			     struct batadv_tt_global_entry *tt_global_entry,
 +			     struct batadv_orig_node *orig_node,
 +			     const char *message)
  {
    bool last_entry = true;
    struct hlist_head *head;
    struct hlist_node *node;
 -	struct tt_orig_list_entry *orig_entry;
 +	struct batadv_tt_orig_list_entry *orig_entry;
/* no local entry exists, case 1:
     * Check if this is the last one or if other entries exist.
@@@ -919,37 -805,37 +920,37 @@@
if (last_entry) {
    	/* its the last one, mark for roaming. */
 -		tt_global_entry->common.flags |= TT_CLIENT_ROAM;
 +		tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
    	tt_global_entry->roam_at = jiffies;
    } else
    	/* there is another entry, we can simply delete this
    	 * one and can still use the other one.
    	 */
 -		tt_global_del_orig_entry(bat_priv, tt_global_entry,
 -					 orig_node, message);
 +		batadv_tt_global_del_orig_entry(bat_priv, tt_global_entry,
 +						orig_node, message);
  }
-static void tt_global_del(struct bat_priv *bat_priv,
 -			  struct orig_node *orig_node,
 -			  const unsigned char *addr,
 -			  const char *message, bool roaming)
 +static void batadv_tt_global_del(struct batadv_priv *bat_priv,
 +				 struct batadv_orig_node *orig_node,
 +				 const unsigned char *addr,
 +				 const char *message, bool roaming)
  {
 -	struct tt_global_entry *tt_global_entry = NULL;
 -	struct tt_local_entry *tt_local_entry = NULL;
 +	struct batadv_tt_global_entry *tt_global_entry = NULL;
 +	struct batadv_tt_local_entry *local_entry = NULL;
-	tt_global_entry = tt_global_hash_find(bat_priv, addr);
 +	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr);
    if (!tt_global_entry)
    	goto out;
if (!roaming) {
 -		tt_global_del_orig_entry(bat_priv, tt_global_entry, orig_node,
 -					 message);
 +		batadv_tt_global_del_orig_entry(bat_priv, tt_global_entry,
 +						orig_node, message);
if (hlist_empty(&tt_global_entry->orig_list))
 -			tt_global_del_struct(bat_priv, tt_global_entry,
 -					     message);
 +			batadv_tt_global_del_struct(bat_priv, tt_global_entry,
 +						    message);
goto out;
    }
@@@ -958,42 -844,41 +959,42 @@@
     * event, there are two possibilities:
     * 1) the client roamed from node A to node B => if there
     *    is only one originator left for this client, we mark
 -	 *    it with TT_CLIENT_ROAM, we start a timer and we
 +	 *    it with BATADV_TT_CLIENT_ROAM, we start a timer and we
     *    wait for node B to claim it. In case of timeout
     *    the entry is purged.
     *
     *    If there are other originators left, we directly delete
     *    the originator.
     * 2) the client roamed to us => we can directly delete
 -	 *    the global entry, since it is useless now. */
 -
 -	tt_local_entry = tt_local_hash_find(bat_priv,
 -					    tt_global_entry->common.addr);
 -	if (tt_local_entry) {
 +	 *    the global entry, since it is useless now.
 +	 */
 +	local_entry = batadv_tt_local_hash_find(bat_priv,
 +						tt_global_entry->common.addr);
 +	if (local_entry) {
    	/* local entry exists, case 2: client roamed to us. */
 -		tt_global_del_orig_list(tt_global_entry);
 -		tt_global_del_struct(bat_priv, tt_global_entry, message);
 +		batadv_tt_global_del_orig_list(tt_global_entry);
 +		batadv_tt_global_del_struct(bat_priv, tt_global_entry, message);
    } else
    	/* no local entry exists, case 1: check for roaming */
 -		tt_global_del_roaming(bat_priv, tt_global_entry, orig_node,
 -				      message);
 +		batadv_tt_global_del_roaming(bat_priv, tt_global_entry,
 +					     orig_node, message);
out:
    if (tt_global_entry)
 -		tt_global_entry_free_ref(tt_global_entry);
 -	if (tt_local_entry)
 -		tt_local_entry_free_ref(tt_local_entry);
 +		batadv_tt_global_entry_free_ref(tt_global_entry);
 +	if (local_entry)
 +		batadv_tt_local_entry_free_ref(local_entry);
  }
-void tt_global_del_orig(struct bat_priv *bat_priv,
 -			struct orig_node *orig_node, const char *message)
 +void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
 +			       struct batadv_orig_node *orig_node,
 +			       const char *message)
  {
 -	struct tt_global_entry *tt_global_entry;
 -	struct tt_common_entry *tt_common_entry;
 +	struct batadv_tt_global_entry *tt_global;
 +	struct batadv_tt_common_entry *tt_common_entry;
    uint32_t i;
 -	struct hashtable_t *hash = bat_priv->tt_global_hash;
 +	struct batadv_hashtable *hash = bat_priv->tt_global_hash;
    struct hlist_node *node, *safe;
    struct hlist_head *head;
    spinlock_t *list_lock; /* protects write access to the hash lists */
@@@ -1008,57 -893,33 +1009,56 @@@
    	spin_lock_bh(list_lock);
    	hlist_for_each_entry_safe(tt_common_entry, node, safe,
    				  head, hash_entry) {
 -			tt_global_entry = container_of(tt_common_entry,
 -						       struct tt_global_entry,
 -						       common);
 -
 -			tt_global_del_orig_entry(bat_priv, tt_global_entry,
 -						 orig_node, message);
 -
 -			if (hlist_empty(&tt_global_entry->orig_list)) {
 -				bat_dbg(DBG_TT, bat_priv,
 -					"Deleting global tt entry %pM: %s\n",
 -					tt_global_entry->common.addr,
 -					message);
 +			tt_global = container_of(tt_common_entry,
 +						 struct batadv_tt_global_entry,
 +						 common);
 +
 +			batadv_tt_global_del_orig_entry(bat_priv, tt_global,
 +							orig_node, message);
 +
 +			if (hlist_empty(&tt_global->orig_list)) {
 +				batadv_dbg(BATADV_DBG_TT, bat_priv,
 +					   "Deleting global tt entry %pM: %s\n",
 +					   tt_global->common.addr, message);
    			hlist_del_rcu(node);
 -				tt_global_entry_free_ref(tt_global_entry);
 +				batadv_tt_global_entry_free_ref(tt_global);
    		}
    	}
    	spin_unlock_bh(list_lock);
    }
    orig_node->tt_initialised = false;
  }
-static void tt_global_roam_purge(struct bat_priv *bat_priv)
 +static void batadv_tt_global_roam_purge_list(struct batadv_priv *bat_priv,
 +					     struct hlist_head *head)
  {
 -	struct hashtable_t *hash = bat_priv->tt_global_hash;
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_global_entry *tt_global_entry;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_global_entry *tt_global_entry;
    struct hlist_node *node, *node_tmp;
 +
 +	hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, head,
 +				  hash_entry) {
 +		tt_global_entry = container_of(tt_common_entry,
 +					       struct batadv_tt_global_entry,
 +					       common);
 +		if (!(tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM))
 +			continue;
 +		if (!batadv_has_timed_out(tt_global_entry->roam_at,
 +					  BATADV_TT_CLIENT_ROAM_TIMEOUT))
 +			continue;
 +
 +		batadv_dbg(BATADV_DBG_TT, bat_priv,
 +			   "Deleting global tt entry (%pM): Roaming timeout\n",
 +			   tt_global_entry->common.addr);
 +
 +		hlist_del_rcu(node);
 +		batadv_tt_global_entry_free_ref(tt_global_entry);
 +	}
 +}
 +
 +static void batadv_tt_global_roam_purge(struct batadv_priv *bat_priv)
 +{
 +	struct batadv_hashtable *hash = bat_priv->tt_global_hash;
    struct hlist_head *head;
    spinlock_t *list_lock; /* protects write access to the hash lists */
    uint32_t i;
@@@ -1068,18 -929,35 +1068,18 @@@
    	list_lock = &hash->list_locks[i];
spin_lock_bh(list_lock);
 -		hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
 -					  head, hash_entry) {
 -			tt_global_entry = container_of(tt_common_entry,
 -						       struct tt_global_entry,
 -						       common);
 -			if (!(tt_global_entry->common.flags & TT_CLIENT_ROAM))
 -				continue;
 -			if (!has_timed_out(tt_global_entry->roam_at,
 -					   TT_CLIENT_ROAM_TIMEOUT))
 -				continue;
 -
 -			bat_dbg(DBG_TT, bat_priv,
 -				"Deleting global tt entry (%pM): Roaming timeout\n",
 -				tt_global_entry->common.addr);
 -
 -			hlist_del_rcu(node);
 -			tt_global_entry_free_ref(tt_global_entry);
 -		}
 +		batadv_tt_global_roam_purge_list(bat_priv, head);
    	spin_unlock_bh(list_lock);
    }
}
-static void tt_global_table_free(struct bat_priv *bat_priv)
 +static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
  {
 -	struct hashtable_t *hash;
 +	struct batadv_hashtable *hash;
    spinlock_t *list_lock; /* protects write access to the hash lists */
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_global_entry *tt_global_entry;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_global_entry *tt_global;
    struct hlist_node *node, *node_tmp;
    struct hlist_head *head;
    uint32_t i;
@@@ -1097,60 -975,56 +1097,60 @@@
    	hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
    				  head, hash_entry) {
    		hlist_del_rcu(node);
 -			tt_global_entry = container_of(tt_common_entry,
 -						       struct tt_global_entry,
 -						       common);
 -			tt_global_entry_free_ref(tt_global_entry);
 +			tt_global = container_of(tt_common_entry,
 +						 struct batadv_tt_global_entry,
 +						 common);
 +			batadv_tt_global_entry_free_ref(tt_global);
    	}
    	spin_unlock_bh(list_lock);
    }
-	hash_destroy(hash);
 +	batadv_hash_destroy(hash);
bat_priv->tt_global_hash = NULL;
  }
-static bool _is_ap_isolated(struct tt_local_entry *tt_local_entry,
 -			    struct tt_global_entry *tt_global_entry)
 +static bool
 +_batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,
 +		       struct batadv_tt_global_entry *tt_global_entry)
  {
    bool ret = false;
-	if (tt_local_entry->common.flags & TT_CLIENT_WIFI &&
 -	    tt_global_entry->common.flags & TT_CLIENT_WIFI)
 +	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&
 +	    tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)
    	ret = true;
return ret;
  }
-struct orig_node *transtable_search(struct bat_priv *bat_priv,
 -				    const uint8_t *src, const uint8_t *addr)
 +struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
 +						  const uint8_t *src,
 +						  const uint8_t *addr)
  {
 -	struct tt_local_entry *tt_local_entry = NULL;
 -	struct tt_global_entry *tt_global_entry = NULL;
 -	struct orig_node *orig_node = NULL;
 -	struct neigh_node *router = NULL;
 +	struct batadv_tt_local_entry *tt_local_entry = NULL;
 +	struct batadv_tt_global_entry *tt_global_entry = NULL;
 +	struct batadv_orig_node *orig_node = NULL;
 +	struct batadv_neigh_node *router = NULL;
    struct hlist_head *head;
    struct hlist_node *node;
 -	struct tt_orig_list_entry *orig_entry;
 +	struct batadv_tt_orig_list_entry *orig_entry;
    int best_tq;
if (src && atomic_read(&bat_priv->ap_isolation)) {
 -		tt_local_entry = tt_local_hash_find(bat_priv, src);
 +		tt_local_entry = batadv_tt_local_hash_find(bat_priv, src);
    	if (!tt_local_entry)
    		goto out;
    }
-	tt_global_entry = tt_global_hash_find(bat_priv, addr);
 +	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr);
    if (!tt_global_entry)
    	goto out;
/* check whether the clients should not communicate due to AP
 -	 * isolation */
 -	if (tt_local_entry && _is_ap_isolated(tt_local_entry, tt_global_entry))
 +	 * isolation
 +	 */
 +	if (tt_local_entry &&
 +	    _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
    	goto out;
best_tq = 0;
@@@ -1158,7 -1032,7 +1158,7 @@@
    rcu_read_lock();
    head = &tt_global_entry->orig_list;
    hlist_for_each_entry_rcu(orig_entry, node, head, list) {
 -		router = orig_node_get_router(orig_entry->orig_node);
 +		router = batadv_orig_node_get_router(orig_entry->orig_node);
    	if (!router)
    		continue;
@@@ -1166,7 -1040,7 +1166,7 @@@
    		orig_node = orig_entry->orig_node;
    		best_tq = router->tq_avg;
    	}
 -		neigh_node_free_ref(router);
 +		batadv_neigh_node_free_ref(router);
    }
    /* found anything? */
    if (orig_node && !atomic_inc_not_zero(&orig_node->refcount))
@@@ -1174,21 -1048,21 +1174,21 @@@
    rcu_read_unlock();
  out:
    if (tt_global_entry)
 -		tt_global_entry_free_ref(tt_global_entry);
 +		batadv_tt_global_entry_free_ref(tt_global_entry);
    if (tt_local_entry)
 -		tt_local_entry_free_ref(tt_local_entry);
 +		batadv_tt_local_entry_free_ref(tt_local_entry);
return orig_node;
  }
/* Calculates the checksum of the local table of a given orig_node */
 -static uint16_t tt_global_crc(struct bat_priv *bat_priv,
 -			      struct orig_node *orig_node)
 +static uint16_t batadv_tt_global_crc(struct batadv_priv *bat_priv,
 +				     struct batadv_orig_node *orig_node)
  {
    uint16_t total = 0, total_one;
 -	struct hashtable_t *hash = bat_priv->tt_global_hash;
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_global_entry *tt_global_entry;
 +	struct batadv_hashtable *hash = bat_priv->tt_global_hash;
 +	struct batadv_tt_common_entry *tt_common;
 +	struct batadv_tt_global_entry *tt_global;
    struct hlist_node *node;
    struct hlist_head *head;
    uint32_t i;
@@@ -1198,29 -1072,30 +1198,29 @@@
    	head = &hash->table[i];
rcu_read_lock();
 -		hlist_for_each_entry_rcu(tt_common_entry, node,
 -					 head, hash_entry) {
 -			tt_global_entry = container_of(tt_common_entry,
 -						       struct tt_global_entry,
 -						       common);
 +		hlist_for_each_entry_rcu(tt_common, node, head, hash_entry) {
 +			tt_global = container_of(tt_common,
 +						 struct batadv_tt_global_entry,
 +						 common);
    		/* Roaming clients are in the global table for
    		 * consistency only. They don't have to be
    		 * taken into account while computing the
    		 * global crc
    		 */
 -			if (tt_global_entry->common.flags & TT_CLIENT_ROAM)
 +			if (tt_common->flags & BATADV_TT_CLIENT_ROAM)
    			continue;
/* find out if this global entry is announced by this
    		 * originator
    		 */
 -			if (!tt_global_entry_has_orig(tt_global_entry,
 -						      orig_node))
 +			if (!batadv_tt_global_entry_has_orig(tt_global,
 +							     orig_node))
    			continue;
total_one = 0;
    		for (j = 0; j < ETH_ALEN; j++)
    			total_one = crc16_byte(total_one,
 -					tt_global_entry->common.addr[j]);
 +						       tt_common->addr[j]);
    		total ^= total_one;
    	}
    	rcu_read_unlock();
@@@ -1230,11 -1105,11 +1230,11 @@@
  }
/* Calculates the checksum of the local table */
 -uint16_t tt_local_crc(struct bat_priv *bat_priv)
 +static uint16_t batadv_tt_local_crc(struct batadv_priv *bat_priv)
  {
    uint16_t total = 0, total_one;
 -	struct hashtable_t *hash = bat_priv->tt_local_hash;
 -	struct tt_common_entry *tt_common_entry;
 +	struct batadv_hashtable *hash = bat_priv->tt_local_hash;
 +	struct batadv_tt_common_entry *tt_common;
    struct hlist_node *node;
    struct hlist_head *head;
    uint32_t i;
@@@ -1244,16 -1119,16 +1244,16 @@@
    	head = &hash->table[i];
rcu_read_lock();
 -		hlist_for_each_entry_rcu(tt_common_entry, node,
 -					 head, hash_entry) {
 +		hlist_for_each_entry_rcu(tt_common, node, head, hash_entry) {
    		/* not yet committed clients have not to be taken into
 -			 * account while computing the CRC */
 -			if (tt_common_entry->flags & TT_CLIENT_NEW)
 +			 * account while computing the CRC
 +			 */
 +			if (tt_common->flags & BATADV_TT_CLIENT_NEW)
    			continue;
    		total_one = 0;
    		for (j = 0; j < ETH_ALEN; j++)
    			total_one = crc16_byte(total_one,
 -						   tt_common_entry->addr[j]);
 +						       tt_common->addr[j]);
    		total ^= total_one;
    	}
    	rcu_read_unlock();
@@@ -1262,9 -1137,9 +1262,9 @@@
    return total;
  }
-static void tt_req_list_free(struct bat_priv *bat_priv)
 +static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)
  {
 -	struct tt_req_node *node, *safe;
 +	struct batadv_tt_req_node *node, *safe;
spin_lock_bh(&bat_priv->tt_req_list_lock);
@@@ -1276,16 -1151,15 +1276,16 @@@
    spin_unlock_bh(&bat_priv->tt_req_list_lock);
  }
-static void tt_save_orig_buffer(struct bat_priv *bat_priv,
 -				struct orig_node *orig_node,
 -				const unsigned char *tt_buff,
 -				uint8_t tt_num_changes)
 +static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,
 +				       struct batadv_orig_node *orig_node,
 +				       const unsigned char *tt_buff,
 +				       uint8_t tt_num_changes)
  {
 -	uint16_t tt_buff_len = tt_len(tt_num_changes);
 +	uint16_t tt_buff_len = batadv_tt_len(tt_num_changes);
/* Replace the old buffer only if I received something in the
 -	 * last OGM (the OGM could carry no changes) */
 +	 * last OGM (the OGM could carry no changes)
 +	 */
    spin_lock_bh(&orig_node->tt_buff_lock);
    if (tt_buff_len > 0) {
    	kfree(orig_node->tt_buff);
@@@ -1299,14 -1173,13 +1299,14 @@@
    spin_unlock_bh(&orig_node->tt_buff_lock);
  }
-static void tt_req_purge(struct bat_priv *bat_priv)
 +static void batadv_tt_req_purge(struct batadv_priv *bat_priv)
  {
 -	struct tt_req_node *node, *safe;
 +	struct batadv_tt_req_node *node, *safe;
spin_lock_bh(&bat_priv->tt_req_list_lock);
    list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
 -		if (has_timed_out(node->issued_at, TT_REQUEST_TIMEOUT)) {
 +		if (batadv_has_timed_out(node->issued_at,
 +					 BATADV_TT_REQUEST_TIMEOUT)) {
    		list_del(&node->list);
    		kfree(node);
    	}
@@@ -1315,19 -1188,17 +1315,19 @@@
  }
/* returns the pointer to the new tt_req_node struct if no request
 - * has already been issued for this orig_node, NULL otherwise */
 -static struct tt_req_node *new_tt_req_node(struct bat_priv *bat_priv,
 -					  struct orig_node *orig_node)
 + * has already been issued for this orig_node, NULL otherwise
 + */
 +static struct batadv_tt_req_node *
 +batadv_new_tt_req_node(struct batadv_priv *bat_priv,
 +		       struct batadv_orig_node *orig_node)
  {
 -	struct tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
 +	struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
spin_lock_bh(&bat_priv->tt_req_list_lock);
    list_for_each_entry(tt_req_node_tmp, &bat_priv->tt_req_list, list) {
 -		if (compare_eth(tt_req_node_tmp, orig_node) &&
 -		    !has_timed_out(tt_req_node_tmp->issued_at,
 -				   TT_REQUEST_TIMEOUT))
 +		if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&
 +		    !batadv_has_timed_out(tt_req_node_tmp->issued_at,
 +					  BATADV_TT_REQUEST_TIMEOUT))
    		goto unlock;
    }
@@@ -1345,67 -1216,63 +1345,67 @@@ unlock
  }
/* data_ptr is useless here, but has to be kept to respect the prototype */
 -static int tt_local_valid_entry(const void *entry_ptr, const void *data_ptr)
 +static int batadv_tt_local_valid_entry(const void *entry_ptr,
 +				       const void *data_ptr)
  {
 -	const struct tt_common_entry *tt_common_entry = entry_ptr;
 +	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
-	if (tt_common_entry->flags & TT_CLIENT_NEW)
 +	if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
    	return 0;
    return 1;
  }
-static int tt_global_valid_entry(const void *entry_ptr, const void *data_ptr)
 +static int batadv_tt_global_valid(const void *entry_ptr,
 +				  const void *data_ptr)
  {
 -	const struct tt_common_entry *tt_common_entry = entry_ptr;
 -	const struct tt_global_entry *tt_global_entry;
 -	const struct orig_node *orig_node = data_ptr;
 +	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
 +	const struct batadv_tt_global_entry *tt_global_entry;
 +	const struct batadv_orig_node *orig_node = data_ptr;
-	if (tt_common_entry->flags & TT_CLIENT_ROAM)
 +	if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM)
    	return 0;
-	tt_global_entry = container_of(tt_common_entry, struct tt_global_entry,
 +	tt_global_entry = container_of(tt_common_entry,
 +				       struct batadv_tt_global_entry,
    			       common);
-	return tt_global_entry_has_orig(tt_global_entry, orig_node);
 +	return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node);
  }
-static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
 -					      struct hashtable_t *hash,
 -					      struct hard_iface *primary_if,
 -					      int (*valid_cb)(const void *,
 -							      const void *),
 -					      void *cb_data)
 +static struct sk_buff *
 +batadv_tt_response_fill_table(uint16_t tt_len, uint8_t ttvn,
 +			      struct batadv_hashtable *hash,
 +			      struct batadv_hard_iface *primary_if,
 +			      int (*valid_cb)(const void *, const void *),
 +			      void *cb_data)
  {
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_query_packet *tt_response;
 -	struct tt_change *tt_change;
 +	struct batadv_tt_common_entry *tt_common_entry;
 +	struct batadv_tt_query_packet *tt_response;
 +	struct batadv_tt_change *tt_change;
    struct hlist_node *node;
    struct hlist_head *head;
    struct sk_buff *skb = NULL;
    uint16_t tt_tot, tt_count;
 -	ssize_t tt_query_size = sizeof(struct tt_query_packet);
 +	ssize_t tt_query_size = sizeof(struct batadv_tt_query_packet);
    uint32_t i;
 +	size_t len;
if (tt_query_size + tt_len > primary_if->soft_iface->mtu) {
    	tt_len = primary_if->soft_iface->mtu - tt_query_size;
 -		tt_len -= tt_len % sizeof(struct tt_change);
 +		tt_len -= tt_len % sizeof(struct batadv_tt_change);
    }
 -	tt_tot = tt_len / sizeof(struct tt_change);
 +	tt_tot = tt_len / sizeof(struct batadv_tt_change);
-	skb = dev_alloc_skb(tt_query_size + tt_len + ETH_HLEN);
 +	len = tt_query_size + tt_len;
 +	skb = dev_alloc_skb(len + ETH_HLEN);
    if (!skb)
    	goto out;
skb_reserve(skb, ETH_HLEN);
 -	tt_response = (struct tt_query_packet *)skb_put(skb,
 -						     tt_query_size + tt_len);
 +	tt_response = (struct batadv_tt_query_packet *)skb_put(skb, len);
    tt_response->ttvn = ttvn;
-	tt_change = (struct tt_change *)(skb->data + tt_query_size);
 +	tt_change = (struct batadv_tt_change *)(skb->data + tt_query_size);
    tt_count = 0;
rcu_read_lock();
@@@ -1422,7 -1289,7 +1422,7 @@@
memcpy(tt_change->addr, tt_common_entry->addr,
    		       ETH_ALEN);
 -			tt_change->flags = NO_FLAGS;
 +			tt_change->flags = BATADV_NO_FLAGS;
tt_count++;
    		tt_change++;
@@@ -1431,78 -1298,72 +1431,78 @@@
    rcu_read_unlock();
/* store in the message the number of entries we have successfully
 -	 * copied */
 +	 * copied
 +	 */
    tt_response->tt_data = htons(tt_count);
out:
    return skb;
  }
-static int send_tt_request(struct bat_priv *bat_priv,
 -			   struct orig_node *dst_orig_node,
 -			   uint8_t ttvn, uint16_t tt_crc, bool full_table)
 +static int batadv_send_tt_request(struct batadv_priv *bat_priv,
 +				  struct batadv_orig_node *dst_orig_node,
 +				  uint8_t ttvn, uint16_t tt_crc,
 +				  bool full_table)
  {
    struct sk_buff *skb = NULL;
 -	struct tt_query_packet *tt_request;
 -	struct neigh_node *neigh_node = NULL;
 -	struct hard_iface *primary_if;
 -	struct tt_req_node *tt_req_node = NULL;
 +	struct batadv_tt_query_packet *tt_request;
 +	struct batadv_neigh_node *neigh_node = NULL;
 +	struct batadv_hard_iface *primary_if;
 +	struct batadv_tt_req_node *tt_req_node = NULL;
    int ret = 1;
 +	size_t tt_req_len;
-	primary_if = primary_if_get_selected(bat_priv);
 +	primary_if = batadv_primary_if_get_selected(bat_priv);
    if (!primary_if)
    	goto out;
/* The new tt_req will be issued only if I'm not waiting for a
 -	 * reply from the same orig_node yet */
 -	tt_req_node = new_tt_req_node(bat_priv, dst_orig_node);
 +	 * reply from the same orig_node yet
 +	 */
 +	tt_req_node = batadv_new_tt_req_node(bat_priv, dst_orig_node);
    if (!tt_req_node)
    	goto out;
-	skb = dev_alloc_skb(sizeof(struct tt_query_packet) + ETH_HLEN);
 +	skb = dev_alloc_skb(sizeof(*tt_request) + ETH_HLEN);
    if (!skb)
    	goto out;
skb_reserve(skb, ETH_HLEN);
-	tt_request = (struct tt_query_packet *)skb_put(skb,
 -				sizeof(struct tt_query_packet));
 +	tt_req_len = sizeof(*tt_request);
 +	tt_request = (struct batadv_tt_query_packet *)skb_put(skb, tt_req_len);
-	tt_request->header.packet_type = BAT_TT_QUERY;
 -	tt_request->header.version = COMPAT_VERSION;
 +	tt_request->header.packet_type = BATADV_TT_QUERY;
 +	tt_request->header.version = BATADV_COMPAT_VERSION;
    memcpy(tt_request->src, primary_if->net_dev->dev_addr, ETH_ALEN);
    memcpy(tt_request->dst, dst_orig_node->orig, ETH_ALEN);
 -	tt_request->header.ttl = TTL;
 +	tt_request->header.ttl = BATADV_TTL;
    tt_request->ttvn = ttvn;
    tt_request->tt_data = htons(tt_crc);
 -	tt_request->flags = TT_REQUEST;
 +	tt_request->flags = BATADV_TT_REQUEST;
if (full_table)
 -		tt_request->flags |= TT_FULL_TABLE;
 +		tt_request->flags |= BATADV_TT_FULL_TABLE;
-	neigh_node = orig_node_get_router(dst_orig_node);
 +	neigh_node = batadv_orig_node_get_router(dst_orig_node);
    if (!neigh_node)
    	goto out;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Sending TT_REQUEST to %pM via %pM [%c]\n",
 -		dst_orig_node->orig, neigh_node->addr,
 -		(full_table ? 'F' : '.'));
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Sending TT_REQUEST to %pM via %pM [%c]\n",
 +		   dst_orig_node->orig, neigh_node->addr,
 +		   (full_table ? 'F' : '.'));
 +
 +	batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
-	send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
 +	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
    ret = 0;
out:
    if (neigh_node)
 -		neigh_node_free_ref(neigh_node);
 +		batadv_neigh_node_free_ref(neigh_node);
    if (primary_if)
 -		hardif_free_ref(primary_if);
 +		batadv_hardif_free_ref(primary_if);
    if (ret)
    	kfree_skb(skb);
    if (ret && tt_req_node) {
@@@ -1514,42 -1375,39 +1514,42 @@@
    return ret;
  }
-static bool send_other_tt_response(struct bat_priv *bat_priv,
 -				   struct tt_query_packet *tt_request)
 +static bool
 +batadv_send_other_tt_response(struct batadv_priv *bat_priv,
 +			      struct batadv_tt_query_packet *tt_request)
  {
 -	struct orig_node *req_dst_orig_node = NULL, *res_dst_orig_node = NULL;
 -	struct neigh_node *neigh_node = NULL;
 -	struct hard_iface *primary_if = NULL;
 +	struct batadv_orig_node *req_dst_orig_node = NULL;
 +	struct batadv_orig_node *res_dst_orig_node = NULL;
 +	struct batadv_neigh_node *neigh_node = NULL;
 +	struct batadv_hard_iface *primary_if = NULL;
    uint8_t orig_ttvn, req_ttvn, ttvn;
    int ret = false;
    unsigned char *tt_buff;
    bool full_table;
    uint16_t tt_len, tt_tot;
    struct sk_buff *skb = NULL;
 -	struct tt_query_packet *tt_response;
 +	struct batadv_tt_query_packet *tt_response;
 +	size_t len;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
 -		tt_request->src, tt_request->ttvn, tt_request->dst,
 -		(tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
 +		   tt_request->src, tt_request->ttvn, tt_request->dst,
 +		   (tt_request->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
/* Let's get the orig node of the REAL destination */
 -	req_dst_orig_node = orig_hash_find(bat_priv, tt_request->dst);
 +	req_dst_orig_node = batadv_orig_hash_find(bat_priv, tt_request->dst);
    if (!req_dst_orig_node)
    	goto out;
-	res_dst_orig_node = orig_hash_find(bat_priv, tt_request->src);
 +	res_dst_orig_node = batadv_orig_hash_find(bat_priv, tt_request->src);
    if (!res_dst_orig_node)
    	goto out;
-	neigh_node = orig_node_get_router(res_dst_orig_node);
 +	neigh_node = batadv_orig_node_get_router(res_dst_orig_node);
    if (!neigh_node)
    	goto out;
-	primary_if = primary_if_get_selected(bat_priv);
 +	primary_if = batadv_primary_if_get_selected(bat_priv);
    if (!primary_if)
    	goto out;
@@@ -1558,75 -1416,71 +1558,75 @@@
/* I don't have the requested data */
    if (orig_ttvn != req_ttvn ||
 -	    tt_request->tt_data != req_dst_orig_node->tt_crc)
 +	    tt_request->tt_data != htons(req_dst_orig_node->tt_crc))
    	goto out;
/* If the full table has been explicitly requested */
 -	if (tt_request->flags & TT_FULL_TABLE ||
 +	if (tt_request->flags & BATADV_TT_FULL_TABLE ||
        !req_dst_orig_node->tt_buff)
    	full_table = true;
    else
    	full_table = false;
/* In this version, fragmentation is not implemented, then
 -	 * I'll send only one packet with as much TT entries as I can */
 +	 * I'll send only one packet with as much TT entries as I can
 +	 */
    if (!full_table) {
    	spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
    	tt_len = req_dst_orig_node->tt_buff_len;
 -		tt_tot = tt_len / sizeof(struct tt_change);
 +		tt_tot = tt_len / sizeof(struct batadv_tt_change);
-		skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
 -				    tt_len + ETH_HLEN);
 +		len = sizeof(*tt_response) + tt_len;
 +		skb = dev_alloc_skb(len + ETH_HLEN);
    	if (!skb)
    		goto unlock;
skb_reserve(skb, ETH_HLEN);
 -		tt_response = (struct tt_query_packet *)skb_put(skb,
 -				sizeof(struct tt_query_packet) + tt_len);
 +		tt_response = (struct batadv_tt_query_packet *)skb_put(skb,
 +								       len);
    	tt_response->ttvn = req_ttvn;
    	tt_response->tt_data = htons(tt_tot);
-		tt_buff = skb->data + sizeof(struct tt_query_packet);
 +		tt_buff = skb->data + sizeof(*tt_response);
    	/* Copy the last orig_node's OGM buffer */
    	memcpy(tt_buff, req_dst_orig_node->tt_buff,
    	       req_dst_orig_node->tt_buff_len);
spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
    } else {
 -		tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size) *
 -						sizeof(struct tt_change);
 +		tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size);
 +		tt_len *= sizeof(struct batadv_tt_change);
    	ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn);
-		skb = tt_response_fill_table(tt_len, ttvn,
 -					     bat_priv->tt_global_hash,
 -					     primary_if, tt_global_valid_entry,
 -					     req_dst_orig_node);
 +		skb = batadv_tt_response_fill_table(tt_len, ttvn,
 +						    bat_priv->tt_global_hash,
 +						    primary_if,
 +						    batadv_tt_global_valid,
 +						    req_dst_orig_node);
    	if (!skb)
    		goto out;
-		tt_response = (struct tt_query_packet *)skb->data;
 +		tt_response = (struct batadv_tt_query_packet *)skb->data;
    }
-	tt_response->header.packet_type = BAT_TT_QUERY;
 -	tt_response->header.version = COMPAT_VERSION;
 -	tt_response->header.ttl = TTL;
 +	tt_response->header.packet_type = BATADV_TT_QUERY;
 +	tt_response->header.version = BATADV_COMPAT_VERSION;
 +	tt_response->header.ttl = BATADV_TTL;
    memcpy(tt_response->src, req_dst_orig_node->orig, ETH_ALEN);
    memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
 -	tt_response->flags = TT_RESPONSE;
 +	tt_response->flags = BATADV_TT_RESPONSE;
if (full_table)
 -		tt_response->flags |= TT_FULL_TABLE;
 +		tt_response->flags |= BATADV_TT_FULL_TABLE;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
 -		res_dst_orig_node->orig, neigh_node->addr,
 -		req_dst_orig_node->orig, req_ttvn);
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
 +		   res_dst_orig_node->orig, neigh_node->addr,
 +		   req_dst_orig_node->orig, req_ttvn);
-	send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
 +	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
 +
 +	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
    ret = true;
    goto out;
@@@ -1635,122 -1489,114 +1635,122 @@@ unlock
out:
    if (res_dst_orig_node)
 -		orig_node_free_ref(res_dst_orig_node);
 +		batadv_orig_node_free_ref(res_dst_orig_node);
    if (req_dst_orig_node)
 -		orig_node_free_ref(req_dst_orig_node);
 +		batadv_orig_node_free_ref(req_dst_orig_node);
    if (neigh_node)
 -		neigh_node_free_ref(neigh_node);
 +		batadv_neigh_node_free_ref(neigh_node);
    if (primary_if)
 -		hardif_free_ref(primary_if);
 +		batadv_hardif_free_ref(primary_if);
    if (!ret)
    	kfree_skb(skb);
    return ret;
}
 -static bool send_my_tt_response(struct bat_priv *bat_priv,
 -				struct tt_query_packet *tt_request)
 +
 +static bool
 +batadv_send_my_tt_response(struct batadv_priv *bat_priv,
 +			   struct batadv_tt_query_packet *tt_request)
  {
 -	struct orig_node *orig_node = NULL;
 -	struct neigh_node *neigh_node = NULL;
 -	struct hard_iface *primary_if = NULL;
 +	struct batadv_orig_node *orig_node = NULL;
 +	struct batadv_neigh_node *neigh_node = NULL;
 +	struct batadv_hard_iface *primary_if = NULL;
    uint8_t my_ttvn, req_ttvn, ttvn;
    int ret = false;
    unsigned char *tt_buff;
    bool full_table;
    uint16_t tt_len, tt_tot;
    struct sk_buff *skb = NULL;
 -	struct tt_query_packet *tt_response;
 +	struct batadv_tt_query_packet *tt_response;
 +	size_t len;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
 -		tt_request->src, tt_request->ttvn,
 -		(tt_request->flags & TT_FULL_TABLE ? 'F' : '.'));
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
 +		   tt_request->src, tt_request->ttvn,
 +		   (tt_request->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
my_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
    req_ttvn = tt_request->ttvn;
-	orig_node = orig_hash_find(bat_priv, tt_request->src);
 +	orig_node = batadv_orig_hash_find(bat_priv, tt_request->src);
    if (!orig_node)
    	goto out;
-	neigh_node = orig_node_get_router(orig_node);
 +	neigh_node = batadv_orig_node_get_router(orig_node);
    if (!neigh_node)
    	goto out;
-	primary_if = primary_if_get_selected(bat_priv);
 +	primary_if = batadv_primary_if_get_selected(bat_priv);
    if (!primary_if)
    	goto out;
/* If the full table has been explicitly requested or the gap
 -	 * is too big send the whole local translation table */
 -	if (tt_request->flags & TT_FULL_TABLE || my_ttvn != req_ttvn ||
 +	 * is too big send the whole local translation table
 +	 */
 +	if (tt_request->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
        !bat_priv->tt_buff)
    	full_table = true;
    else
    	full_table = false;
/* In this version, fragmentation is not implemented, then
 -	 * I'll send only one packet with as much TT entries as I can */
 +	 * I'll send only one packet with as much TT entries as I can
 +	 */
    if (!full_table) {
    	spin_lock_bh(&bat_priv->tt_buff_lock);
    	tt_len = bat_priv->tt_buff_len;
 -		tt_tot = tt_len / sizeof(struct tt_change);
 +		tt_tot = tt_len / sizeof(struct batadv_tt_change);
-		skb = dev_alloc_skb(sizeof(struct tt_query_packet) +
 -				    tt_len + ETH_HLEN);
 +		len = sizeof(*tt_response) + tt_len;
 +		skb = dev_alloc_skb(len + ETH_HLEN);
    	if (!skb)
    		goto unlock;
skb_reserve(skb, ETH_HLEN);
 -		tt_response = (struct tt_query_packet *)skb_put(skb,
 -				sizeof(struct tt_query_packet) + tt_len);
 +		tt_response = (struct batadv_tt_query_packet *)skb_put(skb,
 +								       len);
    	tt_response->ttvn = req_ttvn;
    	tt_response->tt_data = htons(tt_tot);
-		tt_buff = skb->data + sizeof(struct tt_query_packet);
 +		tt_buff = skb->data + sizeof(*tt_response);
    	memcpy(tt_buff, bat_priv->tt_buff,
    	       bat_priv->tt_buff_len);
    	spin_unlock_bh(&bat_priv->tt_buff_lock);
    } else {
 -		tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt) *
 -						sizeof(struct tt_change);
 +		tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt);
 +		tt_len *= sizeof(struct batadv_tt_change);
    	ttvn = (uint8_t)atomic_read(&bat_priv->ttvn);
-		skb = tt_response_fill_table(tt_len, ttvn,
 -					     bat_priv->tt_local_hash,
 -					     primary_if, tt_local_valid_entry,
 -					     NULL);
 +		skb = batadv_tt_response_fill_table(tt_len, ttvn,
 +						    bat_priv->tt_local_hash,
 +						    primary_if,
 +						    batadv_tt_local_valid_entry,
 +						    NULL);
    	if (!skb)
    		goto out;
-		tt_response = (struct tt_query_packet *)skb->data;
 +		tt_response = (struct batadv_tt_query_packet *)skb->data;
    }
-	tt_response->header.packet_type = BAT_TT_QUERY;
 -	tt_response->header.version = COMPAT_VERSION;
 -	tt_response->header.ttl = TTL;
 +	tt_response->header.packet_type = BATADV_TT_QUERY;
 +	tt_response->header.version = BATADV_COMPAT_VERSION;
 +	tt_response->header.ttl = BATADV_TTL;
    memcpy(tt_response->src, primary_if->net_dev->dev_addr, ETH_ALEN);
    memcpy(tt_response->dst, tt_request->src, ETH_ALEN);
 -	tt_response->flags = TT_RESPONSE;
 +	tt_response->flags = BATADV_TT_RESPONSE;
if (full_table)
 -		tt_response->flags |= TT_FULL_TABLE;
 +		tt_response->flags |= BATADV_TT_FULL_TABLE;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Sending TT_RESPONSE to %pM via %pM [%c]\n",
 -		orig_node->orig, neigh_node->addr,
 -		(tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Sending TT_RESPONSE to %pM via %pM [%c]\n",
 +		   orig_node->orig, neigh_node->addr,
 +		   (tt_response->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
-	send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
 +	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
 +
 +	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
    ret = true;
    goto out;
@@@ -1758,50 -1604,49 +1758,50 @@@ unlock
    spin_unlock_bh(&bat_priv->tt_buff_lock);
  out:
    if (orig_node)
 -		orig_node_free_ref(orig_node);
 +		batadv_orig_node_free_ref(orig_node);
    if (neigh_node)
 -		neigh_node_free_ref(neigh_node);
 +		batadv_neigh_node_free_ref(neigh_node);
    if (primary_if)
 -		hardif_free_ref(primary_if);
 +		batadv_hardif_free_ref(primary_if);
    if (!ret)
    	kfree_skb(skb);
    /* This packet was for me, so it doesn't need to be re-routed */
    return true;
  }
-bool send_tt_response(struct bat_priv *bat_priv,
 -		      struct tt_query_packet *tt_request)
 +bool batadv_send_tt_response(struct batadv_priv *bat_priv,
 +			     struct batadv_tt_query_packet *tt_request)
  {
 -	if (is_my_mac(tt_request->dst)) {
 +	if (batadv_is_my_mac(tt_request->dst)) {
    	/* don't answer backbone gws! */
 -		if (bla_is_backbone_gw_orig(bat_priv, tt_request->src))
 +		if (batadv_bla_is_backbone_gw_orig(bat_priv, tt_request->src))
    		return true;
-		return send_my_tt_response(bat_priv, tt_request);
 +		return batadv_send_my_tt_response(bat_priv, tt_request);
    } else {
 -		return send_other_tt_response(bat_priv, tt_request);
 +		return batadv_send_other_tt_response(bat_priv, tt_request);
    }
  }
-static void _tt_update_changes(struct bat_priv *bat_priv,
 -			       struct orig_node *orig_node,
 -			       struct tt_change *tt_change,
 -			       uint16_t tt_num_changes, uint8_t ttvn)
 +static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
 +				      struct batadv_orig_node *orig_node,
 +				      struct batadv_tt_change *tt_change,
 +				      uint16_t tt_num_changes, uint8_t ttvn)
  {
    int i;
 +	int roams;
for (i = 0; i < tt_num_changes; i++) {
 -		if ((tt_change + i)->flags & TT_CLIENT_DEL)
 -			tt_global_del(bat_priv, orig_node,
 -				      (tt_change + i)->addr,
 -				      "tt removed by changes",
 -				      (tt_change + i)->flags & TT_CLIENT_ROAM);
 -		else
 -			if (!tt_global_add(bat_priv, orig_node,
 -					   (tt_change + i)->addr, ttvn, false,
 -					   (tt_change + i)->flags &
 -							TT_CLIENT_WIFI))
 +		if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
 +			roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
 +			batadv_tt_global_del(bat_priv, orig_node,
 +					     (tt_change + i)->addr,
 +					     "tt removed by changes",
 +					     roams);
 +		} else {
 +			if (!batadv_tt_global_add(bat_priv, orig_node,
 +						  (tt_change + i)->addr,
 +						  (tt_change + i)->flags, ttvn))
    			/* In case of problem while storing a
    			 * global_entry, we stop the updating
    			 * procedure without committing the
@@@ -1809,27 -1654,25 +1809,27 @@@
    			 * corrupted data on tt_request
    			 */
    			return;
 +		}
    }
    orig_node->tt_initialised = true;
  }
-static void tt_fill_gtable(struct bat_priv *bat_priv,
 -			   struct tt_query_packet *tt_response)
 +static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
 +				  struct batadv_tt_query_packet *tt_response)
  {
 -	struct orig_node *orig_node = NULL;
 +	struct batadv_orig_node *orig_node = NULL;
-	orig_node = orig_hash_find(bat_priv, tt_response->src);
 +	orig_node = batadv_orig_hash_find(bat_priv, tt_response->src);
    if (!orig_node)
    	goto out;
/* Purge the old table first.. */
 -	tt_global_del_orig(bat_priv, orig_node, "Received full table");
 +	batadv_tt_global_del_orig(bat_priv, orig_node, "Received full table");
-	_tt_update_changes(bat_priv, orig_node,
 -			   (struct tt_change *)(tt_response + 1),
 -			   tt_response->tt_data, tt_response->ttvn);
 +	_batadv_tt_update_changes(bat_priv, orig_node,
 +				  (struct batadv_tt_change *)(tt_response + 1),
 +				  ntohs(tt_response->tt_data),
 +				  tt_response->ttvn);
spin_lock_bh(&orig_node->tt_buff_lock);
    kfree(orig_node->tt_buff);
@@@ -1841,76 -1684,71 +1841,76 @@@
out:
    if (orig_node)
 -		orig_node_free_ref(orig_node);
 +		batadv_orig_node_free_ref(orig_node);
  }
-static void tt_update_changes(struct bat_priv *bat_priv,
 -			      struct orig_node *orig_node,
 -			      uint16_t tt_num_changes, uint8_t ttvn,
 -			      struct tt_change *tt_change)
 +static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
 +				     struct batadv_orig_node *orig_node,
 +				     uint16_t tt_num_changes, uint8_t ttvn,
 +				     struct batadv_tt_change *tt_change)
  {
 -	_tt_update_changes(bat_priv, orig_node, tt_change, tt_num_changes,
 -			   ttvn);
 +	_batadv_tt_update_changes(bat_priv, orig_node, tt_change,
 +				  tt_num_changes, ttvn);
-	tt_save_orig_buffer(bat_priv, orig_node, (unsigned char *)tt_change,
 -			    tt_num_changes);
 +	batadv_tt_save_orig_buffer(bat_priv, orig_node,
 +				   (unsigned char *)tt_change, tt_num_changes);
    atomic_set(&orig_node->last_ttvn, ttvn);
  }
-bool is_my_client(struct bat_priv *bat_priv, const uint8_t *addr)
 +bool batadv_is_my_client(struct batadv_priv *bat_priv, const uint8_t *addr)
  {
 -	struct tt_local_entry *tt_local_entry = NULL;
 +	struct batadv_tt_local_entry *tt_local_entry = NULL;
    bool ret = false;
-	tt_local_entry = tt_local_hash_find(bat_priv, addr);
 +	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr);
    if (!tt_local_entry)
    	goto out;
    /* Check if the client has been logically deleted (but is kept for
 -	 * consistency purpose) */
 -	if (tt_local_entry->common.flags & TT_CLIENT_PENDING)
 +	 * consistency purpose)
 +	 */
 +	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
    	goto out;
    ret = true;
  out:
    if (tt_local_entry)
 -		tt_local_entry_free_ref(tt_local_entry);
 +		batadv_tt_local_entry_free_ref(tt_local_entry);
    return ret;
  }
-void handle_tt_response(struct bat_priv *bat_priv,
 -			struct tt_query_packet *tt_response)
 +void batadv_handle_tt_response(struct batadv_priv *bat_priv,
 +			       struct batadv_tt_query_packet *tt_response)
  {
 -	struct tt_req_node *node, *safe;
 -	struct orig_node *orig_node = NULL;
 +	struct batadv_tt_req_node *node, *safe;
 +	struct batadv_orig_node *orig_node = NULL;
 +	struct batadv_tt_change *tt_change;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
 -		tt_response->src, tt_response->ttvn, tt_response->tt_data,
 -		(tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
 +		   tt_response->src, tt_response->ttvn,
 +		   ntohs(tt_response->tt_data),
 +		   (tt_response->flags & BATADV_TT_FULL_TABLE ? 'F' : '.'));
/* we should have never asked a backbone gw */
 -	if (bla_is_backbone_gw_orig(bat_priv, tt_response->src))
 +	if (batadv_bla_is_backbone_gw_orig(bat_priv, tt_response->src))
    	goto out;
-	orig_node = orig_hash_find(bat_priv, tt_response->src);
 +	orig_node = batadv_orig_hash_find(bat_priv, tt_response->src);
    if (!orig_node)
    	goto out;
-	if (tt_response->flags & TT_FULL_TABLE)
 -		tt_fill_gtable(bat_priv, tt_response);
 -	else
 -		tt_update_changes(bat_priv, orig_node, tt_response->tt_data,
 -				  tt_response->ttvn,
 -				  (struct tt_change *)(tt_response + 1));
 +	if (tt_response->flags & BATADV_TT_FULL_TABLE) {
 +		batadv_tt_fill_gtable(bat_priv, tt_response);
 +	} else {
 +		tt_change = (struct batadv_tt_change *)(tt_response + 1);
 +		batadv_tt_update_changes(bat_priv, orig_node,
 +					 ntohs(tt_response->tt_data),
 +					 tt_response->ttvn, tt_change);
 +	}
/* Delete the tt_req_node from pending tt_requests list */
    spin_lock_bh(&bat_priv->tt_req_list_lock);
    list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) {
 -		if (!compare_eth(node->addr, tt_response->src))
 +		if (!batadv_compare_eth(node->addr, tt_response->src))
    		continue;
    	list_del(&node->list);
    	kfree(node);
@@@ -1918,36 -1756,31 +1918,36 @@@
    spin_unlock_bh(&bat_priv->tt_req_list_lock);
/* Recalculate the CRC for this orig_node and store it */
 -	orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
 +	orig_node->tt_crc = batadv_tt_global_crc(bat_priv, orig_node);
    /* Roaming phase is over: tables are in sync again. I can
 -	 * unset the flag */
 +	 * unset the flag
 +	 */
    orig_node->tt_poss_change = false;
  out:
    if (orig_node)
 -		orig_node_free_ref(orig_node);
 +		batadv_orig_node_free_ref(orig_node);
  }
-int tt_init(struct bat_priv *bat_priv)
 +int batadv_tt_init(struct batadv_priv *bat_priv)
  {
 -	if (!tt_local_init(bat_priv))
 -		return 0;
 +	int ret;
-	if (!tt_global_init(bat_priv))
 -		return 0;
 +	ret = batadv_tt_local_init(bat_priv);
 +	if (ret < 0)
 +		return ret;
-	tt_start_timer(bat_priv);
 +	ret = batadv_tt_global_init(bat_priv);
 +	if (ret < 0)
 +		return ret;
 +
 +	batadv_tt_start_timer(bat_priv);
return 1;
  }
-static void tt_roam_list_free(struct bat_priv *bat_priv)
 +static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
  {
 -	struct tt_roam_node *node, *safe;
 +	struct batadv_tt_roam_node *node, *safe;
spin_lock_bh(&bat_priv->tt_roam_list_lock);
@@@ -1959,14 -1792,13 +1959,14 @@@
    spin_unlock_bh(&bat_priv->tt_roam_list_lock);
  }
-static void tt_roam_purge(struct bat_priv *bat_priv)
 +static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
  {
 -	struct tt_roam_node *node, *safe;
 +	struct batadv_tt_roam_node *node, *safe;
spin_lock_bh(&bat_priv->tt_roam_list_lock);
    list_for_each_entry_safe(node, safe, &bat_priv->tt_roam_list, list) {
 -		if (!has_timed_out(node->first_time, ROAMING_MAX_TIME))
 +		if (!batadv_has_timed_out(node->first_time,
 +					  BATADV_ROAMING_MAX_TIME))
    		continue;
list_del(&node->list);
@@@ -1979,27 -1811,24 +1979,27 @@@
   * maximum number of possible roaming phases. In this case the ROAMING_ADV
   * will not be sent.
   *
 - * returns true if the ROAMING_ADV can be sent, false otherwise */
 -static bool tt_check_roam_count(struct bat_priv *bat_priv,
 -				uint8_t *client)
 + * returns true if the ROAMING_ADV can be sent, false otherwise
 + */
 +static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv,
 +				       uint8_t *client)
  {
 -	struct tt_roam_node *tt_roam_node;
 +	struct batadv_tt_roam_node *tt_roam_node;
    bool ret = false;
spin_lock_bh(&bat_priv->tt_roam_list_lock);
    /* The new tt_req will be issued only if I'm not waiting for a
 -	 * reply from the same orig_node yet */
 +	 * reply from the same orig_node yet
 +	 */
    list_for_each_entry(tt_roam_node, &bat_priv->tt_roam_list, list) {
 -		if (!compare_eth(tt_roam_node->addr, client))
 +		if (!batadv_compare_eth(tt_roam_node->addr, client))
    		continue;
-		if (has_timed_out(tt_roam_node->first_time, ROAMING_MAX_TIME))
 +		if (batadv_has_timed_out(tt_roam_node->first_time,
 +					 BATADV_ROAMING_MAX_TIME))
    		continue;
-		if (!atomic_dec_not_zero(&tt_roam_node->counter))
 +		if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
    		/* Sorry, you roamed too many times! */
    		goto unlock;
    	ret = true;
@@@ -2012,8 -1841,7 +2012,8 @@@
    		goto unlock;
tt_roam_node->first_time = jiffies;
 -		atomic_set(&tt_roam_node->counter, ROAMING_MAX_COUNT - 1);
 +		atomic_set(&tt_roam_node->counter,
 +			   BATADV_ROAMING_MAX_COUNT - 1);
    	memcpy(tt_roam_node->addr, client, ETH_ALEN);
list_add(&tt_roam_node->list, &bat_priv->tt_roam_list);
@@@ -2025,102 -1853,97 +2025,102 @@@ unlock
    return ret;
  }
-static void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client,
 -			  struct orig_node *orig_node)
 +static void batadv_send_roam_adv(struct batadv_priv *bat_priv, uint8_t *client,
 +				 struct batadv_orig_node *orig_node)
  {
 -	struct neigh_node *neigh_node = NULL;
 +	struct batadv_neigh_node *neigh_node = NULL;
    struct sk_buff *skb = NULL;
 -	struct roam_adv_packet *roam_adv_packet;
 +	struct batadv_roam_adv_packet *roam_adv_packet;
    int ret = 1;
 -	struct hard_iface *primary_if;
 +	struct batadv_hard_iface *primary_if;
 +	size_t len = sizeof(*roam_adv_packet);
/* before going on we have to check whether the client has
 -	 * already roamed to us too many times */
 -	if (!tt_check_roam_count(bat_priv, client))
 +	 * already roamed to us too many times
 +	 */
 +	if (!batadv_tt_check_roam_count(bat_priv, client))
    	goto out;
-	skb = dev_alloc_skb(sizeof(struct roam_adv_packet) + ETH_HLEN);
 +	skb = dev_alloc_skb(sizeof(*roam_adv_packet) + ETH_HLEN);
    if (!skb)
    	goto out;
skb_reserve(skb, ETH_HLEN);
-	roam_adv_packet = (struct roam_adv_packet *)skb_put(skb,
 -					sizeof(struct roam_adv_packet));
 +	roam_adv_packet = (struct batadv_roam_adv_packet *)skb_put(skb, len);
-	roam_adv_packet->header.packet_type = BAT_ROAM_ADV;
 -	roam_adv_packet->header.version = COMPAT_VERSION;
 -	roam_adv_packet->header.ttl = TTL;
 -	primary_if = primary_if_get_selected(bat_priv);
 +	roam_adv_packet->header.packet_type = BATADV_ROAM_ADV;
 +	roam_adv_packet->header.version = BATADV_COMPAT_VERSION;
 +	roam_adv_packet->header.ttl = BATADV_TTL;
 +	primary_if = batadv_primary_if_get_selected(bat_priv);
    if (!primary_if)
    	goto out;
    memcpy(roam_adv_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
 -	hardif_free_ref(primary_if);
 +	batadv_hardif_free_ref(primary_if);
    memcpy(roam_adv_packet->dst, orig_node->orig, ETH_ALEN);
    memcpy(roam_adv_packet->client, client, ETH_ALEN);
-	neigh_node = orig_node_get_router(orig_node);
 +	neigh_node = batadv_orig_node_get_router(orig_node);
    if (!neigh_node)
    	goto out;
-	bat_dbg(DBG_TT, bat_priv,
 -		"Sending ROAMING_ADV to %pM (client %pM) via %pM\n",
 -		orig_node->orig, client, neigh_node->addr);
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Sending ROAMING_ADV to %pM (client %pM) via %pM\n",
 +		   orig_node->orig, client, neigh_node->addr);
 +
 +	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
-	send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
 +	batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr);
    ret = 0;
out:
    if (neigh_node)
 -		neigh_node_free_ref(neigh_node);
 +		batadv_neigh_node_free_ref(neigh_node);
    if (ret)
    	kfree_skb(skb);
    return;
  }
-static void tt_purge(struct work_struct *work)
 +static void batadv_tt_purge(struct work_struct *work)
  {
 -	struct delayed_work *delayed_work =
 -		container_of(work, struct delayed_work, work);
 -	struct bat_priv *bat_priv =
 -		container_of(delayed_work, struct bat_priv, tt_work);
 +	struct delayed_work *delayed_work;
 +	struct batadv_priv *bat_priv;
-	tt_local_purge(bat_priv);
 -	tt_global_roam_purge(bat_priv);
 -	tt_req_purge(bat_priv);
 -	tt_roam_purge(bat_priv);
 +	delayed_work = container_of(work, struct delayed_work, work);
 +	bat_priv = container_of(delayed_work, struct batadv_priv, tt_work);
-	tt_start_timer(bat_priv);
 +	batadv_tt_local_purge(bat_priv);
 +	batadv_tt_global_roam_purge(bat_priv);
 +	batadv_tt_req_purge(bat_priv);
 +	batadv_tt_roam_purge(bat_priv);
 +
 +	batadv_tt_start_timer(bat_priv);
  }
-void tt_free(struct bat_priv *bat_priv)
 +void batadv_tt_free(struct batadv_priv *bat_priv)
  {
    cancel_delayed_work_sync(&bat_priv->tt_work);
-	tt_local_table_free(bat_priv);
 -	tt_global_table_free(bat_priv);
 -	tt_req_list_free(bat_priv);
 -	tt_changes_list_free(bat_priv);
 -	tt_roam_list_free(bat_priv);
 +	batadv_tt_local_table_free(bat_priv);
 +	batadv_tt_global_table_free(bat_priv);
 +	batadv_tt_req_list_free(bat_priv);
 +	batadv_tt_changes_list_free(bat_priv);
 +	batadv_tt_roam_list_free(bat_priv);
kfree(bat_priv->tt_buff);
  }
/* This function will enable or disable the specified flags for all the entries
 - * in the given hash table and returns the number of modified entries */
 -static uint16_t tt_set_flags(struct hashtable_t *hash, uint16_t flags,
 -			     bool enable)
 + * in the given hash table and returns the number of modified entries
 + */
 +static uint16_t batadv_tt_set_flags(struct batadv_hashtable *hash,
 +				    uint16_t flags, bool enable)
  {
    uint32_t i;
    uint16_t changed_num = 0;
    struct hlist_head *head;
    struct hlist_node *node;
 -	struct tt_common_entry *tt_common_entry;
 +	struct batadv_tt_common_entry *tt_common_entry;
if (!hash)
    	goto out;
@@@ -2148,12 -1971,12 +2148,12 @@@ out
    return changed_num;
  }
-/* Purge out all the tt local entries marked with TT_CLIENT_PENDING */
 -static void tt_local_purge_pending_clients(struct bat_priv *bat_priv)
 +/* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */
 +static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
  {
 -	struct hashtable_t *hash = bat_priv->tt_local_hash;
 -	struct tt_common_entry *tt_common_entry;
 -	struct tt_local_entry *tt_local_entry;
 +	struct batadv_hashtable *hash = bat_priv->tt_local_hash;
 +	struct batadv_tt_common_entry *tt_common;
 +	struct batadv_tt_local_entry *tt_local;
    struct hlist_node *node, *node_tmp;
    struct hlist_head *head;
    spinlock_t *list_lock; /* protects write access to the hash lists */
@@@ -2167,149 -1990,103 +2167,149 @@@
    	list_lock = &hash->list_locks[i];
spin_lock_bh(list_lock);
 -		hlist_for_each_entry_safe(tt_common_entry, node, node_tmp,
 -					  head, hash_entry) {
 -			if (!(tt_common_entry->flags & TT_CLIENT_PENDING))
 +		hlist_for_each_entry_safe(tt_common, node, node_tmp, head,
 +					  hash_entry) {
 +			if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
    			continue;
-			bat_dbg(DBG_TT, bat_priv,
 -				"Deleting local tt entry (%pM): pending\n",
 -				tt_common_entry->addr);
 +			batadv_dbg(BATADV_DBG_TT, bat_priv,
 +				   "Deleting local tt entry (%pM): pending\n",
 +				   tt_common->addr);
atomic_dec(&bat_priv->num_local_tt);
    		hlist_del_rcu(node);
 -			tt_local_entry = container_of(tt_common_entry,
 -						      struct tt_local_entry,
 -						      common);
 -			tt_local_entry_free_ref(tt_local_entry);
 +			tt_local = container_of(tt_common,
 +						struct batadv_tt_local_entry,
 +						common);
 +			batadv_tt_local_entry_free_ref(tt_local);
    	}
    	spin_unlock_bh(list_lock);
    }
}
-void tt_commit_changes(struct bat_priv *bat_priv)
 +static int batadv_tt_commit_changes(struct batadv_priv *bat_priv,
 +				    unsigned char **packet_buff,
 +				    int *packet_buff_len, int packet_min_len)
  {
 -	uint16_t changed_num = tt_set_flags(bat_priv->tt_local_hash,
 -					    TT_CLIENT_NEW, false);
 -	/* all the reset entries have now to be effectively counted as local
 -	 * entries */
 +	uint16_t changed_num = 0;
 +
 +	if (atomic_read(&bat_priv->tt_local_changes) < 1)
 +		return -ENOENT;
 +
 +	changed_num = batadv_tt_set_flags(bat_priv->tt_local_hash,
 +					  BATADV_TT_CLIENT_NEW, false);
 +
 +	/* all reset entries have to be counted as local entries */
    atomic_add(changed_num, &bat_priv->num_local_tt);
 -	tt_local_purge_pending_clients(bat_priv);
 +	batadv_tt_local_purge_pending_clients(bat_priv);
 +	bat_priv->tt_crc = batadv_tt_local_crc(bat_priv);
/* Increment the TTVN only once per OGM interval */
    atomic_inc(&bat_priv->ttvn);
 -	bat_dbg(DBG_TT, bat_priv, "Local changes committed, updating to ttvn %u\n",
 -		(uint8_t)atomic_read(&bat_priv->ttvn));
 +	batadv_dbg(BATADV_DBG_TT, bat_priv,
 +		   "Local changes committed, updating to ttvn %u\n",
 +		   (uint8_t)atomic_read(&bat_priv->ttvn));
    bat_priv->tt_poss_change = false;
 +
 +	/* reset the sending counter */
 +	atomic_set(&bat_priv->tt_ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
 +
 +	return batadv_tt_changes_fill_buff(bat_priv, packet_buff,
 +					   packet_buff_len, packet_min_len);
 +}
 +
 +/* when calling this function (hard_iface == primary_if) has to be true */
 +int batadv_tt_append_diff(struct batadv_priv *bat_priv,
 +			  unsigned char **packet_buff, int *packet_buff_len,
 +			  int packet_min_len)
 +{
 +	int tt_num_changes;
 +
 +	/* if at least one change happened */
 +	tt_num_changes = batadv_tt_commit_changes(bat_priv, packet_buff,
 +						  packet_buff_len,
 +						  packet_min_len);
 +
 +	/* if the changes have been sent often enough */
 +	if ((tt_num_changes < 0) &&
 +	    (!batadv_atomic_dec_not_zero(&bat_priv->tt_ogm_append_cnt))) {
 +		batadv_tt_realloc_packet_buff(packet_buff, packet_buff_len,
 +					      packet_min_len, packet_min_len);
 +		tt_num_changes = 0;
 +	}
 +
 +	return tt_num_changes;
  }
-bool is_ap_isolated(struct bat_priv *bat_priv, uint8_t *src, uint8_t *dst)
 +bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, uint8_t *src,
 +			   uint8_t *dst)
  {
 -	struct tt_local_entry *tt_local_entry = NULL;
 -	struct tt_global_entry *tt_global_entry = NULL;
 +	struct batadv_tt_local_entry *tt_local_entry = NULL;
 +	struct batadv_tt_global_entry *tt_global_entry = NULL;
- 	bool ret = true;
+ 	bool ret = false;
if (!atomic_read(&bat_priv->ap_isolation))
- 		return false;
+ 		goto out;
-	tt_local_entry = tt_local_hash_find(bat_priv, dst);
 +	tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst);
    if (!tt_local_entry)
    	goto out;
-	tt_global_entry = tt_global_hash_find(bat_priv, src);
 +	tt_global_entry = batadv_tt_global_hash_find(bat_priv, src);
    if (!tt_global_entry)
    	goto out;
- 	if (_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
 -	if (!_is_ap_isolated(tt_local_entry, tt_global_entry))
++	if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
    	goto out;
- 	ret = false;
+ 	ret = true;
out:
    if (tt_global_entry)
 -		tt_global_entry_free_ref(tt_global_entry);
 +		batadv_tt_global_entry_free_ref(tt_global_entry);
    if (tt_local_entry)
 -		tt_local_entry_free_ref(tt_local_entry);
 +		batadv_tt_local_entry_free_ref(tt_local_entry);
    return ret;
  }
-void tt_update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node,
 -		    const unsigned char *tt_buff, uint8_t tt_num_changes,
 -		    uint8_t ttvn, uint16_t tt_crc)
 +void batadv_tt_update_orig(struct batadv_priv *bat_priv,
 +			   struct batadv_orig_node *orig_node,
 +			   const unsigned char *tt_buff, uint8_t tt_num_changes,
 +			   uint8_t ttvn, uint16_t tt_crc)
  {
    uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
    bool full_table = true;
 +	struct batadv_tt_change *tt_change;
/* don't care about a backbone gateways updates. */
 -	if (bla_is_backbone_gw_orig(bat_priv, orig_node->orig))
 +	if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig))
    	return;
/* orig table not initialised AND first diff is in the OGM OR the ttvn
 -	 * increased by one -> we can apply the attached changes */
 +	 * increased by one -> we can apply the attached changes
 +	 */
    if ((!orig_node->tt_initialised && ttvn == 1) ||
        ttvn - orig_ttvn == 1) {
    	/* the OGM could not contain the changes due to their size or
 -		 * because they have already been sent TT_OGM_APPEND_MAX times.
 -		 * In this case send a tt request */
 +		 * because they have already been sent BATADV_TT_OGM_APPEND_MAX
 +		 * times.
 +		 * In this case send a tt request
 +		 */
    	if (!tt_num_changes) {
    		full_table = false;
    		goto request_table;
    	}
-		tt_update_changes(bat_priv, orig_node, tt_num_changes, ttvn,
 -				  (struct tt_change *)tt_buff);
 +		tt_change = (struct batadv_tt_change *)tt_buff;
 +		batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
 +					 ttvn, tt_change);
/* Even if we received the precomputed crc with the OGM, we
    	 * prefer to recompute it to spot any possible inconsistency
 -		 * in the global table */
 -		orig_node->tt_crc = tt_global_crc(bat_priv, orig_node);
 +		 * in the global table
 +		 */
 +		orig_node->tt_crc = batadv_tt_global_crc(bat_priv, orig_node);
/* The ttvn alone is not enough to guarantee consistency
    	 * because a single value could represent different states
@@@ -2318,28 -2095,26 +2318,28 @@@
    	 * consistent or not. E.g. a node could disconnect while its
    	 * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
    	 * checking the CRC value is mandatory to detect the
 -		 * inconsistency */
 +		 * inconsistency
 +		 */
    	if (orig_node->tt_crc != tt_crc)
    		goto request_table;
/* Roaming phase is over: tables are in sync again. I can
 -		 * unset the flag */
 +		 * unset the flag
 +		 */
    	orig_node->tt_poss_change = false;
    } else {
    	/* if we missed more than one change or our tables are not
 -		 * in sync anymore -> request fresh tt data */
 -
 +		 * in sync anymore -> request fresh tt data
 +		 */
    	if (!orig_node->tt_initialised || ttvn != orig_ttvn ||
    	    orig_node->tt_crc != tt_crc) {
  request_table:
 -			bat_dbg(DBG_TT, bat_priv,
 -				"TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u crc: %u last_crc: %u num_changes: %u)\n",
 -				orig_node->orig, ttvn, orig_ttvn, tt_crc,
 -				orig_node->tt_crc, tt_num_changes);
 -			send_tt_request(bat_priv, orig_node, ttvn, tt_crc,
 -					full_table);
 +			batadv_dbg(BATADV_DBG_TT, bat_priv,
 +				   "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u crc: %u last_crc: %u num_changes: %u)\n",
 +				   orig_node->orig, ttvn, orig_ttvn, tt_crc,
 +				   orig_node->tt_crc, tt_num_changes);
 +			batadv_send_tt_request(bat_priv, orig_node, ttvn,
 +					       tt_crc, full_table);
    		return;
    	}
    }
@@@ -2349,18 -2124,17 +2349,18 @@@
   * originator to another one. This entry is kept is still kept for consistency
   * purposes
   */
 -bool tt_global_client_is_roaming(struct bat_priv *bat_priv, uint8_t *addr)
 +bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
 +					uint8_t *addr)
  {
 -	struct tt_global_entry *tt_global_entry;
 +	struct batadv_tt_global_entry *tt_global_entry;
    bool ret = false;
-	tt_global_entry = tt_global_hash_find(bat_priv, addr);
 +	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr);
    if (!tt_global_entry)
    	goto out;
-	ret = tt_global_entry->common.flags & TT_CLIENT_ROAM;
 -	tt_global_entry_free_ref(tt_global_entry);
 +	ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;
 +	batadv_tt_global_entry_free_ref(tt_global_entry);
  out:
    return ret;
  }
-- 
batman-adv

    

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

[commits] batman-adv; branch, next, updated. v2012.2.0-129-gd03cfc8