[linux-next] LinuxNextTracking branch, master, updated. next-20120626

batman at open-mesh.org batman at open-mesh.org
Wed Jun 27 00:17:12 CEST 2012


The following commit has been merged in the master branch:
commit 1d5873e9d75bb72012a6c1327a368d0d2b13581f
Merge: 7665de15642dfb1709177517aa0488162727342c a513088d022c8f59cebe17c567797c220563b517
Author: David S. Miller <davem at davemloft.net>
Date:   Mon Jun 25 16:15:58 2012 -0700

    Merge tag 'batman-adv-for-davem' of git://git.open-mesh.org/linux-merge
    
    Included changes:
    - yet another batch of 'namespace cleaning' patches
    
    Conflicts:
    	net/batman-adv/translation-table.c
    
    Signed-off-by: David S. Miller <davem at davemloft.net>

diff --combined net/batman-adv/translation-table.c
index 3806d9b,f7a6152..cf79883
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@@ -29,13 -29,14 +29,14 @@@
  
  #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 bat_priv *bat_priv, uint8_t *client,
+ 				 struct orig_node *orig_node);
+ static void batadv_tt_purge(struct work_struct *work);
+ static void
+ batadv_tt_global_del_orig_list(struct 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,
  					 hash_entry);
@@@ -43,15 -44,15 +44,15 @@@
  	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 bat_priv *bat_priv)
  {
- 	INIT_DELAYED_WORK(&bat_priv->tt_work, tt_purge);
+ 	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 tt_common_entry *batadv_tt_hash_find(struct hashtable_t *hash,
+ 						   const void *data)
  {
  	struct hlist_head *head;
  	struct hlist_node *node;
@@@ -61,12 -62,12 +62,12 @@@
  	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))
@@@ -80,26 -81,26 +81,26 @@@
  	return tt_common_entry_tmp;
  }
  
- static struct tt_local_entry *tt_local_hash_find(struct bat_priv *bat_priv,
- 						 const void *data)
+ static struct tt_local_entry *
+ batadv_tt_local_hash_find(struct bat_priv *bat_priv, const void *data)
  {
  	struct tt_common_entry *tt_common_entry;
  	struct 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);
  	return tt_local_entry;
  }
  
- static struct tt_global_entry *tt_global_hash_find(struct bat_priv *bat_priv,
- 						   const void *data)
+ static struct tt_global_entry *
+ batadv_tt_global_hash_find(struct bat_priv *bat_priv, const void *data)
  {
  	struct tt_common_entry *tt_common_entry;
  	struct 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);
@@@ -107,13 -108,14 +108,14 @@@
  
  }
  
- static void tt_local_entry_free_ref(struct tt_local_entry *tt_local_entry)
+ static void
+ batadv_tt_local_entry_free_ref(struct 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;
@@@ -125,33 -127,34 +127,33 @@@
  	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 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;
  
  	orig_entry = container_of(rcu, struct 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 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 bat_priv *bat_priv,
+ 				  const uint8_t *addr, uint8_t flags)
  {
  	struct tt_change_node *tt_change_node;
  
@@@ -177,7 -180,7 +179,7 @@@ int batadv_tt_len(int changes_num
  	return changes_num * sizeof(struct tt_change);
  }
  
- static int tt_local_init(struct bat_priv *bat_priv)
+ static int batadv_tt_local_init(struct bat_priv *bat_priv)
  {
  	if (bat_priv->tt_local_hash)
  		return 0;
@@@ -201,7 -204,7 +203,7 @@@ void batadv_tt_local_add(struct net_dev
  	struct 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;
@@@ -214,9 -217,9 +216,9 @@@
  	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(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;
@@@ -226,7 -229,7 +228,7 @@@
  	tt_local_entry->last_seen = jiffies;
  
  	/* the batman interface mac address should never be purged */
- 	if (compare_eth(addr, soft_iface->dev_addr))
+ 	if (batadv_compare_eth(addr, soft_iface->dev_addr))
  		tt_local_entry->common.flags |= TT_CLIENT_NOPURGE;
  
  	/* The local entry has to be marked as NEW to avoid to send it in
@@@ -235,20 -238,21 +237,21 @@@
  	 */
  	tt_local_entry->common.flags |= 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) {
@@@ -258,8 -262,9 +261,9 @@@
  		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
@@@ -270,14 -275,15 +274,15 @@@
  	}
  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 tt_realloc_packet_buff(unsigned char **packet_buff,
- 				   int *packet_buff_len, int min_packet_len,
- 				   int new_packet_len)
+ 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;
  
@@@ -292,14 -298,15 +297,15 @@@
  	}
  }
  
- static void tt_prepare_packet_buff(struct bat_priv *bat_priv,
- 				   unsigned char **packet_buff,
- 				   int *packet_buff_len, int min_packet_len)
+ static void batadv_tt_prepare_packet_buff(struct bat_priv *bat_priv,
+ 					  unsigned char **packet_buff,
+ 					  int *packet_buff_len,
+ 					  int min_packet_len)
  {
  	struct hard_iface *primary_if;
  	int req_len;
  
- 	primary_if = primary_if_get_selected(bat_priv);
+ 	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));
@@@ -310,23 -317,24 +316,24 @@@
  	if ((!primary_if) || (req_len > primary_if->soft_iface->mtu))
  		req_len = min_packet_len;
  
- 	tt_realloc_packet_buff(packet_buff, packet_buff_len,
- 			       min_packet_len, req_len);
+ 	batadv_tt_realloc_packet_buff(packet_buff, packet_buff_len,
+ 				      min_packet_len, req_len);
  
  	if (primary_if)
- 		hardif_free_ref(primary_if);
+ 		batadv_hardif_free_ref(primary_if);
  }
  
- static int tt_changes_fill_buff(struct bat_priv *bat_priv,
- 				unsigned char **packet_buff,
- 				int *packet_buff_len, int min_packet_len)
+ static int batadv_tt_changes_fill_buff(struct bat_priv *bat_priv,
+ 				       unsigned char **packet_buff,
+ 				       int *packet_buff_len,
+ 				       int min_packet_len)
  {
  	struct tt_change_node *entry, *safe;
  	int count = 0, tot_changes = 0, new_len;
  	unsigned char *tt_buff;
  
- 	tt_prepare_packet_buff(bat_priv, packet_buff,
- 			       packet_buff_len, min_packet_len);
+ 	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;
@@@ -382,7 -390,7 +389,7 @@@ int batadv_tt_local_seq_print_text(stru
  	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",
@@@ -424,16 -432,16 +431,16 @@@
  	}
  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 bat_priv *bat_priv,
+ 					struct 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
@@@ -441,9 -449,9 +448,9 @@@
  	 */
  	tt_local_entry->common.flags |= 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(DBG_TT, bat_priv,
+ 		   "Local tt entry (%pM) pending to be removed: %s\n",
+ 		   tt_local_entry->common.addr, message);
  }
  
  void batadv_tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr,
@@@ -451,18 -459,19 +458,19 @@@
  {
  	struct tt_local_entry *tt_local_entry = NULL;
  
- 	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);
+ 	batadv_tt_local_set_pending(bat_priv, tt_local_entry, TT_CLIENT_DEL |
+ 				    (roaming ? TT_CLIENT_ROAM : NO_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(struct bat_priv *bat_priv)
  {
  	struct hashtable_t *hash = bat_priv->tt_local_hash;
  	struct tt_local_entry *tt_local_entry;
@@@ -489,19 -498,19 +497,19 @@@
  			if (tt_local_entry->common.flags & TT_CLIENT_PENDING)
  				continue;
  
- 			if (!has_timed_out(tt_local_entry->last_seen,
- 					   TT_LOCAL_TIMEOUT))
+ 			if (!batadv_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_set_pending(bat_priv, tt_local_entry,
+ 						    TT_CLIENT_DEL, "timed out");
  		}
  		spin_unlock_bh(list_lock);
  	}
  
  }
  
- static void tt_local_table_free(struct bat_priv *bat_priv)
+ static void batadv_tt_local_table_free(struct bat_priv *bat_priv)
  {
  	struct hashtable_t *hash;
  	spinlock_t *list_lock; /* protects write access to the hash lists */
@@@ -527,7 -536,7 +535,7 @@@
  			tt_local_entry = container_of(tt_common_entry,
  						      struct tt_local_entry,
  						      common);
- 			tt_local_entry_free_ref(tt_local_entry);
+ 			batadv_tt_local_entry_free_ref(tt_local_entry);
  		}
  		spin_unlock_bh(list_lock);
  	}
@@@ -537,7 -546,7 +545,7 @@@
  	bat_priv->tt_local_hash = NULL;
  }
  
- static int tt_global_init(struct bat_priv *bat_priv)
+ static int batadv_tt_global_init(struct bat_priv *bat_priv)
  {
  	if (bat_priv->tt_global_hash)
  		return 0;
@@@ -550,7 -559,7 +558,7 @@@
  	return 0;
  }
  
- static void tt_changes_list_free(struct bat_priv *bat_priv)
+ static void batadv_tt_changes_list_free(struct bat_priv *bat_priv)
  {
  	struct tt_change_node *entry, *safe;
  
@@@ -569,8 -578,8 +577,8 @@@
  /* 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 tt_global_entry *entry,
+ 					    const struct orig_node *orig_node)
  {
  	struct tt_orig_list_entry *tmp_orig_entry;
  	const struct hlist_head *head;
@@@ -589,9 -598,9 +597,9 @@@
  	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 tt_global_entry *tt_global_entry,
+ 				struct orig_node *orig_node, int ttvn)
  {
  	struct tt_orig_list_entry *orig_entry;
  
@@@ -619,8 -628,9 +627,9 @@@ int batadv_tt_global_add(struct bat_pri
  	struct tt_global_entry *tt_global_entry = NULL;
  	int ret = 0;
  	int hash_added;
+ 	struct 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),
@@@ -628,26 -638,29 +637,29 @@@
  		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 = NO_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. */
  
@@@ -659,22 -672,23 +671,23 @@@
  		 * new one.
  		 */
  		if (tt_global_entry->common.flags & TT_CLIENT_ROAM) {
- 			tt_global_del_orig_list(tt_global_entry);
+ 			batadv_tt_global_del_orig_list(tt_global_entry);
  			tt_global_entry->common.flags &= ~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(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 */
@@@ -683,15 -697,16 +696,16 @@@
  	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 tt_global_entry *tt_global_entry,
+ 			     struct seq_file *seq)
  {
  	struct hlist_head *head;
  	struct hlist_node *node;
@@@ -728,7 -743,7 +742,7 @@@ int batadv_tt_global_seq_print_text(str
  	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",
@@@ -758,18 -773,19 +772,19 @@@
  			tt_global_entry = container_of(tt_common_entry,
  						       struct tt_global_entry,
  						       common);
- 			tt_global_print_entry(tt_global_entry, seq);
+ 			batadv_tt_global_print_entry(tt_global_entry, 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 tt_global_entry *tt_global_entry)
  {
  	struct hlist_head *head;
  	struct hlist_node *node, *safe;
@@@ -779,16 -795,17 +794,17 @@@
  	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 bat_priv *bat_priv,
+ 				struct tt_global_entry *tt_global_entry,
+ 				struct orig_node *orig_node,
+ 				const char *message)
  {
  	struct hlist_head *head;
  	struct hlist_node *node, *safe;
@@@ -798,28 -815,27 +814,27 @@@
  	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(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 bat_priv *bat_priv,
+ 					struct 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(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);
  
  }
  
@@@ -827,10 -843,10 +842,10 @@@
   * 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.
   */
- 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 bat_priv *bat_priv,
+ 			     struct tt_global_entry *tt_global_entry,
+ 			     struct orig_node *orig_node, const char *message)
  {
  	bool last_entry = true;
  	struct hlist_head *head;
@@@ -859,31 -875,31 +874,31 @@@
  		/* 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 bat_priv *bat_priv,
+ 				 struct 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 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;
  	}
@@@ -901,29 -917,29 +916,29 @@@
  	 * 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) {
+ 	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 batadv_tt_global_del_orig(struct bat_priv *bat_priv,
  			       struct orig_node *orig_node, const char *message)
  {
- 	struct tt_global_entry *tt_global_entry;
+ 	struct tt_global_entry *global_entry;
  	struct tt_common_entry *tt_common_entry;
  	uint32_t i;
  	struct hashtable_t *hash = bat_priv->tt_global_hash;
@@@ -941,28 -957,28 +956,27 @@@
  		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);
+ 			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);
+ 			batadv_tt_global_del_orig_entry(bat_priv, 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);
+ 			if (hlist_empty(&global_entry->orig_list)) {
+ 				batadv_dbg(DBG_TT, bat_priv,
+ 					   "Deleting global tt entry %pM: %s\n",
+ 					   global_entry->common.addr, message);
  				hlist_del_rcu(node);
- 				tt_global_entry_free_ref(tt_global_entry);
+ 				batadv_tt_global_entry_free_ref(global_entry);
  			}
  		}
  		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(struct bat_priv *bat_priv)
  {
  	struct hashtable_t *hash = bat_priv->tt_global_hash;
  	struct tt_common_entry *tt_common_entry;
@@@ -984,23 -1000,23 +998,23 @@@
  						       common);
  			if (!(tt_global_entry->common.flags & TT_CLIENT_ROAM))
  				continue;
- 			if (!has_timed_out(tt_global_entry->roam_at,
- 					   TT_CLIENT_ROAM_TIMEOUT))
+ 			if (!batadv_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);
+ 			batadv_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_entry_free_ref(tt_global_entry);
  		}
  		spin_unlock_bh(list_lock);
  	}
  
  }
  
- static void tt_global_table_free(struct bat_priv *bat_priv)
+ static void batadv_tt_global_table_free(struct bat_priv *bat_priv)
  {
  	struct hashtable_t *hash;
  	spinlock_t *list_lock; /* protects write access to the hash lists */
@@@ -1026,7 -1042,7 +1040,7 @@@
  			tt_global_entry = container_of(tt_common_entry,
  						       struct tt_global_entry,
  						       common);
- 			tt_global_entry_free_ref(tt_global_entry);
+ 			batadv_tt_global_entry_free_ref(tt_global_entry);
  		}
  		spin_unlock_bh(list_lock);
  	}
@@@ -1036,8 -1052,8 +1050,8 @@@
  	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 tt_local_entry *tt_local_entry,
+ 				   struct tt_global_entry *tt_global_entry)
  {
  	bool ret = false;
  
@@@ -1062,19 -1078,20 +1076,20 @@@ struct orig_node *batadv_transtable_sea
  	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))
+ 	if (tt_local_entry &&
+ 	    _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
  		goto out;
  
  	best_tq = 0;
@@@ -1098,16 -1115,16 +1113,16 @@@
  	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 bat_priv *bat_priv,
+ 				     struct orig_node *orig_node)
  {
  	uint16_t total = 0, total_one;
  	struct hashtable_t *hash = bat_priv->tt_global_hash;
@@@ -1138,8 -1155,8 +1153,8 @@@
  			/* 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_entry,
+ 							     orig_node))
  				continue;
  
  			total_one = 0;
@@@ -1188,7 -1205,7 +1203,7 @@@ static uint16_t batadv_tt_local_crc(str
  	return total;
  }
  
- static void tt_req_list_free(struct bat_priv *bat_priv)
+ static void batadv_tt_req_list_free(struct bat_priv *bat_priv)
  {
  	struct tt_req_node *node, *safe;
  
@@@ -1202,10 -1219,10 +1217,10 @@@
  	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 bat_priv *bat_priv,
+ 				       struct orig_node *orig_node,
+ 				       const unsigned char *tt_buff,
+ 				       uint8_t tt_num_changes)
  {
  	uint16_t tt_buff_len = batadv_tt_len(tt_num_changes);
  
@@@ -1225,13 -1242,13 +1240,13 @@@
  	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 bat_priv *bat_priv)
  {
  	struct 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, TT_REQUEST_TIMEOUT)) {
  			list_del(&node->list);
  			kfree(node);
  		}
@@@ -1242,16 -1259,16 +1257,16 @@@
  /* 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)
+ static struct tt_req_node *batadv_new_tt_req_node(struct bat_priv *bat_priv,
+ 						  struct orig_node *orig_node)
  {
  	struct 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,
+ 					  TT_REQUEST_TIMEOUT))
  			goto unlock;
  	}
  
@@@ -1269,7 -1286,8 +1284,8 @@@ 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;
  
@@@ -1278,7 -1296,8 +1294,8 @@@
  	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;
@@@ -1290,15 -1309,15 +1307,15 @@@
  	tt_global_entry = container_of(tt_common_entry, struct 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 hashtable_t *hash,
+ 			      struct 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;
@@@ -1359,9 -1378,10 +1376,10 @@@ 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 bat_priv *bat_priv,
+ 				  struct 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;
@@@ -1370,14 -1390,14 +1388,14 @@@
  	struct tt_req_node *tt_req_node = NULL;
  	int ret = 1;
  
- 	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);
+ 	tt_req_node = batadv_new_tt_req_node(bat_priv, dst_orig_node);
  	if (!tt_req_node)
  		goto out;
  
@@@ -1406,10 -1426,10 +1424,10 @@@
  	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(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, BAT_CNT_TT_REQUEST_TX);
  
@@@ -1420,7 -1440,7 +1438,7 @@@ out
  	if (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) {
@@@ -1432,8 -1452,8 +1450,8 @@@
  	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 bat_priv *bat_priv,
+ 					  struct tt_query_packet *tt_request)
  {
  	struct orig_node *req_dst_orig_node = NULL, *res_dst_orig_node = NULL;
  	struct neigh_node *neigh_node = NULL;
@@@ -1446,17 -1466,17 +1464,17 @@@
  	struct sk_buff *skb = NULL;
  	struct tt_query_packet *tt_response;
  
- 	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(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' : '.'));
  
  	/* 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;
  
@@@ -1464,7 -1484,7 +1482,7 @@@
  	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;
  
@@@ -1513,10 -1533,11 +1531,11 @@@
  						sizeof(struct 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;
  
@@@ -1533,10 -1554,10 +1552,10 @@@
  	if (full_table)
  		tt_response->flags |= 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(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_inc_counter(bat_priv, BAT_CNT_TT_RESPONSE_TX);
  
@@@ -1555,14 -1576,14 +1574,14 @@@ out
  	if (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 bat_priv *bat_priv,
+ 				       struct tt_query_packet *tt_request)
  {
  	struct orig_node *orig_node = NULL;
  	struct neigh_node *neigh_node = NULL;
@@@ -1575,16 -1596,16 +1594,16 @@@
  	struct sk_buff *skb = NULL;
  	struct tt_query_packet *tt_response;
  
- 	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(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' : '.'));
  
  
  	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;
  
@@@ -1592,7 -1613,7 +1611,7 @@@
  	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;
  
@@@ -1633,10 -1654,11 +1652,11 @@@
  						sizeof(struct 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;
  
@@@ -1653,10 -1675,10 +1673,10 @@@
  	if (full_table)
  		tt_response->flags |= 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(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_inc_counter(bat_priv, BAT_CNT_TT_RESPONSE_TX);
  
@@@ -1672,7 -1694,7 +1692,7 @@@ out
  	if (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 */
@@@ -1687,26 -1709,28 +1707,28 @@@ bool batadv_send_tt_response(struct bat
  		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 bat_priv *bat_priv,
+ 				      struct orig_node *orig_node,
+ 				      struct tt_change *tt_change,
+ 				      uint16_t tt_num_changes, uint8_t ttvn)
  {
  	int i;
  	int is_wifi;
+ 	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);
+ 			roams = (tt_change + i)->flags & TT_CLIENT_ROAM;
+ 			batadv_tt_global_del(bat_priv, orig_node,
+ 					     (tt_change + i)->addr,
+ 					      "tt removed by changes",
+ 					      roams);
  		} else {
  			is_wifi = (tt_change + i)->flags & TT_CLIENT_WIFI;
  			if (!batadv_tt_global_add(bat_priv, orig_node,
@@@ -1724,21 -1748,22 +1746,22 @@@
  	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 bat_priv *bat_priv,
+ 				  struct tt_query_packet *tt_response)
  {
  	struct 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.. */
  	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),
- 			   ntohs(tt_response->tt_data), tt_response->ttvn);
+ 	_batadv_tt_update_changes(bat_priv, orig_node,
+ 				  (struct 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);
@@@ -1753,16 -1778,16 +1776,16 @@@ out
  		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 bat_priv *bat_priv,
+ 				     struct orig_node *orig_node,
+ 				     uint16_t tt_num_changes, uint8_t ttvn,
+ 				     struct 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);
  }
  
@@@ -1771,7 -1796,7 +1794,7 @@@ bool batadv_is_my_client(struct bat_pri
  	struct 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
@@@ -1782,7 -1807,7 +1805,7 @@@
  	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;
  }
  
@@@ -1792,32 -1817,32 +1815,32 @@@ void batadv_handle_tt_response(struct b
  	struct tt_req_node *node, *safe;
  	struct orig_node *orig_node = NULL;
  
- 	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,
- 		ntohs(tt_response->tt_data),
- 		(tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
+ 	batadv_dbg(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 & TT_FULL_TABLE ? 'F' : '.'));
  
  	/* we should have never asked a backbone gw */
  	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);
+ 		batadv_tt_fill_gtable(bat_priv, tt_response);
  	else
- 		tt_update_changes(bat_priv, orig_node,
- 				  ntohs(tt_response->tt_data),
- 				  tt_response->ttvn,
- 				  (struct tt_change *)(tt_response + 1));
+ 		batadv_tt_update_changes(bat_priv, orig_node,
+ 					 ntohs(tt_response->tt_data),
+ 					 tt_response->ttvn,
+ 					 (struct tt_change *)(tt_response + 1));
  
  	/* 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);
@@@ -1825,7 -1850,7 +1848,7 @@@
  	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
  	 */
@@@ -1839,20 -1864,20 +1862,20 @@@ int batadv_tt_init(struct bat_priv *bat
  {
  	int ret;
  
- 	ret = tt_local_init(bat_priv);
+ 	ret = batadv_tt_local_init(bat_priv);
  	if (ret < 0)
  		return ret;
  
- 	ret = tt_global_init(bat_priv);
+ 	ret = batadv_tt_global_init(bat_priv);
  	if (ret < 0)
  		return ret;
  
- 	tt_start_timer(bat_priv);
+ 	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 bat_priv *bat_priv)
  {
  	struct tt_roam_node *node, *safe;
  
@@@ -1866,13 -1891,13 +1889,13 @@@
  	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 bat_priv *bat_priv)
  {
  	struct 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, ROAMING_MAX_TIME))
  			continue;
  
  		list_del(&node->list);
@@@ -1887,8 -1912,8 +1910,8 @@@
   *
   * 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)
+ static bool batadv_tt_check_roam_count(struct bat_priv *bat_priv,
+ 				       uint8_t *client)
  {
  	struct tt_roam_node *tt_roam_node;
  	bool ret = false;
@@@ -1898,10 -1923,11 +1921,11 @@@
  	 * 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,
+ 					 ROAMING_MAX_TIME))
  			continue;
  
  		if (!atomic_dec_not_zero(&tt_roam_node->counter))
@@@ -1929,8 -1955,8 +1953,8 @@@ 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 bat_priv *bat_priv, uint8_t *client,
+ 				 struct orig_node *orig_node)
  {
  	struct neigh_node *neigh_node = NULL;
  	struct sk_buff *skb = NULL;
@@@ -1941,7 -1967,7 +1965,7 @@@
  	/* 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))
+ 	if (!batadv_tt_check_roam_count(bat_priv, client))
  		goto out;
  
  	skb = dev_alloc_skb(sizeof(struct roam_adv_packet) + ETH_HLEN);
@@@ -1956,11 -1982,11 +1980,11 @@@
  	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);
+ 	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);
  
@@@ -1968,9 -1994,9 +1992,9 @@@
  	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(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, BAT_CNT_TT_ROAM_ADV_TX);
  
@@@ -1985,30 -2011,30 +2009,30 @@@ out
  	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);
  
- 	tt_local_purge(bat_priv);
- 	tt_global_roam_purge(bat_priv);
- 	tt_req_purge(bat_priv);
- 	tt_roam_purge(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);
  
- 	tt_start_timer(bat_priv);
+ 	batadv_tt_start_timer(bat_priv);
  }
  
  void batadv_tt_free(struct bat_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);
  }
@@@ -2016,8 -2042,8 +2040,8 @@@
  /* 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)
+ static uint16_t batadv_tt_set_flags(struct hashtable_t *hash, uint16_t flags,
+ 				    bool enable)
  {
  	uint32_t i;
  	uint16_t changed_num = 0;
@@@ -2052,7 -2078,7 +2076,7 @@@ out
  }
  
  /* Purge out all the tt local entries marked with TT_CLIENT_PENDING */
- static void tt_local_purge_pending_clients(struct bat_priv *bat_priv)
+ static void batadv_tt_local_purge_pending_clients(struct bat_priv *bat_priv)
  {
  	struct hashtable_t *hash = bat_priv->tt_local_hash;
  	struct tt_common_entry *tt_common_entry;
@@@ -2075,50 -2101,51 +2099,51 @@@
  			if (!(tt_common_entry->flags & TT_CLIENT_PENDING))
  				continue;
  
- 			bat_dbg(DBG_TT, bat_priv,
- 				"Deleting local tt entry (%pM): pending\n",
- 				tt_common_entry->addr);
+ 			batadv_dbg(DBG_TT, bat_priv,
+ 				   "Deleting local tt entry (%pM): pending\n",
+ 				   tt_common_entry->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);
+ 			batadv_tt_local_entry_free_ref(tt_local_entry);
  		}
  		spin_unlock_bh(list_lock);
  	}
  
  }
  
- static int tt_commit_changes(struct bat_priv *bat_priv,
- 			     unsigned char **packet_buff, int *packet_buff_len,
- 			     int packet_min_len)
+ static int batadv_tt_commit_changes(struct bat_priv *bat_priv,
+ 				    unsigned char **packet_buff,
+ 				    int *packet_buff_len, int packet_min_len)
  {
  	uint16_t changed_num = 0;
  
  	if (atomic_read(&bat_priv->tt_local_changes) < 1)
  		return -ENOENT;
  
- 	changed_num = tt_set_flags(bat_priv->tt_local_hash,
- 				   TT_CLIENT_NEW, false);
+ 	changed_num = batadv_tt_set_flags(bat_priv->tt_local_hash,
+ 					  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(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, TT_OGM_APPEND_MAX);
  
- 	return tt_changes_fill_buff(bat_priv, packet_buff,
- 				    packet_buff_len, packet_min_len);
+ 	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 */
@@@ -2129,14 -2156,15 +2154,15 @@@ int batadv_tt_append_diff(struct bat_pr
  	int tt_num_changes;
  
  	/* if at least one change happened */
- 	tt_num_changes = tt_commit_changes(bat_priv, packet_buff,
- 					   packet_buff_len, packet_min_len);
+ 	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) &&
  	    (!atomic_dec_not_zero(&bat_priv->tt_ogm_append_cnt))) {
- 		tt_realloc_packet_buff(packet_buff, packet_buff_len,
- 				       packet_min_len, packet_min_len);
+ 		batadv_tt_realloc_packet_buff(packet_buff, packet_buff_len,
+ 					      packet_min_len, packet_min_len);
  		tt_num_changes = 0;
  	}
  
@@@ -2148,29 -2176,29 +2174,29 @@@ bool batadv_is_ap_isolated(struct bat_p
  {
  	struct tt_local_entry *tt_local_entry = NULL;
  	struct 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 (!_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;
  }
  
@@@ -2200,14 -2228,14 +2226,14 @@@ void batadv_tt_update_orig(struct bat_p
  			goto request_table;
  		}
  
- 		tt_update_changes(bat_priv, orig_node, tt_num_changes, ttvn,
- 				  (struct tt_change *)tt_buff);
+ 		batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
+ 					 ttvn, (struct tt_change *)tt_buff);
  
  		/* 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);
+ 		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
@@@ -2232,12 -2260,12 +2258,12 @@@
  		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(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;
  		}
  	}
@@@ -2253,12 -2281,12 +2279,12 @@@ bool batadv_tt_global_client_is_roaming
  	struct 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);
+ 	batadv_tt_global_entry_free_ref(tt_global_entry);
  out:
  	return ret;
  }

-- 
LinuxNextTracking


More information about the linux-merge mailing list