1 /* Copyright (C) 2007-2015 B.A.T.M.A.N. contributors:
2  *
3  * Marek Lindner, Simon Wunderlich, Antonio Quartulli
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of version 2 of the GNU General Public
7  * License as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #include "translation-table.h"
19 #include "main.h"
20 
21 #include <linux/atomic.h>
22 #include <linux/bitops.h>
23 #include <linux/bug.h>
24 #include <linux/byteorder/generic.h>
25 #include <linux/compiler.h>
26 #include <linux/crc32c.h>
27 #include <linux/errno.h>
28 #include <linux/etherdevice.h>
29 #include <linux/fs.h>
30 #include <linux/if_ether.h>
31 #include <linux/jhash.h>
32 #include <linux/jiffies.h>
33 #include <linux/kernel.h>
34 #include <linux/list.h>
35 #include <linux/lockdep.h>
36 #include <linux/netdevice.h>
37 #include <linux/rculist.h>
38 #include <linux/rcupdate.h>
39 #include <linux/seq_file.h>
40 #include <linux/slab.h>
41 #include <linux/spinlock.h>
42 #include <linux/stddef.h>
43 #include <linux/string.h>
44 #include <linux/workqueue.h>
45 #include <net/net_namespace.h>
46 
47 #include "bridge_loop_avoidance.h"
48 #include "hard-interface.h"
49 #include "hash.h"
50 #include "multicast.h"
51 #include "originator.h"
52 #include "packet.h"
53 #include "soft-interface.h"
54 
55 /* hash class keys */
56 static struct lock_class_key batadv_tt_local_hash_lock_class_key;
57 static struct lock_class_key batadv_tt_global_hash_lock_class_key;
58 
59 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
60 				 unsigned short vid,
61 				 struct batadv_orig_node *orig_node);
62 static void batadv_tt_purge(struct work_struct *work);
63 static void
64 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry);
65 static void batadv_tt_global_del(struct batadv_priv *bat_priv,
66 				 struct batadv_orig_node *orig_node,
67 				 const unsigned char *addr,
68 				 unsigned short vid, const char *message,
69 				 bool roaming);
70 
71 /* returns 1 if they are the same mac addr and vid */
72 static int batadv_compare_tt(const struct hlist_node *node, const void *data2)
73 {
74 	const void *data1 = container_of(node, struct batadv_tt_common_entry,
75 					 hash_entry);
76 	const struct batadv_tt_common_entry *tt1 = data1;
77 	const struct batadv_tt_common_entry *tt2 = data2;
78 
79 	return (tt1->vid == tt2->vid) && batadv_compare_eth(data1, data2);
80 }
81 
82 /**
83  * batadv_choose_tt - return the index of the tt entry in the hash table
84  * @data: pointer to the tt_common_entry object to map
85  * @size: the size of the hash table
86  *
87  * Returns the hash index where the object represented by 'data' should be
88  * stored at.
89  */
90 static inline u32 batadv_choose_tt(const void *data, u32 size)
91 {
92 	struct batadv_tt_common_entry *tt;
93 	u32 hash = 0;
94 
95 	tt = (struct batadv_tt_common_entry *)data;
96 	hash = jhash(&tt->addr, ETH_ALEN, hash);
97 	hash = jhash(&tt->vid, sizeof(tt->vid), hash);
98 
99 	return hash % size;
100 }
101 
102 /**
103  * batadv_tt_hash_find - look for a client in the given hash table
104  * @hash: the hash table to search
105  * @addr: the mac address of the client to look for
106  * @vid: VLAN identifier
107  *
108  * Returns a pointer to the tt_common struct belonging to the searched client if
109  * found, NULL otherwise.
110  */
111 static struct batadv_tt_common_entry *
112 batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr,
113 		    unsigned short vid)
114 {
115 	struct hlist_head *head;
116 	struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL;
117 	u32 index;
118 
119 	if (!hash)
120 		return NULL;
121 
122 	ether_addr_copy(to_search.addr, addr);
123 	to_search.vid = vid;
124 
125 	index = batadv_choose_tt(&to_search, hash->size);
126 	head = &hash->table[index];
127 
128 	rcu_read_lock();
129 	hlist_for_each_entry_rcu(tt, head, hash_entry) {
130 		if (!batadv_compare_eth(tt, addr))
131 			continue;
132 
133 		if (tt->vid != vid)
134 			continue;
135 
136 		if (!atomic_inc_not_zero(&tt->refcount))
137 			continue;
138 
139 		tt_tmp = tt;
140 		break;
141 	}
142 	rcu_read_unlock();
143 
144 	return tt_tmp;
145 }
146 
147 /**
148  * batadv_tt_local_hash_find - search the local table for a given client
149  * @bat_priv: the bat priv with all the soft interface information
150  * @addr: the mac address of the client to look for
151  * @vid: VLAN identifier
152  *
153  * Returns a pointer to the corresponding tt_local_entry struct if the client is
154  * found, NULL otherwise.
155  */
156 static struct batadv_tt_local_entry *
157 batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
158 			  unsigned short vid)
159 {
160 	struct batadv_tt_common_entry *tt_common_entry;
161 	struct batadv_tt_local_entry *tt_local_entry = NULL;
162 
163 	tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr,
164 					      vid);
165 	if (tt_common_entry)
166 		tt_local_entry = container_of(tt_common_entry,
167 					      struct batadv_tt_local_entry,
168 					      common);
169 	return tt_local_entry;
170 }
171 
172 /**
173  * batadv_tt_global_hash_find - search the global table for a given client
174  * @bat_priv: the bat priv with all the soft interface information
175  * @addr: the mac address of the client to look for
176  * @vid: VLAN identifier
177  *
178  * Returns a pointer to the corresponding tt_global_entry struct if the client
179  * is found, NULL otherwise.
180  */
181 static struct batadv_tt_global_entry *
182 batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr,
183 			   unsigned short vid)
184 {
185 	struct batadv_tt_common_entry *tt_common_entry;
186 	struct batadv_tt_global_entry *tt_global_entry = NULL;
187 
188 	tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr,
189 					      vid);
190 	if (tt_common_entry)
191 		tt_global_entry = container_of(tt_common_entry,
192 					       struct batadv_tt_global_entry,
193 					       common);
194 	return tt_global_entry;
195 }
196 
197 static void
198 batadv_tt_local_entry_free_ref(struct batadv_tt_local_entry *tt_local_entry)
199 {
200 	if (atomic_dec_and_test(&tt_local_entry->common.refcount))
201 		kfree_rcu(tt_local_entry, common.rcu);
202 }
203 
204 /**
205  * batadv_tt_global_entry_free_ref - decrement the refcounter for a
206  *  tt_global_entry and possibly free it
207  * @tt_global_entry: the object to free
208  */
209 static void
210 batadv_tt_global_entry_free_ref(struct batadv_tt_global_entry *tt_global_entry)
211 {
212 	if (atomic_dec_and_test(&tt_global_entry->common.refcount)) {
213 		batadv_tt_global_del_orig_list(tt_global_entry);
214 		kfree_rcu(tt_global_entry, common.rcu);
215 	}
216 }
217 
218 /**
219  * batadv_tt_global_hash_count - count the number of orig entries
220  * @hash: hash table containing the tt entries
221  * @addr: the mac address of the client to count entries for
222  * @vid: VLAN identifier
223  *
224  * Return the number of originators advertising the given address/data
225  * (excluding ourself).
226  */
227 int batadv_tt_global_hash_count(struct batadv_priv *bat_priv,
228 				const u8 *addr, unsigned short vid)
229 {
230 	struct batadv_tt_global_entry *tt_global_entry;
231 	int count;
232 
233 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
234 	if (!tt_global_entry)
235 		return 0;
236 
237 	count = atomic_read(&tt_global_entry->orig_list_count);
238 	batadv_tt_global_entry_free_ref(tt_global_entry);
239 
240 	return count;
241 }
242 
243 static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu)
244 {
245 	struct batadv_tt_orig_list_entry *orig_entry;
246 
247 	orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu);
248 
249 	/* We are in an rcu callback here, therefore we cannot use
250 	 * batadv_orig_node_free_ref() and its call_rcu():
251 	 * An rcu_barrier() wouldn't wait for that to finish
252 	 */
253 	batadv_orig_node_free_ref_now(orig_entry->orig_node);
254 	kfree(orig_entry);
255 }
256 
257 /**
258  * batadv_tt_local_size_mod - change the size by v of the local table identified
259  *  by vid
260  * @bat_priv: the bat priv with all the soft interface information
261  * @vid: the VLAN identifier of the sub-table to change
262  * @v: the amount to sum to the local table size
263  */
264 static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv,
265 				     unsigned short vid, int v)
266 {
267 	struct batadv_softif_vlan *vlan;
268 
269 	vlan = batadv_softif_vlan_get(bat_priv, vid);
270 	if (!vlan)
271 		return;
272 
273 	atomic_add(v, &vlan->tt.num_entries);
274 
275 	batadv_softif_vlan_free_ref(vlan);
276 }
277 
278 /**
279  * batadv_tt_local_size_inc - increase by one the local table size for the given
280  *  vid
281  * @bat_priv: the bat priv with all the soft interface information
282  * @vid: the VLAN identifier
283  */
284 static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv,
285 				     unsigned short vid)
286 {
287 	batadv_tt_local_size_mod(bat_priv, vid, 1);
288 }
289 
290 /**
291  * batadv_tt_local_size_dec - decrease by one the local table size for the given
292  *  vid
293  * @bat_priv: the bat priv with all the soft interface information
294  * @vid: the VLAN identifier
295  */
296 static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv,
297 				     unsigned short vid)
298 {
299 	batadv_tt_local_size_mod(bat_priv, vid, -1);
300 }
301 
302 /**
303  * batadv_tt_global_size_mod - change the size by v of the local table
304  *  identified by vid
305  * @bat_priv: the bat priv with all the soft interface information
306  * @vid: the VLAN identifier
307  * @v: the amount to sum to the global table size
308  */
309 static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node,
310 				      unsigned short vid, int v)
311 {
312 	struct batadv_orig_node_vlan *vlan;
313 
314 	vlan = batadv_orig_node_vlan_new(orig_node, vid);
315 	if (!vlan)
316 		return;
317 
318 	if (atomic_add_return(v, &vlan->tt.num_entries) == 0) {
319 		spin_lock_bh(&orig_node->vlan_list_lock);
320 		hlist_del_init_rcu(&vlan->list);
321 		spin_unlock_bh(&orig_node->vlan_list_lock);
322 		batadv_orig_node_vlan_free_ref(vlan);
323 	}
324 
325 	batadv_orig_node_vlan_free_ref(vlan);
326 }
327 
328 /**
329  * batadv_tt_global_size_inc - increase by one the global table size for the
330  *  given vid
331  * @orig_node: the originator which global table size has to be decreased
332  * @vid: the vlan identifier
333  */
334 static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node,
335 				      unsigned short vid)
336 {
337 	batadv_tt_global_size_mod(orig_node, vid, 1);
338 }
339 
340 /**
341  * batadv_tt_global_size_dec - decrease by one the global table size for the
342  *  given vid
343  * @orig_node: the originator which global table size has to be decreased
344  * @vid: the vlan identifier
345  */
346 static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node,
347 				      unsigned short vid)
348 {
349 	batadv_tt_global_size_mod(orig_node, vid, -1);
350 }
351 
352 static void
353 batadv_tt_orig_list_entry_free_ref(struct batadv_tt_orig_list_entry *orig_entry)
354 {
355 	if (!atomic_dec_and_test(&orig_entry->refcount))
356 		return;
357 
358 	call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu);
359 }
360 
361 /**
362  * batadv_tt_local_event - store a local TT event (ADD/DEL)
363  * @bat_priv: the bat priv with all the soft interface information
364  * @tt_local_entry: the TT entry involved in the event
365  * @event_flags: flags to store in the event structure
366  */
367 static void batadv_tt_local_event(struct batadv_priv *bat_priv,
368 				  struct batadv_tt_local_entry *tt_local_entry,
369 				  u8 event_flags)
370 {
371 	struct batadv_tt_change_node *tt_change_node, *entry, *safe;
372 	struct batadv_tt_common_entry *common = &tt_local_entry->common;
373 	u8 flags = common->flags | event_flags;
374 	bool event_removed = false;
375 	bool del_op_requested, del_op_entry;
376 
377 	tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC);
378 	if (!tt_change_node)
379 		return;
380 
381 	tt_change_node->change.flags = flags;
382 	memset(tt_change_node->change.reserved, 0,
383 	       sizeof(tt_change_node->change.reserved));
384 	ether_addr_copy(tt_change_node->change.addr, common->addr);
385 	tt_change_node->change.vid = htons(common->vid);
386 
387 	del_op_requested = flags & BATADV_TT_CLIENT_DEL;
388 
389 	/* check for ADD+DEL or DEL+ADD events */
390 	spin_lock_bh(&bat_priv->tt.changes_list_lock);
391 	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
392 				 list) {
393 		if (!batadv_compare_eth(entry->change.addr, common->addr))
394 			continue;
395 
396 		/* DEL+ADD in the same orig interval have no effect and can be
397 		 * removed to avoid silly behaviour on the receiver side. The
398 		 * other way around (ADD+DEL) can happen in case of roaming of
399 		 * a client still in the NEW state. Roaming of NEW clients is
400 		 * now possible due to automatically recognition of "temporary"
401 		 * clients
402 		 */
403 		del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL;
404 		if (!del_op_requested && del_op_entry)
405 			goto del;
406 		if (del_op_requested && !del_op_entry)
407 			goto del;
408 
409 		/* this is a second add in the same originator interval. It
410 		 * means that flags have been changed: update them!
411 		 */
412 		if (!del_op_requested && !del_op_entry)
413 			entry->change.flags = flags;
414 
415 		continue;
416 del:
417 		list_del(&entry->list);
418 		kfree(entry);
419 		kfree(tt_change_node);
420 		event_removed = true;
421 		goto unlock;
422 	}
423 
424 	/* track the change in the OGMinterval list */
425 	list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list);
426 
427 unlock:
428 	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
429 
430 	if (event_removed)
431 		atomic_dec(&bat_priv->tt.local_changes);
432 	else
433 		atomic_inc(&bat_priv->tt.local_changes);
434 }
435 
436 /**
437  * batadv_tt_len - compute length in bytes of given number of tt changes
438  * @changes_num: number of tt changes
439  *
440  * Returns computed length in bytes.
441  */
442 static int batadv_tt_len(int changes_num)
443 {
444 	return changes_num * sizeof(struct batadv_tvlv_tt_change);
445 }
446 
447 /**
448  * batadv_tt_entries - compute the number of entries fitting in tt_len bytes
449  * @tt_len: available space
450  *
451  * Returns the number of entries.
452  */
453 static u16 batadv_tt_entries(u16 tt_len)
454 {
455 	return tt_len / batadv_tt_len(1);
456 }
457 
458 /**
459  * batadv_tt_local_table_transmit_size - calculates the local translation table
460  *  size when transmitted over the air
461  * @bat_priv: the bat priv with all the soft interface information
462  *
463  * Returns local translation table size in bytes.
464  */
465 static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv)
466 {
467 	u16 num_vlan = 0;
468 	u16 tt_local_entries = 0;
469 	struct batadv_softif_vlan *vlan;
470 	int hdr_size;
471 
472 	rcu_read_lock();
473 	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
474 		num_vlan++;
475 		tt_local_entries += atomic_read(&vlan->tt.num_entries);
476 	}
477 	rcu_read_unlock();
478 
479 	/* header size of tvlv encapsulated tt response payload */
480 	hdr_size = sizeof(struct batadv_unicast_tvlv_packet);
481 	hdr_size += sizeof(struct batadv_tvlv_hdr);
482 	hdr_size += sizeof(struct batadv_tvlv_tt_data);
483 	hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data);
484 
485 	return hdr_size + batadv_tt_len(tt_local_entries);
486 }
487 
488 static int batadv_tt_local_init(struct batadv_priv *bat_priv)
489 {
490 	if (bat_priv->tt.local_hash)
491 		return 0;
492 
493 	bat_priv->tt.local_hash = batadv_hash_new(1024);
494 
495 	if (!bat_priv->tt.local_hash)
496 		return -ENOMEM;
497 
498 	batadv_hash_set_lock_class(bat_priv->tt.local_hash,
499 				   &batadv_tt_local_hash_lock_class_key);
500 
501 	return 0;
502 }
503 
504 static void batadv_tt_global_free(struct batadv_priv *bat_priv,
505 				  struct batadv_tt_global_entry *tt_global,
506 				  const char *message)
507 {
508 	batadv_dbg(BATADV_DBG_TT, bat_priv,
509 		   "Deleting global tt entry %pM (vid: %d): %s\n",
510 		   tt_global->common.addr,
511 		   BATADV_PRINT_VID(tt_global->common.vid), message);
512 
513 	batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt,
514 			   batadv_choose_tt, &tt_global->common);
515 	batadv_tt_global_entry_free_ref(tt_global);
516 }
517 
518 /**
519  * batadv_tt_local_add - add a new client to the local table or update an
520  *  existing client
521  * @soft_iface: netdev struct of the mesh interface
522  * @addr: the mac address of the client to add
523  * @vid: VLAN identifier
524  * @ifindex: index of the interface where the client is connected to (useful to
525  *  identify wireless clients)
526  * @mark: the value contained in the skb->mark field of the received packet (if
527  *  any)
528  *
529  * Returns true if the client was successfully added, false otherwise.
530  */
531 bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr,
532 			 unsigned short vid, int ifindex, u32 mark)
533 {
534 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
535 	struct batadv_tt_local_entry *tt_local;
536 	struct batadv_tt_global_entry *tt_global = NULL;
537 	struct batadv_softif_vlan *vlan;
538 	struct net_device *in_dev = NULL;
539 	struct hlist_head *head;
540 	struct batadv_tt_orig_list_entry *orig_entry;
541 	int hash_added, table_size, packet_size_max;
542 	bool ret = false;
543 	bool roamed_back = false;
544 	u8 remote_flags;
545 	u32 match_mark;
546 
547 	if (ifindex != BATADV_NULL_IFINDEX)
548 		in_dev = dev_get_by_index(&init_net, ifindex);
549 
550 	tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid);
551 
552 	if (!is_multicast_ether_addr(addr))
553 		tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid);
554 
555 	if (tt_local) {
556 		tt_local->last_seen = jiffies;
557 		if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) {
558 			batadv_dbg(BATADV_DBG_TT, bat_priv,
559 				   "Re-adding pending client %pM (vid: %d)\n",
560 				   addr, BATADV_PRINT_VID(vid));
561 			/* whatever the reason why the PENDING flag was set,
562 			 * this is a client which was enqueued to be removed in
563 			 * this orig_interval. Since it popped up again, the
564 			 * flag can be reset like it was never enqueued
565 			 */
566 			tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING;
567 			goto add_event;
568 		}
569 
570 		if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) {
571 			batadv_dbg(BATADV_DBG_TT, bat_priv,
572 				   "Roaming client %pM (vid: %d) came back to its original location\n",
573 				   addr, BATADV_PRINT_VID(vid));
574 			/* the ROAM flag is set because this client roamed away
575 			 * and the node got a roaming_advertisement message. Now
576 			 * that the client popped up again at its original
577 			 * location such flag can be unset
578 			 */
579 			tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM;
580 			roamed_back = true;
581 		}
582 		goto check_roaming;
583 	}
584 
585 	/* Ignore the client if we cannot send it in a full table response. */
586 	table_size = batadv_tt_local_table_transmit_size(bat_priv);
587 	table_size += batadv_tt_len(1);
588 	packet_size_max = atomic_read(&bat_priv->packet_size_max);
589 	if (table_size > packet_size_max) {
590 		net_ratelimited_function(batadv_info, soft_iface,
591 					 "Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n",
592 					 table_size, packet_size_max, addr);
593 		goto out;
594 	}
595 
596 	tt_local = kmalloc(sizeof(*tt_local), GFP_ATOMIC);
597 	if (!tt_local)
598 		goto out;
599 
600 	/* increase the refcounter of the related vlan */
601 	vlan = batadv_softif_vlan_get(bat_priv, vid);
602 	if (WARN(!vlan, "adding TT local entry %pM to non-existent VLAN %d",
603 		 addr, BATADV_PRINT_VID(vid))) {
604 		kfree(tt_local);
605 		tt_local = NULL;
606 		goto out;
607 	}
608 
609 	batadv_dbg(BATADV_DBG_TT, bat_priv,
610 		   "Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n",
611 		   addr, BATADV_PRINT_VID(vid),
612 		   (u8)atomic_read(&bat_priv->tt.vn));
613 
614 	ether_addr_copy(tt_local->common.addr, addr);
615 	/* The local entry has to be marked as NEW to avoid to send it in
616 	 * a full table response going out before the next ttvn increment
617 	 * (consistency check)
618 	 */
619 	tt_local->common.flags = BATADV_TT_CLIENT_NEW;
620 	tt_local->common.vid = vid;
621 	if (batadv_is_wifi_netdev(in_dev))
622 		tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
623 	atomic_set(&tt_local->common.refcount, 2);
624 	tt_local->last_seen = jiffies;
625 	tt_local->common.added_at = tt_local->last_seen;
626 
627 	/* the batman interface mac and multicast addresses should never be
628 	 * purged
629 	 */
630 	if (batadv_compare_eth(addr, soft_iface->dev_addr) ||
631 	    is_multicast_ether_addr(addr))
632 		tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE;
633 
634 	hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt,
635 				     batadv_choose_tt, &tt_local->common,
636 				     &tt_local->common.hash_entry);
637 
638 	if (unlikely(hash_added != 0)) {
639 		/* remove the reference for the hash */
640 		batadv_tt_local_entry_free_ref(tt_local);
641 		batadv_softif_vlan_free_ref(vlan);
642 		goto out;
643 	}
644 
645 add_event:
646 	batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
647 
648 check_roaming:
649 	/* Check whether it is a roaming, but don't do anything if the roaming
650 	 * process has already been handled
651 	 */
652 	if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) {
653 		/* These node are probably going to update their tt table */
654 		head = &tt_global->orig_list;
655 		rcu_read_lock();
656 		hlist_for_each_entry_rcu(orig_entry, head, list) {
657 			batadv_send_roam_adv(bat_priv, tt_global->common.addr,
658 					     tt_global->common.vid,
659 					     orig_entry->orig_node);
660 		}
661 		rcu_read_unlock();
662 		if (roamed_back) {
663 			batadv_tt_global_free(bat_priv, tt_global,
664 					      "Roaming canceled");
665 			tt_global = NULL;
666 		} else {
667 			/* The global entry has to be marked as ROAMING and
668 			 * has to be kept for consistency purpose
669 			 */
670 			tt_global->common.flags |= BATADV_TT_CLIENT_ROAM;
671 			tt_global->roam_at = jiffies;
672 		}
673 	}
674 
675 	/* store the current remote flags before altering them. This helps
676 	 * understanding is flags are changing or not
677 	 */
678 	remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK;
679 
680 	if (batadv_is_wifi_netdev(in_dev))
681 		tt_local->common.flags |= BATADV_TT_CLIENT_WIFI;
682 	else
683 		tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI;
684 
685 	/* check the mark in the skb: if it's equal to the configured
686 	 * isolation_mark, it means the packet is coming from an isolated
687 	 * non-mesh client
688 	 */
689 	match_mark = (mark & bat_priv->isolation_mark_mask);
690 	if (bat_priv->isolation_mark_mask &&
691 	    match_mark == bat_priv->isolation_mark)
692 		tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA;
693 	else
694 		tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA;
695 
696 	/* if any "dynamic" flag has been modified, resend an ADD event for this
697 	 * entry so that all the nodes can get the new flags
698 	 */
699 	if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK))
700 		batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS);
701 
702 	ret = true;
703 out:
704 	if (in_dev)
705 		dev_put(in_dev);
706 	if (tt_local)
707 		batadv_tt_local_entry_free_ref(tt_local);
708 	if (tt_global)
709 		batadv_tt_global_entry_free_ref(tt_global);
710 	return ret;
711 }
712 
713 /**
714  * batadv_tt_prepare_tvlv_global_data - prepare the TVLV TT header to send
715  *  within a TT Response directed to another node
716  * @orig_node: originator for which the TT data has to be prepared
717  * @tt_data: uninitialised pointer to the address of the TVLV buffer
718  * @tt_change: uninitialised pointer to the address of the area where the TT
719  *  changed can be stored
720  * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
721  *  function reserves the amount of space needed to send the entire global TT
722  *  table. In case of success the value is updated with the real amount of
723  *  reserved bytes
724 
725  * Allocate the needed amount of memory for the entire TT TVLV and write its
726  * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
727  * objects, one per active VLAN served by the originator node.
728  *
729  * Return the size of the allocated buffer or 0 in case of failure.
730  */
731 static u16
732 batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node,
733 				   struct batadv_tvlv_tt_data **tt_data,
734 				   struct batadv_tvlv_tt_change **tt_change,
735 				   s32 *tt_len)
736 {
737 	u16 num_vlan = 0;
738 	u16 num_entries = 0;
739 	u16 change_offset;
740 	u16 tvlv_len;
741 	struct batadv_tvlv_tt_vlan_data *tt_vlan;
742 	struct batadv_orig_node_vlan *vlan;
743 	u8 *tt_change_ptr;
744 
745 	rcu_read_lock();
746 	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
747 		num_vlan++;
748 		num_entries += atomic_read(&vlan->tt.num_entries);
749 	}
750 
751 	change_offset = sizeof(**tt_data);
752 	change_offset += num_vlan * sizeof(*tt_vlan);
753 
754 	/* if tt_len is negative, allocate the space needed by the full table */
755 	if (*tt_len < 0)
756 		*tt_len = batadv_tt_len(num_entries);
757 
758 	tvlv_len = *tt_len;
759 	tvlv_len += change_offset;
760 
761 	*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
762 	if (!*tt_data) {
763 		*tt_len = 0;
764 		goto out;
765 	}
766 
767 	(*tt_data)->flags = BATADV_NO_FLAGS;
768 	(*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn);
769 	(*tt_data)->num_vlan = htons(num_vlan);
770 
771 	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
772 	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
773 		tt_vlan->vid = htons(vlan->vid);
774 		tt_vlan->crc = htonl(vlan->tt.crc);
775 
776 		tt_vlan++;
777 	}
778 
779 	tt_change_ptr = (u8 *)*tt_data + change_offset;
780 	*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
781 
782 out:
783 	rcu_read_unlock();
784 	return tvlv_len;
785 }
786 
787 /**
788  * batadv_tt_prepare_tvlv_local_data - allocate and prepare the TT TVLV for this
789  *  node
790  * @bat_priv: the bat priv with all the soft interface information
791  * @tt_data: uninitialised pointer to the address of the TVLV buffer
792  * @tt_change: uninitialised pointer to the address of the area where the TT
793  *  changes can be stored
794  * @tt_len: pointer to the length to reserve to the tt_change. if -1 this
795  *  function reserves the amount of space needed to send the entire local TT
796  *  table. In case of success the value is updated with the real amount of
797  *  reserved bytes
798  *
799  * Allocate the needed amount of memory for the entire TT TVLV and write its
800  * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data
801  * objects, one per active VLAN.
802  *
803  * Return the size of the allocated buffer or 0 in case of failure.
804  */
805 static u16
806 batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv,
807 				  struct batadv_tvlv_tt_data **tt_data,
808 				  struct batadv_tvlv_tt_change **tt_change,
809 				  s32 *tt_len)
810 {
811 	struct batadv_tvlv_tt_vlan_data *tt_vlan;
812 	struct batadv_softif_vlan *vlan;
813 	u16 num_vlan = 0;
814 	u16 num_entries = 0;
815 	u16 tvlv_len;
816 	u8 *tt_change_ptr;
817 	int change_offset;
818 
819 	rcu_read_lock();
820 	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
821 		num_vlan++;
822 		num_entries += atomic_read(&vlan->tt.num_entries);
823 	}
824 
825 	change_offset = sizeof(**tt_data);
826 	change_offset += num_vlan * sizeof(*tt_vlan);
827 
828 	/* if tt_len is negative, allocate the space needed by the full table */
829 	if (*tt_len < 0)
830 		*tt_len = batadv_tt_len(num_entries);
831 
832 	tvlv_len = *tt_len;
833 	tvlv_len += change_offset;
834 
835 	*tt_data = kmalloc(tvlv_len, GFP_ATOMIC);
836 	if (!*tt_data) {
837 		tvlv_len = 0;
838 		goto out;
839 	}
840 
841 	(*tt_data)->flags = BATADV_NO_FLAGS;
842 	(*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn);
843 	(*tt_data)->num_vlan = htons(num_vlan);
844 
845 	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1);
846 	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
847 		tt_vlan->vid = htons(vlan->vid);
848 		tt_vlan->crc = htonl(vlan->tt.crc);
849 
850 		tt_vlan++;
851 	}
852 
853 	tt_change_ptr = (u8 *)*tt_data + change_offset;
854 	*tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr;
855 
856 out:
857 	rcu_read_unlock();
858 	return tvlv_len;
859 }
860 
861 /**
862  * batadv_tt_tvlv_container_update - update the translation table tvlv container
863  *  after local tt changes have been committed
864  * @bat_priv: the bat priv with all the soft interface information
865  */
866 static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv)
867 {
868 	struct batadv_tt_change_node *entry, *safe;
869 	struct batadv_tvlv_tt_data *tt_data;
870 	struct batadv_tvlv_tt_change *tt_change;
871 	int tt_diff_len, tt_change_len = 0;
872 	int tt_diff_entries_num = 0;
873 	int tt_diff_entries_count = 0;
874 	u16 tvlv_len;
875 
876 	tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes);
877 	tt_diff_len = batadv_tt_len(tt_diff_entries_num);
878 
879 	/* if we have too many changes for one packet don't send any
880 	 * and wait for the tt table request which will be fragmented
881 	 */
882 	if (tt_diff_len > bat_priv->soft_iface->mtu)
883 		tt_diff_len = 0;
884 
885 	tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data,
886 						     &tt_change, &tt_diff_len);
887 	if (!tvlv_len)
888 		return;
889 
890 	tt_data->flags = BATADV_TT_OGM_DIFF;
891 
892 	if (tt_diff_len == 0)
893 		goto container_register;
894 
895 	spin_lock_bh(&bat_priv->tt.changes_list_lock);
896 	atomic_set(&bat_priv->tt.local_changes, 0);
897 
898 	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
899 				 list) {
900 		if (tt_diff_entries_count < tt_diff_entries_num) {
901 			memcpy(tt_change + tt_diff_entries_count,
902 			       &entry->change,
903 			       sizeof(struct batadv_tvlv_tt_change));
904 			tt_diff_entries_count++;
905 		}
906 		list_del(&entry->list);
907 		kfree(entry);
908 	}
909 	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
910 
911 	/* Keep the buffer for possible tt_request */
912 	spin_lock_bh(&bat_priv->tt.last_changeset_lock);
913 	kfree(bat_priv->tt.last_changeset);
914 	bat_priv->tt.last_changeset_len = 0;
915 	bat_priv->tt.last_changeset = NULL;
916 	tt_change_len = batadv_tt_len(tt_diff_entries_count);
917 	/* check whether this new OGM has no changes due to size problems */
918 	if (tt_diff_entries_count > 0) {
919 		/* if kmalloc() fails we will reply with the full table
920 		 * instead of providing the diff
921 		 */
922 		bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC);
923 		if (bat_priv->tt.last_changeset) {
924 			memcpy(bat_priv->tt.last_changeset,
925 			       tt_change, tt_change_len);
926 			bat_priv->tt.last_changeset_len = tt_diff_len;
927 		}
928 	}
929 	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
930 
931 container_register:
932 	batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data,
933 				       tvlv_len);
934 	kfree(tt_data);
935 }
936 
937 int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset)
938 {
939 	struct net_device *net_dev = (struct net_device *)seq->private;
940 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
941 	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
942 	struct batadv_tt_common_entry *tt_common_entry;
943 	struct batadv_tt_local_entry *tt_local;
944 	struct batadv_hard_iface *primary_if;
945 	struct batadv_softif_vlan *vlan;
946 	struct hlist_head *head;
947 	unsigned short vid;
948 	u32 i;
949 	int last_seen_secs;
950 	int last_seen_msecs;
951 	unsigned long last_seen_jiffies;
952 	bool no_purge;
953 	u16 np_flag = BATADV_TT_CLIENT_NOPURGE;
954 
955 	primary_if = batadv_seq_print_text_primary_if_get(seq);
956 	if (!primary_if)
957 		goto out;
958 
959 	seq_printf(seq,
960 		   "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n",
961 		   net_dev->name, (u8)atomic_read(&bat_priv->tt.vn));
962 	seq_printf(seq, "       %-13s  %s %-8s %-9s (%-10s)\n", "Client", "VID",
963 		   "Flags", "Last seen", "CRC");
964 
965 	for (i = 0; i < hash->size; i++) {
966 		head = &hash->table[i];
967 
968 		rcu_read_lock();
969 		hlist_for_each_entry_rcu(tt_common_entry,
970 					 head, hash_entry) {
971 			tt_local = container_of(tt_common_entry,
972 						struct batadv_tt_local_entry,
973 						common);
974 			vid = tt_common_entry->vid;
975 			last_seen_jiffies = jiffies - tt_local->last_seen;
976 			last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
977 			last_seen_secs = last_seen_msecs / 1000;
978 			last_seen_msecs = last_seen_msecs % 1000;
979 
980 			no_purge = tt_common_entry->flags & np_flag;
981 
982 			vlan = batadv_softif_vlan_get(bat_priv, vid);
983 			if (!vlan) {
984 				seq_printf(seq, "Cannot retrieve VLAN %d\n",
985 					   BATADV_PRINT_VID(vid));
986 				continue;
987 			}
988 
989 			seq_printf(seq,
990 				   " * %pM %4i [%c%c%c%c%c%c] %3u.%03u   (%#.8x)\n",
991 				   tt_common_entry->addr,
992 				   BATADV_PRINT_VID(tt_common_entry->vid),
993 				   ((tt_common_entry->flags &
994 				     BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
995 				   no_purge ? 'P' : '.',
996 				   ((tt_common_entry->flags &
997 				     BATADV_TT_CLIENT_NEW) ? 'N' : '.'),
998 				   ((tt_common_entry->flags &
999 				     BATADV_TT_CLIENT_PENDING) ? 'X' : '.'),
1000 				   ((tt_common_entry->flags &
1001 				     BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
1002 				   ((tt_common_entry->flags &
1003 				     BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
1004 				   no_purge ? 0 : last_seen_secs,
1005 				   no_purge ? 0 : last_seen_msecs,
1006 				   vlan->tt.crc);
1007 
1008 			batadv_softif_vlan_free_ref(vlan);
1009 		}
1010 		rcu_read_unlock();
1011 	}
1012 out:
1013 	if (primary_if)
1014 		batadv_hardif_free_ref(primary_if);
1015 	return 0;
1016 }
1017 
1018 static void
1019 batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
1020 			    struct batadv_tt_local_entry *tt_local_entry,
1021 			    u16 flags, const char *message)
1022 {
1023 	batadv_tt_local_event(bat_priv, tt_local_entry, flags);
1024 
1025 	/* The local client has to be marked as "pending to be removed" but has
1026 	 * to be kept in the table in order to send it in a full table
1027 	 * response issued before the net ttvn increment (consistency check)
1028 	 */
1029 	tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING;
1030 
1031 	batadv_dbg(BATADV_DBG_TT, bat_priv,
1032 		   "Local tt entry (%pM, vid: %d) pending to be removed: %s\n",
1033 		   tt_local_entry->common.addr,
1034 		   BATADV_PRINT_VID(tt_local_entry->common.vid), message);
1035 }
1036 
1037 /**
1038  * batadv_tt_local_remove - logically remove an entry from the local table
1039  * @bat_priv: the bat priv with all the soft interface information
1040  * @addr: the MAC address of the client to remove
1041  * @vid: VLAN identifier
1042  * @message: message to append to the log on deletion
1043  * @roaming: true if the deletion is due to a roaming event
1044  *
1045  * Returns the flags assigned to the local entry before being deleted
1046  */
1047 u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr,
1048 			   unsigned short vid, const char *message,
1049 			   bool roaming)
1050 {
1051 	struct batadv_tt_local_entry *tt_local_entry;
1052 	u16 flags, curr_flags = BATADV_NO_FLAGS;
1053 	struct batadv_softif_vlan *vlan;
1054 	void *tt_entry_exists;
1055 
1056 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
1057 	if (!tt_local_entry)
1058 		goto out;
1059 
1060 	curr_flags = tt_local_entry->common.flags;
1061 
1062 	flags = BATADV_TT_CLIENT_DEL;
1063 	/* if this global entry addition is due to a roaming, the node has to
1064 	 * mark the local entry as "roamed" in order to correctly reroute
1065 	 * packets later
1066 	 */
1067 	if (roaming) {
1068 		flags |= BATADV_TT_CLIENT_ROAM;
1069 		/* mark the local client as ROAMed */
1070 		tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
1071 	}
1072 
1073 	if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) {
1074 		batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags,
1075 					    message);
1076 		goto out;
1077 	}
1078 	/* if this client has been added right now, it is possible to
1079 	 * immediately purge it
1080 	 */
1081 	batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL);
1082 
1083 	tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash,
1084 					     batadv_compare_tt,
1085 					     batadv_choose_tt,
1086 					     &tt_local_entry->common);
1087 	if (!tt_entry_exists)
1088 		goto out;
1089 
1090 	/* extra call to free the local tt entry */
1091 	batadv_tt_local_entry_free_ref(tt_local_entry);
1092 
1093 	/* decrease the reference held for this vlan */
1094 	vlan = batadv_softif_vlan_get(bat_priv, vid);
1095 	if (!vlan)
1096 		goto out;
1097 
1098 	batadv_softif_vlan_free_ref(vlan);
1099 	batadv_softif_vlan_free_ref(vlan);
1100 
1101 out:
1102 	if (tt_local_entry)
1103 		batadv_tt_local_entry_free_ref(tt_local_entry);
1104 
1105 	return curr_flags;
1106 }
1107 
1108 /**
1109  * batadv_tt_local_purge_list - purge inactive tt local entries
1110  * @bat_priv: the bat priv with all the soft interface information
1111  * @head: pointer to the list containing the local tt entries
1112  * @timeout: parameter deciding whether a given tt local entry is considered
1113  *  inactive or not
1114  */
1115 static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv,
1116 				       struct hlist_head *head,
1117 				       int timeout)
1118 {
1119 	struct batadv_tt_local_entry *tt_local_entry;
1120 	struct batadv_tt_common_entry *tt_common_entry;
1121 	struct hlist_node *node_tmp;
1122 
1123 	hlist_for_each_entry_safe(tt_common_entry, node_tmp, head,
1124 				  hash_entry) {
1125 		tt_local_entry = container_of(tt_common_entry,
1126 					      struct batadv_tt_local_entry,
1127 					      common);
1128 		if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE)
1129 			continue;
1130 
1131 		/* entry already marked for deletion */
1132 		if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)
1133 			continue;
1134 
1135 		if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout))
1136 			continue;
1137 
1138 		batadv_tt_local_set_pending(bat_priv, tt_local_entry,
1139 					    BATADV_TT_CLIENT_DEL, "timed out");
1140 	}
1141 }
1142 
1143 /**
1144  * batadv_tt_local_purge - purge inactive tt local entries
1145  * @bat_priv: the bat priv with all the soft interface information
1146  * @timeout: parameter deciding whether a given tt local entry is considered
1147  *  inactive or not
1148  */
1149 static void batadv_tt_local_purge(struct batadv_priv *bat_priv,
1150 				  int timeout)
1151 {
1152 	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
1153 	struct hlist_head *head;
1154 	spinlock_t *list_lock; /* protects write access to the hash lists */
1155 	u32 i;
1156 
1157 	for (i = 0; i < hash->size; i++) {
1158 		head = &hash->table[i];
1159 		list_lock = &hash->list_locks[i];
1160 
1161 		spin_lock_bh(list_lock);
1162 		batadv_tt_local_purge_list(bat_priv, head, timeout);
1163 		spin_unlock_bh(list_lock);
1164 	}
1165 }
1166 
1167 static void batadv_tt_local_table_free(struct batadv_priv *bat_priv)
1168 {
1169 	struct batadv_hashtable *hash;
1170 	spinlock_t *list_lock; /* protects write access to the hash lists */
1171 	struct batadv_tt_common_entry *tt_common_entry;
1172 	struct batadv_tt_local_entry *tt_local;
1173 	struct batadv_softif_vlan *vlan;
1174 	struct hlist_node *node_tmp;
1175 	struct hlist_head *head;
1176 	u32 i;
1177 
1178 	if (!bat_priv->tt.local_hash)
1179 		return;
1180 
1181 	hash = bat_priv->tt.local_hash;
1182 
1183 	for (i = 0; i < hash->size; i++) {
1184 		head = &hash->table[i];
1185 		list_lock = &hash->list_locks[i];
1186 
1187 		spin_lock_bh(list_lock);
1188 		hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1189 					  head, hash_entry) {
1190 			hlist_del_rcu(&tt_common_entry->hash_entry);
1191 			tt_local = container_of(tt_common_entry,
1192 						struct batadv_tt_local_entry,
1193 						common);
1194 
1195 			/* decrease the reference held for this vlan */
1196 			vlan = batadv_softif_vlan_get(bat_priv,
1197 						      tt_common_entry->vid);
1198 			if (vlan) {
1199 				batadv_softif_vlan_free_ref(vlan);
1200 				batadv_softif_vlan_free_ref(vlan);
1201 			}
1202 
1203 			batadv_tt_local_entry_free_ref(tt_local);
1204 		}
1205 		spin_unlock_bh(list_lock);
1206 	}
1207 
1208 	batadv_hash_destroy(hash);
1209 
1210 	bat_priv->tt.local_hash = NULL;
1211 }
1212 
1213 static int batadv_tt_global_init(struct batadv_priv *bat_priv)
1214 {
1215 	if (bat_priv->tt.global_hash)
1216 		return 0;
1217 
1218 	bat_priv->tt.global_hash = batadv_hash_new(1024);
1219 
1220 	if (!bat_priv->tt.global_hash)
1221 		return -ENOMEM;
1222 
1223 	batadv_hash_set_lock_class(bat_priv->tt.global_hash,
1224 				   &batadv_tt_global_hash_lock_class_key);
1225 
1226 	return 0;
1227 }
1228 
1229 static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv)
1230 {
1231 	struct batadv_tt_change_node *entry, *safe;
1232 
1233 	spin_lock_bh(&bat_priv->tt.changes_list_lock);
1234 
1235 	list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list,
1236 				 list) {
1237 		list_del(&entry->list);
1238 		kfree(entry);
1239 	}
1240 
1241 	atomic_set(&bat_priv->tt.local_changes, 0);
1242 	spin_unlock_bh(&bat_priv->tt.changes_list_lock);
1243 }
1244 
1245 /* retrieves the orig_tt_list_entry belonging to orig_node from the
1246  * batadv_tt_global_entry list
1247  *
1248  * returns it with an increased refcounter, NULL if not found
1249  */
1250 static struct batadv_tt_orig_list_entry *
1251 batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry,
1252 				 const struct batadv_orig_node *orig_node)
1253 {
1254 	struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL;
1255 	const struct hlist_head *head;
1256 
1257 	rcu_read_lock();
1258 	head = &entry->orig_list;
1259 	hlist_for_each_entry_rcu(tmp_orig_entry, head, list) {
1260 		if (tmp_orig_entry->orig_node != orig_node)
1261 			continue;
1262 		if (!atomic_inc_not_zero(&tmp_orig_entry->refcount))
1263 			continue;
1264 
1265 		orig_entry = tmp_orig_entry;
1266 		break;
1267 	}
1268 	rcu_read_unlock();
1269 
1270 	return orig_entry;
1271 }
1272 
1273 /* find out if an orig_node is already in the list of a tt_global_entry.
1274  * returns true if found, false otherwise
1275  */
1276 static bool
1277 batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry,
1278 				const struct batadv_orig_node *orig_node)
1279 {
1280 	struct batadv_tt_orig_list_entry *orig_entry;
1281 	bool found = false;
1282 
1283 	orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node);
1284 	if (orig_entry) {
1285 		found = true;
1286 		batadv_tt_orig_list_entry_free_ref(orig_entry);
1287 	}
1288 
1289 	return found;
1290 }
1291 
1292 static void
1293 batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global,
1294 				struct batadv_orig_node *orig_node, int ttvn)
1295 {
1296 	struct batadv_tt_orig_list_entry *orig_entry;
1297 
1298 	orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node);
1299 	if (orig_entry) {
1300 		/* refresh the ttvn: the current value could be a bogus one that
1301 		 * was added during a "temporary client detection"
1302 		 */
1303 		orig_entry->ttvn = ttvn;
1304 		goto out;
1305 	}
1306 
1307 	orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC);
1308 	if (!orig_entry)
1309 		goto out;
1310 
1311 	INIT_HLIST_NODE(&orig_entry->list);
1312 	atomic_inc(&orig_node->refcount);
1313 	batadv_tt_global_size_inc(orig_node, tt_global->common.vid);
1314 	orig_entry->orig_node = orig_node;
1315 	orig_entry->ttvn = ttvn;
1316 	atomic_set(&orig_entry->refcount, 2);
1317 
1318 	spin_lock_bh(&tt_global->list_lock);
1319 	hlist_add_head_rcu(&orig_entry->list,
1320 			   &tt_global->orig_list);
1321 	spin_unlock_bh(&tt_global->list_lock);
1322 	atomic_inc(&tt_global->orig_list_count);
1323 
1324 out:
1325 	if (orig_entry)
1326 		batadv_tt_orig_list_entry_free_ref(orig_entry);
1327 }
1328 
1329 /**
1330  * batadv_tt_global_add - add a new TT global entry or update an existing one
1331  * @bat_priv: the bat priv with all the soft interface information
1332  * @orig_node: the originator announcing the client
1333  * @tt_addr: the mac address of the non-mesh client
1334  * @vid: VLAN identifier
1335  * @flags: TT flags that have to be set for this non-mesh client
1336  * @ttvn: the tt version number ever announcing this non-mesh client
1337  *
1338  * Add a new TT global entry for the given originator. If the entry already
1339  * exists add a new reference to the given originator (a global entry can have
1340  * references to multiple originators) and adjust the flags attribute to reflect
1341  * the function argument.
1342  * If a TT local entry exists for this non-mesh client remove it.
1343  *
1344  * The caller must hold orig_node refcount.
1345  *
1346  * Return true if the new entry has been added, false otherwise
1347  */
1348 static bool batadv_tt_global_add(struct batadv_priv *bat_priv,
1349 				 struct batadv_orig_node *orig_node,
1350 				 const unsigned char *tt_addr,
1351 				 unsigned short vid, u16 flags, u8 ttvn)
1352 {
1353 	struct batadv_tt_global_entry *tt_global_entry;
1354 	struct batadv_tt_local_entry *tt_local_entry;
1355 	bool ret = false;
1356 	int hash_added;
1357 	struct batadv_tt_common_entry *common;
1358 	u16 local_flags;
1359 
1360 	/* ignore global entries from backbone nodes */
1361 	if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid))
1362 		return true;
1363 
1364 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid);
1365 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid);
1366 
1367 	/* if the node already has a local client for this entry, it has to wait
1368 	 * for a roaming advertisement instead of manually messing up the global
1369 	 * table
1370 	 */
1371 	if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry &&
1372 	    !(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW))
1373 		goto out;
1374 
1375 	if (!tt_global_entry) {
1376 		tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC);
1377 		if (!tt_global_entry)
1378 			goto out;
1379 
1380 		common = &tt_global_entry->common;
1381 		ether_addr_copy(common->addr, tt_addr);
1382 		common->vid = vid;
1383 
1384 		common->flags = flags;
1385 		tt_global_entry->roam_at = 0;
1386 		/* node must store current time in case of roaming. This is
1387 		 * needed to purge this entry out on timeout (if nobody claims
1388 		 * it)
1389 		 */
1390 		if (flags & BATADV_TT_CLIENT_ROAM)
1391 			tt_global_entry->roam_at = jiffies;
1392 		atomic_set(&common->refcount, 2);
1393 		common->added_at = jiffies;
1394 
1395 		INIT_HLIST_HEAD(&tt_global_entry->orig_list);
1396 		atomic_set(&tt_global_entry->orig_list_count, 0);
1397 		spin_lock_init(&tt_global_entry->list_lock);
1398 
1399 		hash_added = batadv_hash_add(bat_priv->tt.global_hash,
1400 					     batadv_compare_tt,
1401 					     batadv_choose_tt, common,
1402 					     &common->hash_entry);
1403 
1404 		if (unlikely(hash_added != 0)) {
1405 			/* remove the reference for the hash */
1406 			batadv_tt_global_entry_free_ref(tt_global_entry);
1407 			goto out_remove;
1408 		}
1409 	} else {
1410 		common = &tt_global_entry->common;
1411 		/* If there is already a global entry, we can use this one for
1412 		 * our processing.
1413 		 * But if we are trying to add a temporary client then here are
1414 		 * two options at this point:
1415 		 * 1) the global client is not a temporary client: the global
1416 		 *    client has to be left as it is, temporary information
1417 		 *    should never override any already known client state
1418 		 * 2) the global client is a temporary client: purge the
1419 		 *    originator list and add the new one orig_entry
1420 		 */
1421 		if (flags & BATADV_TT_CLIENT_TEMP) {
1422 			if (!(common->flags & BATADV_TT_CLIENT_TEMP))
1423 				goto out;
1424 			if (batadv_tt_global_entry_has_orig(tt_global_entry,
1425 							    orig_node))
1426 				goto out_remove;
1427 			batadv_tt_global_del_orig_list(tt_global_entry);
1428 			goto add_orig_entry;
1429 		}
1430 
1431 		/* if the client was temporary added before receiving the first
1432 		 * OGM announcing it, we have to clear the TEMP flag. Also,
1433 		 * remove the previous temporary orig node and re-add it
1434 		 * if required. If the orig entry changed, the new one which
1435 		 * is a non-temporary entry is preferred.
1436 		 */
1437 		if (common->flags & BATADV_TT_CLIENT_TEMP) {
1438 			batadv_tt_global_del_orig_list(tt_global_entry);
1439 			common->flags &= ~BATADV_TT_CLIENT_TEMP;
1440 		}
1441 
1442 		/* the change can carry possible "attribute" flags like the
1443 		 * TT_CLIENT_WIFI, therefore they have to be copied in the
1444 		 * client entry
1445 		 */
1446 		tt_global_entry->common.flags |= flags;
1447 
1448 		/* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only
1449 		 * one originator left in the list and we previously received a
1450 		 * delete + roaming change for this originator.
1451 		 *
1452 		 * We should first delete the old originator before adding the
1453 		 * new one.
1454 		 */
1455 		if (common->flags & BATADV_TT_CLIENT_ROAM) {
1456 			batadv_tt_global_del_orig_list(tt_global_entry);
1457 			common->flags &= ~BATADV_TT_CLIENT_ROAM;
1458 			tt_global_entry->roam_at = 0;
1459 		}
1460 	}
1461 add_orig_entry:
1462 	/* add the new orig_entry (if needed) or update it */
1463 	batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn);
1464 
1465 	batadv_dbg(BATADV_DBG_TT, bat_priv,
1466 		   "Creating new global tt entry: %pM (vid: %d, via %pM)\n",
1467 		   common->addr, BATADV_PRINT_VID(common->vid),
1468 		   orig_node->orig);
1469 	ret = true;
1470 
1471 out_remove:
1472 	/* Do not remove multicast addresses from the local hash on
1473 	 * global additions
1474 	 */
1475 	if (is_multicast_ether_addr(tt_addr))
1476 		goto out;
1477 
1478 	/* remove address from local hash if present */
1479 	local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid,
1480 					     "global tt received",
1481 					     flags & BATADV_TT_CLIENT_ROAM);
1482 	tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI;
1483 
1484 	if (!(flags & BATADV_TT_CLIENT_ROAM))
1485 		/* this is a normal global add. Therefore the client is not in a
1486 		 * roaming state anymore.
1487 		 */
1488 		tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM;
1489 
1490 out:
1491 	if (tt_global_entry)
1492 		batadv_tt_global_entry_free_ref(tt_global_entry);
1493 	if (tt_local_entry)
1494 		batadv_tt_local_entry_free_ref(tt_local_entry);
1495 	return ret;
1496 }
1497 
1498 /**
1499  * batadv_transtable_best_orig - Get best originator list entry from tt entry
1500  * @bat_priv: the bat priv with all the soft interface information
1501  * @tt_global_entry: global translation table entry to be analyzed
1502  *
1503  * This functon assumes the caller holds rcu_read_lock().
1504  * Returns best originator list entry or NULL on errors.
1505  */
1506 static struct batadv_tt_orig_list_entry *
1507 batadv_transtable_best_orig(struct batadv_priv *bat_priv,
1508 			    struct batadv_tt_global_entry *tt_global_entry)
1509 {
1510 	struct batadv_neigh_node *router, *best_router = NULL;
1511 	struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
1512 	struct hlist_head *head;
1513 	struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL;
1514 
1515 	head = &tt_global_entry->orig_list;
1516 	hlist_for_each_entry_rcu(orig_entry, head, list) {
1517 		router = batadv_orig_router_get(orig_entry->orig_node,
1518 						BATADV_IF_DEFAULT);
1519 		if (!router)
1520 			continue;
1521 
1522 		if (best_router &&
1523 		    bao->bat_neigh_cmp(router, BATADV_IF_DEFAULT,
1524 				       best_router, BATADV_IF_DEFAULT) <= 0) {
1525 			batadv_neigh_node_free_ref(router);
1526 			continue;
1527 		}
1528 
1529 		/* release the refcount for the "old" best */
1530 		if (best_router)
1531 			batadv_neigh_node_free_ref(best_router);
1532 
1533 		best_entry = orig_entry;
1534 		best_router = router;
1535 	}
1536 
1537 	if (best_router)
1538 		batadv_neigh_node_free_ref(best_router);
1539 
1540 	return best_entry;
1541 }
1542 
1543 /**
1544  * batadv_tt_global_print_entry - print all orig nodes who announce the address
1545  *  for this global entry
1546  * @bat_priv: the bat priv with all the soft interface information
1547  * @tt_global_entry: global translation table entry to be printed
1548  * @seq: debugfs table seq_file struct
1549  *
1550  * This functon assumes the caller holds rcu_read_lock().
1551  */
1552 static void
1553 batadv_tt_global_print_entry(struct batadv_priv *bat_priv,
1554 			     struct batadv_tt_global_entry *tt_global_entry,
1555 			     struct seq_file *seq)
1556 {
1557 	struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
1558 	struct batadv_tt_common_entry *tt_common_entry;
1559 	struct batadv_orig_node_vlan *vlan;
1560 	struct hlist_head *head;
1561 	u8 last_ttvn;
1562 	u16 flags;
1563 
1564 	tt_common_entry = &tt_global_entry->common;
1565 	flags = tt_common_entry->flags;
1566 
1567 	best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
1568 	if (best_entry) {
1569 		vlan = batadv_orig_node_vlan_get(best_entry->orig_node,
1570 						 tt_common_entry->vid);
1571 		if (!vlan) {
1572 			seq_printf(seq,
1573 				   " * Cannot retrieve VLAN %d for originator %pM\n",
1574 				   BATADV_PRINT_VID(tt_common_entry->vid),
1575 				   best_entry->orig_node->orig);
1576 			goto print_list;
1577 		}
1578 
1579 		last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn);
1580 		seq_printf(seq,
1581 			   " %c %pM %4i   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]\n",
1582 			   '*', tt_global_entry->common.addr,
1583 			   BATADV_PRINT_VID(tt_global_entry->common.vid),
1584 			   best_entry->ttvn, best_entry->orig_node->orig,
1585 			   last_ttvn, vlan->tt.crc,
1586 			   ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
1587 			   ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
1588 			   ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
1589 			   ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));
1590 
1591 		batadv_orig_node_vlan_free_ref(vlan);
1592 	}
1593 
1594 print_list:
1595 	head = &tt_global_entry->orig_list;
1596 
1597 	hlist_for_each_entry_rcu(orig_entry, head, list) {
1598 		if (best_entry == orig_entry)
1599 			continue;
1600 
1601 		vlan = batadv_orig_node_vlan_get(orig_entry->orig_node,
1602 						 tt_common_entry->vid);
1603 		if (!vlan) {
1604 			seq_printf(seq,
1605 				   " + Cannot retrieve VLAN %d for originator %pM\n",
1606 				   BATADV_PRINT_VID(tt_common_entry->vid),
1607 				   orig_entry->orig_node->orig);
1608 			continue;
1609 		}
1610 
1611 		last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn);
1612 		seq_printf(seq,
1613 			   " %c %pM %4d   (%3u) via %pM     (%3u)   (%#.8x) [%c%c%c%c]\n",
1614 			   '+', tt_global_entry->common.addr,
1615 			   BATADV_PRINT_VID(tt_global_entry->common.vid),
1616 			   orig_entry->ttvn, orig_entry->orig_node->orig,
1617 			   last_ttvn, vlan->tt.crc,
1618 			   ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'),
1619 			   ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'),
1620 			   ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'),
1621 			   ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.'));
1622 
1623 		batadv_orig_node_vlan_free_ref(vlan);
1624 	}
1625 }
1626 
1627 int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset)
1628 {
1629 	struct net_device *net_dev = (struct net_device *)seq->private;
1630 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
1631 	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1632 	struct batadv_tt_common_entry *tt_common_entry;
1633 	struct batadv_tt_global_entry *tt_global;
1634 	struct batadv_hard_iface *primary_if;
1635 	struct hlist_head *head;
1636 	u32 i;
1637 
1638 	primary_if = batadv_seq_print_text_primary_if_get(seq);
1639 	if (!primary_if)
1640 		goto out;
1641 
1642 	seq_printf(seq,
1643 		   "Globally announced TT entries received via the mesh %s\n",
1644 		   net_dev->name);
1645 	seq_printf(seq, "       %-13s  %s  %s       %-15s %s (%-10s) %s\n",
1646 		   "Client", "VID", "(TTVN)", "Originator", "(Curr TTVN)",
1647 		   "CRC", "Flags");
1648 
1649 	for (i = 0; i < hash->size; i++) {
1650 		head = &hash->table[i];
1651 
1652 		rcu_read_lock();
1653 		hlist_for_each_entry_rcu(tt_common_entry,
1654 					 head, hash_entry) {
1655 			tt_global = container_of(tt_common_entry,
1656 						 struct batadv_tt_global_entry,
1657 						 common);
1658 			batadv_tt_global_print_entry(bat_priv, tt_global, seq);
1659 		}
1660 		rcu_read_unlock();
1661 	}
1662 out:
1663 	if (primary_if)
1664 		batadv_hardif_free_ref(primary_if);
1665 	return 0;
1666 }
1667 
1668 /**
1669  * _batadv_tt_global_del_orig_entry - remove and free an orig_entry
1670  * @tt_global_entry: the global entry to remove the orig_entry from
1671  * @orig_entry: the orig entry to remove and free
1672  *
1673  * Remove an orig_entry from its list in the given tt_global_entry and
1674  * free this orig_entry afterwards.
1675  *
1676  * Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is
1677  * part of a list.
1678  */
1679 static void
1680 _batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry,
1681 				 struct batadv_tt_orig_list_entry *orig_entry)
1682 {
1683 	lockdep_assert_held(&tt_global_entry->list_lock);
1684 
1685 	batadv_tt_global_size_dec(orig_entry->orig_node,
1686 				  tt_global_entry->common.vid);
1687 	atomic_dec(&tt_global_entry->orig_list_count);
1688 	/* requires holding tt_global_entry->list_lock and orig_entry->list
1689 	 * being part of a list
1690 	 */
1691 	hlist_del_rcu(&orig_entry->list);
1692 	batadv_tt_orig_list_entry_free_ref(orig_entry);
1693 }
1694 
1695 /* deletes the orig list of a tt_global_entry */
1696 static void
1697 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry)
1698 {
1699 	struct hlist_head *head;
1700 	struct hlist_node *safe;
1701 	struct batadv_tt_orig_list_entry *orig_entry;
1702 
1703 	spin_lock_bh(&tt_global_entry->list_lock);
1704 	head = &tt_global_entry->orig_list;
1705 	hlist_for_each_entry_safe(orig_entry, safe, head, list)
1706 		_batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry);
1707 	spin_unlock_bh(&tt_global_entry->list_lock);
1708 }
1709 
1710 /**
1711  * batadv_tt_global_del_orig_node - remove orig_node from a global tt entry
1712  * @bat_priv: the bat priv with all the soft interface information
1713  * @tt_global_entry: the global entry to remove the orig_node from
1714  * @orig_node: the originator announcing the client
1715  * @message: message to append to the log on deletion
1716  *
1717  * Remove the given orig_node and its according orig_entry from the given
1718  * global tt entry.
1719  */
1720 static void
1721 batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv,
1722 			       struct batadv_tt_global_entry *tt_global_entry,
1723 			       struct batadv_orig_node *orig_node,
1724 			       const char *message)
1725 {
1726 	struct hlist_head *head;
1727 	struct hlist_node *safe;
1728 	struct batadv_tt_orig_list_entry *orig_entry;
1729 	unsigned short vid;
1730 
1731 	spin_lock_bh(&tt_global_entry->list_lock);
1732 	head = &tt_global_entry->orig_list;
1733 	hlist_for_each_entry_safe(orig_entry, safe, head, list) {
1734 		if (orig_entry->orig_node == orig_node) {
1735 			vid = tt_global_entry->common.vid;
1736 			batadv_dbg(BATADV_DBG_TT, bat_priv,
1737 				   "Deleting %pM from global tt entry %pM (vid: %d): %s\n",
1738 				   orig_node->orig,
1739 				   tt_global_entry->common.addr,
1740 				   BATADV_PRINT_VID(vid), message);
1741 			_batadv_tt_global_del_orig_entry(tt_global_entry,
1742 							 orig_entry);
1743 		}
1744 	}
1745 	spin_unlock_bh(&tt_global_entry->list_lock);
1746 }
1747 
1748 /* If the client is to be deleted, we check if it is the last origantor entry
1749  * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the
1750  * timer, otherwise we simply remove the originator scheduled for deletion.
1751  */
1752 static void
1753 batadv_tt_global_del_roaming(struct batadv_priv *bat_priv,
1754 			     struct batadv_tt_global_entry *tt_global_entry,
1755 			     struct batadv_orig_node *orig_node,
1756 			     const char *message)
1757 {
1758 	bool last_entry = true;
1759 	struct hlist_head *head;
1760 	struct batadv_tt_orig_list_entry *orig_entry;
1761 
1762 	/* no local entry exists, case 1:
1763 	 * Check if this is the last one or if other entries exist.
1764 	 */
1765 
1766 	rcu_read_lock();
1767 	head = &tt_global_entry->orig_list;
1768 	hlist_for_each_entry_rcu(orig_entry, head, list) {
1769 		if (orig_entry->orig_node != orig_node) {
1770 			last_entry = false;
1771 			break;
1772 		}
1773 	}
1774 	rcu_read_unlock();
1775 
1776 	if (last_entry) {
1777 		/* its the last one, mark for roaming. */
1778 		tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM;
1779 		tt_global_entry->roam_at = jiffies;
1780 	} else
1781 		/* there is another entry, we can simply delete this
1782 		 * one and can still use the other one.
1783 		 */
1784 		batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
1785 					       orig_node, message);
1786 }
1787 
1788 /**
1789  * batadv_tt_global_del - remove a client from the global table
1790  * @bat_priv: the bat priv with all the soft interface information
1791  * @orig_node: an originator serving this client
1792  * @addr: the mac address of the client
1793  * @vid: VLAN identifier
1794  * @message: a message explaining the reason for deleting the client to print
1795  *  for debugging purpose
1796  * @roaming: true if the deletion has been triggered by a roaming event
1797  */
1798 static void batadv_tt_global_del(struct batadv_priv *bat_priv,
1799 				 struct batadv_orig_node *orig_node,
1800 				 const unsigned char *addr, unsigned short vid,
1801 				 const char *message, bool roaming)
1802 {
1803 	struct batadv_tt_global_entry *tt_global_entry;
1804 	struct batadv_tt_local_entry *local_entry = NULL;
1805 
1806 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
1807 	if (!tt_global_entry)
1808 		goto out;
1809 
1810 	if (!roaming) {
1811 		batadv_tt_global_del_orig_node(bat_priv, tt_global_entry,
1812 					       orig_node, message);
1813 
1814 		if (hlist_empty(&tt_global_entry->orig_list))
1815 			batadv_tt_global_free(bat_priv, tt_global_entry,
1816 					      message);
1817 
1818 		goto out;
1819 	}
1820 
1821 	/* if we are deleting a global entry due to a roam
1822 	 * event, there are two possibilities:
1823 	 * 1) the client roamed from node A to node B => if there
1824 	 *    is only one originator left for this client, we mark
1825 	 *    it with BATADV_TT_CLIENT_ROAM, we start a timer and we
1826 	 *    wait for node B to claim it. In case of timeout
1827 	 *    the entry is purged.
1828 	 *
1829 	 *    If there are other originators left, we directly delete
1830 	 *    the originator.
1831 	 * 2) the client roamed to us => we can directly delete
1832 	 *    the global entry, since it is useless now.
1833 	 */
1834 	local_entry = batadv_tt_local_hash_find(bat_priv,
1835 						tt_global_entry->common.addr,
1836 						vid);
1837 	if (local_entry) {
1838 		/* local entry exists, case 2: client roamed to us. */
1839 		batadv_tt_global_del_orig_list(tt_global_entry);
1840 		batadv_tt_global_free(bat_priv, tt_global_entry, message);
1841 	} else
1842 		/* no local entry exists, case 1: check for roaming */
1843 		batadv_tt_global_del_roaming(bat_priv, tt_global_entry,
1844 					     orig_node, message);
1845 
1846 out:
1847 	if (tt_global_entry)
1848 		batadv_tt_global_entry_free_ref(tt_global_entry);
1849 	if (local_entry)
1850 		batadv_tt_local_entry_free_ref(local_entry);
1851 }
1852 
1853 /**
1854  * batadv_tt_global_del_orig - remove all the TT global entries belonging to the
1855  *  given originator matching the provided vid
1856  * @bat_priv: the bat priv with all the soft interface information
1857  * @orig_node: the originator owning the entries to remove
1858  * @match_vid: the VLAN identifier to match. If negative all the entries will be
1859  *  removed
1860  * @message: debug message to print as "reason"
1861  */
1862 void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
1863 			       struct batadv_orig_node *orig_node,
1864 			       s32 match_vid,
1865 			       const char *message)
1866 {
1867 	struct batadv_tt_global_entry *tt_global;
1868 	struct batadv_tt_common_entry *tt_common_entry;
1869 	u32 i;
1870 	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1871 	struct hlist_node *safe;
1872 	struct hlist_head *head;
1873 	spinlock_t *list_lock; /* protects write access to the hash lists */
1874 	unsigned short vid;
1875 
1876 	if (!hash)
1877 		return;
1878 
1879 	for (i = 0; i < hash->size; i++) {
1880 		head = &hash->table[i];
1881 		list_lock = &hash->list_locks[i];
1882 
1883 		spin_lock_bh(list_lock);
1884 		hlist_for_each_entry_safe(tt_common_entry, safe,
1885 					  head, hash_entry) {
1886 			/* remove only matching entries */
1887 			if (match_vid >= 0 && tt_common_entry->vid != match_vid)
1888 				continue;
1889 
1890 			tt_global = container_of(tt_common_entry,
1891 						 struct batadv_tt_global_entry,
1892 						 common);
1893 
1894 			batadv_tt_global_del_orig_node(bat_priv, tt_global,
1895 						       orig_node, message);
1896 
1897 			if (hlist_empty(&tt_global->orig_list)) {
1898 				vid = tt_global->common.vid;
1899 				batadv_dbg(BATADV_DBG_TT, bat_priv,
1900 					   "Deleting global tt entry %pM (vid: %d): %s\n",
1901 					   tt_global->common.addr,
1902 					   BATADV_PRINT_VID(vid), message);
1903 				hlist_del_rcu(&tt_common_entry->hash_entry);
1904 				batadv_tt_global_entry_free_ref(tt_global);
1905 			}
1906 		}
1907 		spin_unlock_bh(list_lock);
1908 	}
1909 	clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
1910 }
1911 
1912 static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global,
1913 				      char **msg)
1914 {
1915 	bool purge = false;
1916 	unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT;
1917 	unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT;
1918 
1919 	if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) &&
1920 	    batadv_has_timed_out(tt_global->roam_at, roam_timeout)) {
1921 		purge = true;
1922 		*msg = "Roaming timeout\n";
1923 	}
1924 
1925 	if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) &&
1926 	    batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) {
1927 		purge = true;
1928 		*msg = "Temporary client timeout\n";
1929 	}
1930 
1931 	return purge;
1932 }
1933 
1934 static void batadv_tt_global_purge(struct batadv_priv *bat_priv)
1935 {
1936 	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
1937 	struct hlist_head *head;
1938 	struct hlist_node *node_tmp;
1939 	spinlock_t *list_lock; /* protects write access to the hash lists */
1940 	u32 i;
1941 	char *msg = NULL;
1942 	struct batadv_tt_common_entry *tt_common;
1943 	struct batadv_tt_global_entry *tt_global;
1944 
1945 	for (i = 0; i < hash->size; i++) {
1946 		head = &hash->table[i];
1947 		list_lock = &hash->list_locks[i];
1948 
1949 		spin_lock_bh(list_lock);
1950 		hlist_for_each_entry_safe(tt_common, node_tmp, head,
1951 					  hash_entry) {
1952 			tt_global = container_of(tt_common,
1953 						 struct batadv_tt_global_entry,
1954 						 common);
1955 
1956 			if (!batadv_tt_global_to_purge(tt_global, &msg))
1957 				continue;
1958 
1959 			batadv_dbg(BATADV_DBG_TT, bat_priv,
1960 				   "Deleting global tt entry %pM (vid: %d): %s\n",
1961 				   tt_global->common.addr,
1962 				   BATADV_PRINT_VID(tt_global->common.vid),
1963 				   msg);
1964 
1965 			hlist_del_rcu(&tt_common->hash_entry);
1966 
1967 			batadv_tt_global_entry_free_ref(tt_global);
1968 		}
1969 		spin_unlock_bh(list_lock);
1970 	}
1971 }
1972 
1973 static void batadv_tt_global_table_free(struct batadv_priv *bat_priv)
1974 {
1975 	struct batadv_hashtable *hash;
1976 	spinlock_t *list_lock; /* protects write access to the hash lists */
1977 	struct batadv_tt_common_entry *tt_common_entry;
1978 	struct batadv_tt_global_entry *tt_global;
1979 	struct hlist_node *node_tmp;
1980 	struct hlist_head *head;
1981 	u32 i;
1982 
1983 	if (!bat_priv->tt.global_hash)
1984 		return;
1985 
1986 	hash = bat_priv->tt.global_hash;
1987 
1988 	for (i = 0; i < hash->size; i++) {
1989 		head = &hash->table[i];
1990 		list_lock = &hash->list_locks[i];
1991 
1992 		spin_lock_bh(list_lock);
1993 		hlist_for_each_entry_safe(tt_common_entry, node_tmp,
1994 					  head, hash_entry) {
1995 			hlist_del_rcu(&tt_common_entry->hash_entry);
1996 			tt_global = container_of(tt_common_entry,
1997 						 struct batadv_tt_global_entry,
1998 						 common);
1999 			batadv_tt_global_entry_free_ref(tt_global);
2000 		}
2001 		spin_unlock_bh(list_lock);
2002 	}
2003 
2004 	batadv_hash_destroy(hash);
2005 
2006 	bat_priv->tt.global_hash = NULL;
2007 }
2008 
2009 static bool
2010 _batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry,
2011 		       struct batadv_tt_global_entry *tt_global_entry)
2012 {
2013 	bool ret = false;
2014 
2015 	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI &&
2016 	    tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI)
2017 		ret = true;
2018 
2019 	/* check if the two clients are marked as isolated */
2020 	if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA &&
2021 	    tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA)
2022 		ret = true;
2023 
2024 	return ret;
2025 }
2026 
2027 /**
2028  * batadv_transtable_search - get the mesh destination for a given client
2029  * @bat_priv: the bat priv with all the soft interface information
2030  * @src: mac address of the source client
2031  * @addr: mac address of the destination client
2032  * @vid: VLAN identifier
2033  *
2034  * Returns a pointer to the originator that was selected as destination in the
2035  * mesh for contacting the client 'addr', NULL otherwise.
2036  * In case of multiple originators serving the same client, the function returns
2037  * the best one (best in terms of metric towards the destination node).
2038  *
2039  * If the two clients are AP isolated the function returns NULL.
2040  */
2041 struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv,
2042 						  const u8 *src,
2043 						  const u8 *addr,
2044 						  unsigned short vid)
2045 {
2046 	struct batadv_tt_local_entry *tt_local_entry = NULL;
2047 	struct batadv_tt_global_entry *tt_global_entry = NULL;
2048 	struct batadv_orig_node *orig_node = NULL;
2049 	struct batadv_tt_orig_list_entry *best_entry;
2050 
2051 	if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) {
2052 		tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid);
2053 		if (!tt_local_entry ||
2054 		    (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING))
2055 			goto out;
2056 	}
2057 
2058 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
2059 	if (!tt_global_entry)
2060 		goto out;
2061 
2062 	/* check whether the clients should not communicate due to AP
2063 	 * isolation
2064 	 */
2065 	if (tt_local_entry &&
2066 	    _batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
2067 		goto out;
2068 
2069 	rcu_read_lock();
2070 	best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry);
2071 	/* found anything? */
2072 	if (best_entry)
2073 		orig_node = best_entry->orig_node;
2074 	if (orig_node && !atomic_inc_not_zero(&orig_node->refcount))
2075 		orig_node = NULL;
2076 	rcu_read_unlock();
2077 
2078 out:
2079 	if (tt_global_entry)
2080 		batadv_tt_global_entry_free_ref(tt_global_entry);
2081 	if (tt_local_entry)
2082 		batadv_tt_local_entry_free_ref(tt_local_entry);
2083 
2084 	return orig_node;
2085 }
2086 
2087 /**
2088  * batadv_tt_global_crc - calculates the checksum of the local table belonging
2089  *  to the given orig_node
2090  * @bat_priv: the bat priv with all the soft interface information
2091  * @orig_node: originator for which the CRC should be computed
2092  * @vid: VLAN identifier for which the CRC32 has to be computed
2093  *
2094  * This function computes the checksum for the global table corresponding to a
2095  * specific originator. In particular, the checksum is computed as follows: For
2096  * each client connected to the originator the CRC32C of the MAC address and the
2097  * VID is computed and then all the CRC32Cs of the various clients are xor'ed
2098  * together.
2099  *
2100  * The idea behind is that CRC32C should be used as much as possible in order to
2101  * produce a unique hash of the table, but since the order which is used to feed
2102  * the CRC32C function affects the result and since every node in the network
2103  * probably sorts the clients differently, the hash function cannot be directly
2104  * computed over the entire table. Hence the CRC32C is used only on
2105  * the single client entry, while all the results are then xor'ed together
2106  * because the XOR operation can combine them all while trying to reduce the
2107  * noise as much as possible.
2108  *
2109  * Returns the checksum of the global table of a given originator.
2110  */
2111 static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv,
2112 				struct batadv_orig_node *orig_node,
2113 				unsigned short vid)
2114 {
2115 	struct batadv_hashtable *hash = bat_priv->tt.global_hash;
2116 	struct batadv_tt_common_entry *tt_common;
2117 	struct batadv_tt_global_entry *tt_global;
2118 	struct hlist_head *head;
2119 	u32 i, crc_tmp, crc = 0;
2120 	u8 flags;
2121 	__be16 tmp_vid;
2122 
2123 	for (i = 0; i < hash->size; i++) {
2124 		head = &hash->table[i];
2125 
2126 		rcu_read_lock();
2127 		hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2128 			tt_global = container_of(tt_common,
2129 						 struct batadv_tt_global_entry,
2130 						 common);
2131 			/* compute the CRC only for entries belonging to the
2132 			 * VLAN identified by the vid passed as parameter
2133 			 */
2134 			if (tt_common->vid != vid)
2135 				continue;
2136 
2137 			/* Roaming clients are in the global table for
2138 			 * consistency only. They don't have to be
2139 			 * taken into account while computing the
2140 			 * global crc
2141 			 */
2142 			if (tt_common->flags & BATADV_TT_CLIENT_ROAM)
2143 				continue;
2144 			/* Temporary clients have not been announced yet, so
2145 			 * they have to be skipped while computing the global
2146 			 * crc
2147 			 */
2148 			if (tt_common->flags & BATADV_TT_CLIENT_TEMP)
2149 				continue;
2150 
2151 			/* find out if this global entry is announced by this
2152 			 * originator
2153 			 */
2154 			if (!batadv_tt_global_entry_has_orig(tt_global,
2155 							     orig_node))
2156 				continue;
2157 
2158 			/* use network order to read the VID: this ensures that
2159 			 * every node reads the bytes in the same order.
2160 			 */
2161 			tmp_vid = htons(tt_common->vid);
2162 			crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2163 
2164 			/* compute the CRC on flags that have to be kept in sync
2165 			 * among nodes
2166 			 */
2167 			flags = tt_common->flags & BATADV_TT_SYNC_MASK;
2168 			crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
2169 
2170 			crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2171 		}
2172 		rcu_read_unlock();
2173 	}
2174 
2175 	return crc;
2176 }
2177 
2178 /**
2179  * batadv_tt_local_crc - calculates the checksum of the local table
2180  * @bat_priv: the bat priv with all the soft interface information
2181  * @vid: VLAN identifier for which the CRC32 has to be computed
2182  *
2183  * For details about the computation, please refer to the documentation for
2184  * batadv_tt_global_crc().
2185  *
2186  * Returns the checksum of the local table
2187  */
2188 static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv,
2189 			       unsigned short vid)
2190 {
2191 	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
2192 	struct batadv_tt_common_entry *tt_common;
2193 	struct hlist_head *head;
2194 	u32 i, crc_tmp, crc = 0;
2195 	u8 flags;
2196 	__be16 tmp_vid;
2197 
2198 	for (i = 0; i < hash->size; i++) {
2199 		head = &hash->table[i];
2200 
2201 		rcu_read_lock();
2202 		hlist_for_each_entry_rcu(tt_common, head, hash_entry) {
2203 			/* compute the CRC only for entries belonging to the
2204 			 * VLAN identified by vid
2205 			 */
2206 			if (tt_common->vid != vid)
2207 				continue;
2208 
2209 			/* not yet committed clients have not to be taken into
2210 			 * account while computing the CRC
2211 			 */
2212 			if (tt_common->flags & BATADV_TT_CLIENT_NEW)
2213 				continue;
2214 
2215 			/* use network order to read the VID: this ensures that
2216 			 * every node reads the bytes in the same order.
2217 			 */
2218 			tmp_vid = htons(tt_common->vid);
2219 			crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid));
2220 
2221 			/* compute the CRC on flags that have to be kept in sync
2222 			 * among nodes
2223 			 */
2224 			flags = tt_common->flags & BATADV_TT_SYNC_MASK;
2225 			crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags));
2226 
2227 			crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN);
2228 		}
2229 		rcu_read_unlock();
2230 	}
2231 
2232 	return crc;
2233 }
2234 
2235 static void batadv_tt_req_list_free(struct batadv_priv *bat_priv)
2236 {
2237 	struct batadv_tt_req_node *node;
2238 	struct hlist_node *safe;
2239 
2240 	spin_lock_bh(&bat_priv->tt.req_list_lock);
2241 
2242 	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2243 		hlist_del_init(&node->list);
2244 		kfree(node);
2245 	}
2246 
2247 	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2248 }
2249 
2250 static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv,
2251 				       struct batadv_orig_node *orig_node,
2252 				       const void *tt_buff,
2253 				       u16 tt_buff_len)
2254 {
2255 	/* Replace the old buffer only if I received something in the
2256 	 * last OGM (the OGM could carry no changes)
2257 	 */
2258 	spin_lock_bh(&orig_node->tt_buff_lock);
2259 	if (tt_buff_len > 0) {
2260 		kfree(orig_node->tt_buff);
2261 		orig_node->tt_buff_len = 0;
2262 		orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC);
2263 		if (orig_node->tt_buff) {
2264 			memcpy(orig_node->tt_buff, tt_buff, tt_buff_len);
2265 			orig_node->tt_buff_len = tt_buff_len;
2266 		}
2267 	}
2268 	spin_unlock_bh(&orig_node->tt_buff_lock);
2269 }
2270 
2271 static void batadv_tt_req_purge(struct batadv_priv *bat_priv)
2272 {
2273 	struct batadv_tt_req_node *node;
2274 	struct hlist_node *safe;
2275 
2276 	spin_lock_bh(&bat_priv->tt.req_list_lock);
2277 	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
2278 		if (batadv_has_timed_out(node->issued_at,
2279 					 BATADV_TT_REQUEST_TIMEOUT)) {
2280 			hlist_del_init(&node->list);
2281 			kfree(node);
2282 		}
2283 	}
2284 	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2285 }
2286 
2287 /**
2288  * batadv_tt_req_node_new - search and possibly create a tt_req_node object
2289  * @bat_priv: the bat priv with all the soft interface information
2290  * @orig_node: orig node this request is being issued for
2291  *
2292  * Returns the pointer to the new tt_req_node struct if no request
2293  * has already been issued for this orig_node, NULL otherwise.
2294  */
2295 static struct batadv_tt_req_node *
2296 batadv_tt_req_node_new(struct batadv_priv *bat_priv,
2297 		       struct batadv_orig_node *orig_node)
2298 {
2299 	struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL;
2300 
2301 	spin_lock_bh(&bat_priv->tt.req_list_lock);
2302 	hlist_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) {
2303 		if (batadv_compare_eth(tt_req_node_tmp, orig_node) &&
2304 		    !batadv_has_timed_out(tt_req_node_tmp->issued_at,
2305 					  BATADV_TT_REQUEST_TIMEOUT))
2306 			goto unlock;
2307 	}
2308 
2309 	tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC);
2310 	if (!tt_req_node)
2311 		goto unlock;
2312 
2313 	ether_addr_copy(tt_req_node->addr, orig_node->orig);
2314 	tt_req_node->issued_at = jiffies;
2315 
2316 	hlist_add_head(&tt_req_node->list, &bat_priv->tt.req_list);
2317 unlock:
2318 	spin_unlock_bh(&bat_priv->tt.req_list_lock);
2319 	return tt_req_node;
2320 }
2321 
2322 /**
2323  * batadv_tt_local_valid - verify that given tt entry is a valid one
2324  * @entry_ptr: to be checked local tt entry
2325  * @data_ptr: not used but definition required to satisfy the callback prototype
2326  *
2327  * Returns 1 if the entry is a valid, 0 otherwise.
2328  */
2329 static int batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr)
2330 {
2331 	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2332 
2333 	if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW)
2334 		return 0;
2335 	return 1;
2336 }
2337 
2338 static int batadv_tt_global_valid(const void *entry_ptr,
2339 				  const void *data_ptr)
2340 {
2341 	const struct batadv_tt_common_entry *tt_common_entry = entry_ptr;
2342 	const struct batadv_tt_global_entry *tt_global_entry;
2343 	const struct batadv_orig_node *orig_node = data_ptr;
2344 
2345 	if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM ||
2346 	    tt_common_entry->flags & BATADV_TT_CLIENT_TEMP)
2347 		return 0;
2348 
2349 	tt_global_entry = container_of(tt_common_entry,
2350 				       struct batadv_tt_global_entry,
2351 				       common);
2352 
2353 	return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node);
2354 }
2355 
2356 /**
2357  * batadv_tt_tvlv_generate - fill the tvlv buff with the tt entries from the
2358  *  specified tt hash
2359  * @bat_priv: the bat priv with all the soft interface information
2360  * @hash: hash table containing the tt entries
2361  * @tt_len: expected tvlv tt data buffer length in number of bytes
2362  * @tvlv_buff: pointer to the buffer to fill with the TT data
2363  * @valid_cb: function to filter tt change entries
2364  * @cb_data: data passed to the filter function as argument
2365  */
2366 static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv,
2367 				    struct batadv_hashtable *hash,
2368 				    void *tvlv_buff, u16 tt_len,
2369 				    int (*valid_cb)(const void *, const void *),
2370 				    void *cb_data)
2371 {
2372 	struct batadv_tt_common_entry *tt_common_entry;
2373 	struct batadv_tvlv_tt_change *tt_change;
2374 	struct hlist_head *head;
2375 	u16 tt_tot, tt_num_entries = 0;
2376 	u32 i;
2377 
2378 	tt_tot = batadv_tt_entries(tt_len);
2379 	tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff;
2380 
2381 	rcu_read_lock();
2382 	for (i = 0; i < hash->size; i++) {
2383 		head = &hash->table[i];
2384 
2385 		hlist_for_each_entry_rcu(tt_common_entry,
2386 					 head, hash_entry) {
2387 			if (tt_tot == tt_num_entries)
2388 				break;
2389 
2390 			if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data)))
2391 				continue;
2392 
2393 			ether_addr_copy(tt_change->addr, tt_common_entry->addr);
2394 			tt_change->flags = tt_common_entry->flags;
2395 			tt_change->vid = htons(tt_common_entry->vid);
2396 			memset(tt_change->reserved, 0,
2397 			       sizeof(tt_change->reserved));
2398 
2399 			tt_num_entries++;
2400 			tt_change++;
2401 		}
2402 	}
2403 	rcu_read_unlock();
2404 }
2405 
2406 /**
2407  * batadv_tt_global_check_crc - check if all the CRCs are correct
2408  * @orig_node: originator for which the CRCs have to be checked
2409  * @tt_vlan: pointer to the first tvlv VLAN entry
2410  * @num_vlan: number of tvlv VLAN entries
2411  * @create: if true, create VLAN objects if not found
2412  *
2413  * Return true if all the received CRCs match the locally stored ones, false
2414  * otherwise
2415  */
2416 static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node,
2417 				       struct batadv_tvlv_tt_vlan_data *tt_vlan,
2418 				       u16 num_vlan)
2419 {
2420 	struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp;
2421 	struct batadv_orig_node_vlan *vlan;
2422 	u32 crc;
2423 	int i;
2424 
2425 	/* check if each received CRC matches the locally stored one */
2426 	for (i = 0; i < num_vlan; i++) {
2427 		tt_vlan_tmp = tt_vlan + i;
2428 
2429 		/* if orig_node is a backbone node for this VLAN, don't check
2430 		 * the CRC as we ignore all the global entries over it
2431 		 */
2432 		if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv,
2433 						   orig_node->orig,
2434 						   ntohs(tt_vlan_tmp->vid)))
2435 			continue;
2436 
2437 		vlan = batadv_orig_node_vlan_get(orig_node,
2438 						 ntohs(tt_vlan_tmp->vid));
2439 		if (!vlan)
2440 			return false;
2441 
2442 		crc = vlan->tt.crc;
2443 		batadv_orig_node_vlan_free_ref(vlan);
2444 
2445 		if (crc != ntohl(tt_vlan_tmp->crc))
2446 			return false;
2447 	}
2448 
2449 	return true;
2450 }
2451 
2452 /**
2453  * batadv_tt_local_update_crc - update all the local CRCs
2454  * @bat_priv: the bat priv with all the soft interface information
2455  */
2456 static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv)
2457 {
2458 	struct batadv_softif_vlan *vlan;
2459 
2460 	/* recompute the global CRC for each VLAN */
2461 	rcu_read_lock();
2462 	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
2463 		vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid);
2464 	}
2465 	rcu_read_unlock();
2466 }
2467 
2468 /**
2469  * batadv_tt_global_update_crc - update all the global CRCs for this orig_node
2470  * @bat_priv: the bat priv with all the soft interface information
2471  * @orig_node: the orig_node for which the CRCs have to be updated
2472  */
2473 static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv,
2474 					struct batadv_orig_node *orig_node)
2475 {
2476 	struct batadv_orig_node_vlan *vlan;
2477 	u32 crc;
2478 
2479 	/* recompute the global CRC for each VLAN */
2480 	rcu_read_lock();
2481 	hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) {
2482 		/* if orig_node is a backbone node for this VLAN, don't compute
2483 		 * the CRC as we ignore all the global entries over it
2484 		 */
2485 		if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig,
2486 						   vlan->vid))
2487 			continue;
2488 
2489 		crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid);
2490 		vlan->tt.crc = crc;
2491 	}
2492 	rcu_read_unlock();
2493 }
2494 
2495 /**
2496  * batadv_send_tt_request - send a TT Request message to a given node
2497  * @bat_priv: the bat priv with all the soft interface information
2498  * @dst_orig_node: the destination of the message
2499  * @ttvn: the version number that the source of the message is looking for
2500  * @tt_vlan: pointer to the first tvlv VLAN object to request
2501  * @num_vlan: number of tvlv VLAN entries
2502  * @full_table: ask for the entire translation table if true, while only for the
2503  *  last TT diff otherwise
2504  */
2505 static int batadv_send_tt_request(struct batadv_priv *bat_priv,
2506 				  struct batadv_orig_node *dst_orig_node,
2507 				  u8 ttvn,
2508 				  struct batadv_tvlv_tt_vlan_data *tt_vlan,
2509 				  u16 num_vlan, bool full_table)
2510 {
2511 	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2512 	struct batadv_tt_req_node *tt_req_node = NULL;
2513 	struct batadv_tvlv_tt_vlan_data *tt_vlan_req;
2514 	struct batadv_hard_iface *primary_if;
2515 	bool ret = false;
2516 	int i, size;
2517 
2518 	primary_if = batadv_primary_if_get_selected(bat_priv);
2519 	if (!primary_if)
2520 		goto out;
2521 
2522 	/* The new tt_req will be issued only if I'm not waiting for a
2523 	 * reply from the same orig_node yet
2524 	 */
2525 	tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node);
2526 	if (!tt_req_node)
2527 		goto out;
2528 
2529 	size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan;
2530 	tvlv_tt_data = kzalloc(size, GFP_ATOMIC);
2531 	if (!tvlv_tt_data)
2532 		goto out;
2533 
2534 	tvlv_tt_data->flags = BATADV_TT_REQUEST;
2535 	tvlv_tt_data->ttvn = ttvn;
2536 	tvlv_tt_data->num_vlan = htons(num_vlan);
2537 
2538 	/* send all the CRCs within the request. This is needed by intermediate
2539 	 * nodes to ensure they have the correct table before replying
2540 	 */
2541 	tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1);
2542 	for (i = 0; i < num_vlan; i++) {
2543 		tt_vlan_req->vid = tt_vlan->vid;
2544 		tt_vlan_req->crc = tt_vlan->crc;
2545 
2546 		tt_vlan_req++;
2547 		tt_vlan++;
2548 	}
2549 
2550 	if (full_table)
2551 		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2552 
2553 	batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n",
2554 		   dst_orig_node->orig, full_table ? 'F' : '.');
2555 
2556 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX);
2557 	batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2558 				 dst_orig_node->orig, BATADV_TVLV_TT, 1,
2559 				 tvlv_tt_data, size);
2560 	ret = true;
2561 
2562 out:
2563 	if (primary_if)
2564 		batadv_hardif_free_ref(primary_if);
2565 	if (ret && tt_req_node) {
2566 		spin_lock_bh(&bat_priv->tt.req_list_lock);
2567 		/* hlist_del_init() verifies tt_req_node still is in the list */
2568 		hlist_del_init(&tt_req_node->list);
2569 		spin_unlock_bh(&bat_priv->tt.req_list_lock);
2570 		kfree(tt_req_node);
2571 	}
2572 	kfree(tvlv_tt_data);
2573 	return ret;
2574 }
2575 
2576 /**
2577  * batadv_send_other_tt_response - send reply to tt request concerning another
2578  *  node's translation table
2579  * @bat_priv: the bat priv with all the soft interface information
2580  * @tt_data: tt data containing the tt request information
2581  * @req_src: mac address of tt request sender
2582  * @req_dst: mac address of tt request recipient
2583  *
2584  * Returns true if tt request reply was sent, false otherwise.
2585  */
2586 static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv,
2587 					  struct batadv_tvlv_tt_data *tt_data,
2588 					  u8 *req_src, u8 *req_dst)
2589 {
2590 	struct batadv_orig_node *req_dst_orig_node;
2591 	struct batadv_orig_node *res_dst_orig_node = NULL;
2592 	struct batadv_tvlv_tt_change *tt_change;
2593 	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2594 	struct batadv_tvlv_tt_vlan_data *tt_vlan;
2595 	bool ret = false, full_table;
2596 	u8 orig_ttvn, req_ttvn;
2597 	u16 tvlv_len;
2598 	s32 tt_len;
2599 
2600 	batadv_dbg(BATADV_DBG_TT, bat_priv,
2601 		   "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n",
2602 		   req_src, tt_data->ttvn, req_dst,
2603 		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2604 
2605 	/* Let's get the orig node of the REAL destination */
2606 	req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst);
2607 	if (!req_dst_orig_node)
2608 		goto out;
2609 
2610 	res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src);
2611 	if (!res_dst_orig_node)
2612 		goto out;
2613 
2614 	orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn);
2615 	req_ttvn = tt_data->ttvn;
2616 
2617 	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
2618 	/* this node doesn't have the requested data */
2619 	if (orig_ttvn != req_ttvn ||
2620 	    !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan,
2621 					ntohs(tt_data->num_vlan)))
2622 		goto out;
2623 
2624 	/* If the full table has been explicitly requested */
2625 	if (tt_data->flags & BATADV_TT_FULL_TABLE ||
2626 	    !req_dst_orig_node->tt_buff)
2627 		full_table = true;
2628 	else
2629 		full_table = false;
2630 
2631 	/* TT fragmentation hasn't been implemented yet, so send as many
2632 	 * TT entries fit a single packet as possible only
2633 	 */
2634 	if (!full_table) {
2635 		spin_lock_bh(&req_dst_orig_node->tt_buff_lock);
2636 		tt_len = req_dst_orig_node->tt_buff_len;
2637 
2638 		tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
2639 							      &tvlv_tt_data,
2640 							      &tt_change,
2641 							      &tt_len);
2642 		if (!tt_len)
2643 			goto unlock;
2644 
2645 		/* Copy the last orig_node's OGM buffer */
2646 		memcpy(tt_change, req_dst_orig_node->tt_buff,
2647 		       req_dst_orig_node->tt_buff_len);
2648 		spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
2649 	} else {
2650 		/* allocate the tvlv, put the tt_data and all the tt_vlan_data
2651 		 * in the initial part
2652 		 */
2653 		tt_len = -1;
2654 		tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node,
2655 							      &tvlv_tt_data,
2656 							      &tt_change,
2657 							      &tt_len);
2658 		if (!tt_len)
2659 			goto out;
2660 
2661 		/* fill the rest of the tvlv with the real TT entries */
2662 		batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash,
2663 					tt_change, tt_len,
2664 					batadv_tt_global_valid,
2665 					req_dst_orig_node);
2666 	}
2667 
2668 	/* Don't send the response, if larger than fragmented packet. */
2669 	tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len;
2670 	if (tt_len > atomic_read(&bat_priv->packet_size_max)) {
2671 		net_ratelimited_function(batadv_info, bat_priv->soft_iface,
2672 					 "Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n",
2673 					 res_dst_orig_node->orig);
2674 		goto out;
2675 	}
2676 
2677 	tvlv_tt_data->flags = BATADV_TT_RESPONSE;
2678 	tvlv_tt_data->ttvn = req_ttvn;
2679 
2680 	if (full_table)
2681 		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2682 
2683 	batadv_dbg(BATADV_DBG_TT, bat_priv,
2684 		   "Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n",
2685 		   res_dst_orig_node->orig, req_dst_orig_node->orig,
2686 		   full_table ? 'F' : '.', req_ttvn);
2687 
2688 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2689 
2690 	batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig,
2691 				 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
2692 				 tvlv_len);
2693 
2694 	ret = true;
2695 	goto out;
2696 
2697 unlock:
2698 	spin_unlock_bh(&req_dst_orig_node->tt_buff_lock);
2699 
2700 out:
2701 	if (res_dst_orig_node)
2702 		batadv_orig_node_free_ref(res_dst_orig_node);
2703 	if (req_dst_orig_node)
2704 		batadv_orig_node_free_ref(req_dst_orig_node);
2705 	kfree(tvlv_tt_data);
2706 	return ret;
2707 }
2708 
2709 /**
2710  * batadv_send_my_tt_response - send reply to tt request concerning this node's
2711  *  translation table
2712  * @bat_priv: the bat priv with all the soft interface information
2713  * @tt_data: tt data containing the tt request information
2714  * @req_src: mac address of tt request sender
2715  *
2716  * Returns true if tt request reply was sent, false otherwise.
2717  */
2718 static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv,
2719 				       struct batadv_tvlv_tt_data *tt_data,
2720 				       u8 *req_src)
2721 {
2722 	struct batadv_tvlv_tt_data *tvlv_tt_data = NULL;
2723 	struct batadv_hard_iface *primary_if = NULL;
2724 	struct batadv_tvlv_tt_change *tt_change;
2725 	struct batadv_orig_node *orig_node;
2726 	u8 my_ttvn, req_ttvn;
2727 	u16 tvlv_len;
2728 	bool full_table;
2729 	s32 tt_len;
2730 
2731 	batadv_dbg(BATADV_DBG_TT, bat_priv,
2732 		   "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n",
2733 		   req_src, tt_data->ttvn,
2734 		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2735 
2736 	spin_lock_bh(&bat_priv->tt.commit_lock);
2737 
2738 	my_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
2739 	req_ttvn = tt_data->ttvn;
2740 
2741 	orig_node = batadv_orig_hash_find(bat_priv, req_src);
2742 	if (!orig_node)
2743 		goto out;
2744 
2745 	primary_if = batadv_primary_if_get_selected(bat_priv);
2746 	if (!primary_if)
2747 		goto out;
2748 
2749 	/* If the full table has been explicitly requested or the gap
2750 	 * is too big send the whole local translation table
2751 	 */
2752 	if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn ||
2753 	    !bat_priv->tt.last_changeset)
2754 		full_table = true;
2755 	else
2756 		full_table = false;
2757 
2758 	/* TT fragmentation hasn't been implemented yet, so send as many
2759 	 * TT entries fit a single packet as possible only
2760 	 */
2761 	if (!full_table) {
2762 		spin_lock_bh(&bat_priv->tt.last_changeset_lock);
2763 
2764 		tt_len = bat_priv->tt.last_changeset_len;
2765 		tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
2766 							     &tvlv_tt_data,
2767 							     &tt_change,
2768 							     &tt_len);
2769 		if (!tt_len)
2770 			goto unlock;
2771 
2772 		/* Copy the last orig_node's OGM buffer */
2773 		memcpy(tt_change, bat_priv->tt.last_changeset,
2774 		       bat_priv->tt.last_changeset_len);
2775 		spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2776 	} else {
2777 		req_ttvn = (u8)atomic_read(&bat_priv->tt.vn);
2778 
2779 		/* allocate the tvlv, put the tt_data and all the tt_vlan_data
2780 		 * in the initial part
2781 		 */
2782 		tt_len = -1;
2783 		tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv,
2784 							     &tvlv_tt_data,
2785 							     &tt_change,
2786 							     &tt_len);
2787 		if (!tt_len)
2788 			goto out;
2789 
2790 		/* fill the rest of the tvlv with the real TT entries */
2791 		batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash,
2792 					tt_change, tt_len,
2793 					batadv_tt_local_valid, NULL);
2794 	}
2795 
2796 	tvlv_tt_data->flags = BATADV_TT_RESPONSE;
2797 	tvlv_tt_data->ttvn = req_ttvn;
2798 
2799 	if (full_table)
2800 		tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE;
2801 
2802 	batadv_dbg(BATADV_DBG_TT, bat_priv,
2803 		   "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n",
2804 		   orig_node->orig, full_table ? 'F' : '.', req_ttvn);
2805 
2806 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX);
2807 
2808 	batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
2809 				 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data,
2810 				 tvlv_len);
2811 
2812 	goto out;
2813 
2814 unlock:
2815 	spin_unlock_bh(&bat_priv->tt.last_changeset_lock);
2816 out:
2817 	spin_unlock_bh(&bat_priv->tt.commit_lock);
2818 	if (orig_node)
2819 		batadv_orig_node_free_ref(orig_node);
2820 	if (primary_if)
2821 		batadv_hardif_free_ref(primary_if);
2822 	kfree(tvlv_tt_data);
2823 	/* The packet was for this host, so it doesn't need to be re-routed */
2824 	return true;
2825 }
2826 
2827 /**
2828  * batadv_send_tt_response - send reply to tt request
2829  * @bat_priv: the bat priv with all the soft interface information
2830  * @tt_data: tt data containing the tt request information
2831  * @req_src: mac address of tt request sender
2832  * @req_dst: mac address of tt request recipient
2833  *
2834  * Returns true if tt request reply was sent, false otherwise.
2835  */
2836 static bool batadv_send_tt_response(struct batadv_priv *bat_priv,
2837 				    struct batadv_tvlv_tt_data *tt_data,
2838 				    u8 *req_src, u8 *req_dst)
2839 {
2840 	if (batadv_is_my_mac(bat_priv, req_dst))
2841 		return batadv_send_my_tt_response(bat_priv, tt_data, req_src);
2842 	return batadv_send_other_tt_response(bat_priv, tt_data, req_src,
2843 					     req_dst);
2844 }
2845 
2846 static void _batadv_tt_update_changes(struct batadv_priv *bat_priv,
2847 				      struct batadv_orig_node *orig_node,
2848 				      struct batadv_tvlv_tt_change *tt_change,
2849 				      u16 tt_num_changes, u8 ttvn)
2850 {
2851 	int i;
2852 	int roams;
2853 
2854 	for (i = 0; i < tt_num_changes; i++) {
2855 		if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) {
2856 			roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM;
2857 			batadv_tt_global_del(bat_priv, orig_node,
2858 					     (tt_change + i)->addr,
2859 					     ntohs((tt_change + i)->vid),
2860 					     "tt removed by changes",
2861 					     roams);
2862 		} else {
2863 			if (!batadv_tt_global_add(bat_priv, orig_node,
2864 						  (tt_change + i)->addr,
2865 						  ntohs((tt_change + i)->vid),
2866 						  (tt_change + i)->flags, ttvn))
2867 				/* In case of problem while storing a
2868 				 * global_entry, we stop the updating
2869 				 * procedure without committing the
2870 				 * ttvn change. This will avoid to send
2871 				 * corrupted data on tt_request
2872 				 */
2873 				return;
2874 		}
2875 	}
2876 	set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized);
2877 }
2878 
2879 static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv,
2880 				  struct batadv_tvlv_tt_change *tt_change,
2881 				  u8 ttvn, u8 *resp_src,
2882 				  u16 num_entries)
2883 {
2884 	struct batadv_orig_node *orig_node;
2885 
2886 	orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2887 	if (!orig_node)
2888 		goto out;
2889 
2890 	/* Purge the old table first.. */
2891 	batadv_tt_global_del_orig(bat_priv, orig_node, -1,
2892 				  "Received full table");
2893 
2894 	_batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries,
2895 				  ttvn);
2896 
2897 	spin_lock_bh(&orig_node->tt_buff_lock);
2898 	kfree(orig_node->tt_buff);
2899 	orig_node->tt_buff_len = 0;
2900 	orig_node->tt_buff = NULL;
2901 	spin_unlock_bh(&orig_node->tt_buff_lock);
2902 
2903 	atomic_set(&orig_node->last_ttvn, ttvn);
2904 
2905 out:
2906 	if (orig_node)
2907 		batadv_orig_node_free_ref(orig_node);
2908 }
2909 
2910 static void batadv_tt_update_changes(struct batadv_priv *bat_priv,
2911 				     struct batadv_orig_node *orig_node,
2912 				     u16 tt_num_changes, u8 ttvn,
2913 				     struct batadv_tvlv_tt_change *tt_change)
2914 {
2915 	_batadv_tt_update_changes(bat_priv, orig_node, tt_change,
2916 				  tt_num_changes, ttvn);
2917 
2918 	batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change,
2919 				   batadv_tt_len(tt_num_changes));
2920 	atomic_set(&orig_node->last_ttvn, ttvn);
2921 }
2922 
2923 /**
2924  * batadv_is_my_client - check if a client is served by the local node
2925  * @bat_priv: the bat priv with all the soft interface information
2926  * @addr: the mac address of the client to check
2927  * @vid: VLAN identifier
2928  *
2929  * Returns true if the client is served by this node, false otherwise.
2930  */
2931 bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr,
2932 			 unsigned short vid)
2933 {
2934 	struct batadv_tt_local_entry *tt_local_entry;
2935 	bool ret = false;
2936 
2937 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
2938 	if (!tt_local_entry)
2939 		goto out;
2940 	/* Check if the client has been logically deleted (but is kept for
2941 	 * consistency purpose)
2942 	 */
2943 	if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) ||
2944 	    (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM))
2945 		goto out;
2946 	ret = true;
2947 out:
2948 	if (tt_local_entry)
2949 		batadv_tt_local_entry_free_ref(tt_local_entry);
2950 	return ret;
2951 }
2952 
2953 /**
2954  * batadv_handle_tt_response - process incoming tt reply
2955  * @bat_priv: the bat priv with all the soft interface information
2956  * @tt_data: tt data containing the tt request information
2957  * @resp_src: mac address of tt reply sender
2958  * @num_entries: number of tt change entries appended to the tt data
2959  */
2960 static void batadv_handle_tt_response(struct batadv_priv *bat_priv,
2961 				      struct batadv_tvlv_tt_data *tt_data,
2962 				      u8 *resp_src, u16 num_entries)
2963 {
2964 	struct batadv_tt_req_node *node;
2965 	struct hlist_node *safe;
2966 	struct batadv_orig_node *orig_node = NULL;
2967 	struct batadv_tvlv_tt_change *tt_change;
2968 	u8 *tvlv_ptr = (u8 *)tt_data;
2969 	u16 change_offset;
2970 
2971 	batadv_dbg(BATADV_DBG_TT, bat_priv,
2972 		   "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n",
2973 		   resp_src, tt_data->ttvn, num_entries,
2974 		   ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.'));
2975 
2976 	orig_node = batadv_orig_hash_find(bat_priv, resp_src);
2977 	if (!orig_node)
2978 		goto out;
2979 
2980 	spin_lock_bh(&orig_node->tt_lock);
2981 
2982 	change_offset = sizeof(struct batadv_tvlv_tt_vlan_data);
2983 	change_offset *= ntohs(tt_data->num_vlan);
2984 	change_offset += sizeof(*tt_data);
2985 	tvlv_ptr += change_offset;
2986 
2987 	tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr;
2988 	if (tt_data->flags & BATADV_TT_FULL_TABLE) {
2989 		batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn,
2990 				      resp_src, num_entries);
2991 	} else {
2992 		batadv_tt_update_changes(bat_priv, orig_node, num_entries,
2993 					 tt_data->ttvn, tt_change);
2994 	}
2995 
2996 	/* Recalculate the CRC for this orig_node and store it */
2997 	batadv_tt_global_update_crc(bat_priv, orig_node);
2998 
2999 	spin_unlock_bh(&orig_node->tt_lock);
3000 
3001 	/* Delete the tt_req_node from pending tt_requests list */
3002 	spin_lock_bh(&bat_priv->tt.req_list_lock);
3003 	hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) {
3004 		if (!batadv_compare_eth(node->addr, resp_src))
3005 			continue;
3006 		hlist_del_init(&node->list);
3007 		kfree(node);
3008 	}
3009 
3010 	spin_unlock_bh(&bat_priv->tt.req_list_lock);
3011 out:
3012 	if (orig_node)
3013 		batadv_orig_node_free_ref(orig_node);
3014 }
3015 
3016 static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv)
3017 {
3018 	struct batadv_tt_roam_node *node, *safe;
3019 
3020 	spin_lock_bh(&bat_priv->tt.roam_list_lock);
3021 
3022 	list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3023 		list_del(&node->list);
3024 		kfree(node);
3025 	}
3026 
3027 	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3028 }
3029 
3030 static void batadv_tt_roam_purge(struct batadv_priv *bat_priv)
3031 {
3032 	struct batadv_tt_roam_node *node, *safe;
3033 
3034 	spin_lock_bh(&bat_priv->tt.roam_list_lock);
3035 	list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) {
3036 		if (!batadv_has_timed_out(node->first_time,
3037 					  BATADV_ROAMING_MAX_TIME))
3038 			continue;
3039 
3040 		list_del(&node->list);
3041 		kfree(node);
3042 	}
3043 	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3044 }
3045 
3046 /* This function checks whether the client already reached the
3047  * maximum number of possible roaming phases. In this case the ROAMING_ADV
3048  * will not be sent.
3049  *
3050  * returns true if the ROAMING_ADV can be sent, false otherwise
3051  */
3052 static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client)
3053 {
3054 	struct batadv_tt_roam_node *tt_roam_node;
3055 	bool ret = false;
3056 
3057 	spin_lock_bh(&bat_priv->tt.roam_list_lock);
3058 	/* The new tt_req will be issued only if I'm not waiting for a
3059 	 * reply from the same orig_node yet
3060 	 */
3061 	list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) {
3062 		if (!batadv_compare_eth(tt_roam_node->addr, client))
3063 			continue;
3064 
3065 		if (batadv_has_timed_out(tt_roam_node->first_time,
3066 					 BATADV_ROAMING_MAX_TIME))
3067 			continue;
3068 
3069 		if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter))
3070 			/* Sorry, you roamed too many times! */
3071 			goto unlock;
3072 		ret = true;
3073 		break;
3074 	}
3075 
3076 	if (!ret) {
3077 		tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC);
3078 		if (!tt_roam_node)
3079 			goto unlock;
3080 
3081 		tt_roam_node->first_time = jiffies;
3082 		atomic_set(&tt_roam_node->counter,
3083 			   BATADV_ROAMING_MAX_COUNT - 1);
3084 		ether_addr_copy(tt_roam_node->addr, client);
3085 
3086 		list_add(&tt_roam_node->list, &bat_priv->tt.roam_list);
3087 		ret = true;
3088 	}
3089 
3090 unlock:
3091 	spin_unlock_bh(&bat_priv->tt.roam_list_lock);
3092 	return ret;
3093 }
3094 
3095 /**
3096  * batadv_send_roam_adv - send a roaming advertisement message
3097  * @bat_priv: the bat priv with all the soft interface information
3098  * @client: mac address of the roaming client
3099  * @vid: VLAN identifier
3100  * @orig_node: message destination
3101  *
3102  * Send a ROAMING_ADV message to the node which was previously serving this
3103  * client. This is done to inform the node that from now on all traffic destined
3104  * for this particular roamed client has to be forwarded to the sender of the
3105  * roaming message.
3106  */
3107 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client,
3108 				 unsigned short vid,
3109 				 struct batadv_orig_node *orig_node)
3110 {
3111 	struct batadv_hard_iface *primary_if;
3112 	struct batadv_tvlv_roam_adv tvlv_roam;
3113 
3114 	primary_if = batadv_primary_if_get_selected(bat_priv);
3115 	if (!primary_if)
3116 		goto out;
3117 
3118 	/* before going on we have to check whether the client has
3119 	 * already roamed to us too many times
3120 	 */
3121 	if (!batadv_tt_check_roam_count(bat_priv, client))
3122 		goto out;
3123 
3124 	batadv_dbg(BATADV_DBG_TT, bat_priv,
3125 		   "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n",
3126 		   orig_node->orig, client, BATADV_PRINT_VID(vid));
3127 
3128 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX);
3129 
3130 	memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client));
3131 	tvlv_roam.vid = htons(vid);
3132 
3133 	batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr,
3134 				 orig_node->orig, BATADV_TVLV_ROAM, 1,
3135 				 &tvlv_roam, sizeof(tvlv_roam));
3136 
3137 out:
3138 	if (primary_if)
3139 		batadv_hardif_free_ref(primary_if);
3140 }
3141 
3142 static void batadv_tt_purge(struct work_struct *work)
3143 {
3144 	struct delayed_work *delayed_work;
3145 	struct batadv_priv_tt *priv_tt;
3146 	struct batadv_priv *bat_priv;
3147 
3148 	delayed_work = container_of(work, struct delayed_work, work);
3149 	priv_tt = container_of(delayed_work, struct batadv_priv_tt, work);
3150 	bat_priv = container_of(priv_tt, struct batadv_priv, tt);
3151 
3152 	batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT);
3153 	batadv_tt_global_purge(bat_priv);
3154 	batadv_tt_req_purge(bat_priv);
3155 	batadv_tt_roam_purge(bat_priv);
3156 
3157 	queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
3158 			   msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3159 }
3160 
3161 void batadv_tt_free(struct batadv_priv *bat_priv)
3162 {
3163 	batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1);
3164 	batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1);
3165 
3166 	cancel_delayed_work_sync(&bat_priv->tt.work);
3167 
3168 	batadv_tt_local_table_free(bat_priv);
3169 	batadv_tt_global_table_free(bat_priv);
3170 	batadv_tt_req_list_free(bat_priv);
3171 	batadv_tt_changes_list_free(bat_priv);
3172 	batadv_tt_roam_list_free(bat_priv);
3173 
3174 	kfree(bat_priv->tt.last_changeset);
3175 }
3176 
3177 /**
3178  * batadv_tt_local_set_flags - set or unset the specified flags on the local
3179  *  table and possibly count them in the TT size
3180  * @bat_priv: the bat priv with all the soft interface information
3181  * @flags: the flag to switch
3182  * @enable: whether to set or unset the flag
3183  * @count: whether to increase the TT size by the number of changed entries
3184  */
3185 static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags,
3186 				      bool enable, bool count)
3187 {
3188 	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3189 	struct batadv_tt_common_entry *tt_common_entry;
3190 	u16 changed_num = 0;
3191 	struct hlist_head *head;
3192 	u32 i;
3193 
3194 	if (!hash)
3195 		return;
3196 
3197 	for (i = 0; i < hash->size; i++) {
3198 		head = &hash->table[i];
3199 
3200 		rcu_read_lock();
3201 		hlist_for_each_entry_rcu(tt_common_entry,
3202 					 head, hash_entry) {
3203 			if (enable) {
3204 				if ((tt_common_entry->flags & flags) == flags)
3205 					continue;
3206 				tt_common_entry->flags |= flags;
3207 			} else {
3208 				if (!(tt_common_entry->flags & flags))
3209 					continue;
3210 				tt_common_entry->flags &= ~flags;
3211 			}
3212 			changed_num++;
3213 
3214 			if (!count)
3215 				continue;
3216 
3217 			batadv_tt_local_size_inc(bat_priv,
3218 						 tt_common_entry->vid);
3219 		}
3220 		rcu_read_unlock();
3221 	}
3222 }
3223 
3224 /* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */
3225 static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv)
3226 {
3227 	struct batadv_hashtable *hash = bat_priv->tt.local_hash;
3228 	struct batadv_tt_common_entry *tt_common;
3229 	struct batadv_tt_local_entry *tt_local;
3230 	struct batadv_softif_vlan *vlan;
3231 	struct hlist_node *node_tmp;
3232 	struct hlist_head *head;
3233 	spinlock_t *list_lock; /* protects write access to the hash lists */
3234 	u32 i;
3235 
3236 	if (!hash)
3237 		return;
3238 
3239 	for (i = 0; i < hash->size; i++) {
3240 		head = &hash->table[i];
3241 		list_lock = &hash->list_locks[i];
3242 
3243 		spin_lock_bh(list_lock);
3244 		hlist_for_each_entry_safe(tt_common, node_tmp, head,
3245 					  hash_entry) {
3246 			if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING))
3247 				continue;
3248 
3249 			batadv_dbg(BATADV_DBG_TT, bat_priv,
3250 				   "Deleting local tt entry (%pM, vid: %d): pending\n",
3251 				   tt_common->addr,
3252 				   BATADV_PRINT_VID(tt_common->vid));
3253 
3254 			batadv_tt_local_size_dec(bat_priv, tt_common->vid);
3255 			hlist_del_rcu(&tt_common->hash_entry);
3256 			tt_local = container_of(tt_common,
3257 						struct batadv_tt_local_entry,
3258 						common);
3259 
3260 			/* decrease the reference held for this vlan */
3261 			vlan = batadv_softif_vlan_get(bat_priv, tt_common->vid);
3262 			if (vlan) {
3263 				batadv_softif_vlan_free_ref(vlan);
3264 				batadv_softif_vlan_free_ref(vlan);
3265 			}
3266 
3267 			batadv_tt_local_entry_free_ref(tt_local);
3268 		}
3269 		spin_unlock_bh(list_lock);
3270 	}
3271 }
3272 
3273 /**
3274  * batadv_tt_local_commit_changes_nolock - commit all pending local tt changes
3275  *  which have been queued in the time since the last commit
3276  * @bat_priv: the bat priv with all the soft interface information
3277  *
3278  * Caller must hold tt->commit_lock.
3279  */
3280 static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv)
3281 {
3282 	lockdep_assert_held(&bat_priv->tt.commit_lock);
3283 
3284 	/* Update multicast addresses in local translation table */
3285 	batadv_mcast_mla_update(bat_priv);
3286 
3287 	if (atomic_read(&bat_priv->tt.local_changes) < 1) {
3288 		if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt))
3289 			batadv_tt_tvlv_container_update(bat_priv);
3290 		return;
3291 	}
3292 
3293 	batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true);
3294 
3295 	batadv_tt_local_purge_pending_clients(bat_priv);
3296 	batadv_tt_local_update_crc(bat_priv);
3297 
3298 	/* Increment the TTVN only once per OGM interval */
3299 	atomic_inc(&bat_priv->tt.vn);
3300 	batadv_dbg(BATADV_DBG_TT, bat_priv,
3301 		   "Local changes committed, updating to ttvn %u\n",
3302 		   (u8)atomic_read(&bat_priv->tt.vn));
3303 
3304 	/* reset the sending counter */
3305 	atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX);
3306 	batadv_tt_tvlv_container_update(bat_priv);
3307 }
3308 
3309 /**
3310  * batadv_tt_local_commit_changes - commit all pending local tt changes which
3311  *  have been queued in the time since the last commit
3312  * @bat_priv: the bat priv with all the soft interface information
3313  */
3314 void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv)
3315 {
3316 	spin_lock_bh(&bat_priv->tt.commit_lock);
3317 	batadv_tt_local_commit_changes_nolock(bat_priv);
3318 	spin_unlock_bh(&bat_priv->tt.commit_lock);
3319 }
3320 
3321 bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst,
3322 			   unsigned short vid)
3323 {
3324 	struct batadv_tt_local_entry *tt_local_entry = NULL;
3325 	struct batadv_tt_global_entry *tt_global_entry = NULL;
3326 	struct batadv_softif_vlan *vlan;
3327 	bool ret = false;
3328 
3329 	vlan = batadv_softif_vlan_get(bat_priv, vid);
3330 	if (!vlan || !atomic_read(&vlan->ap_isolation))
3331 		goto out;
3332 
3333 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid);
3334 	if (!tt_local_entry)
3335 		goto out;
3336 
3337 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid);
3338 	if (!tt_global_entry)
3339 		goto out;
3340 
3341 	if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry))
3342 		goto out;
3343 
3344 	ret = true;
3345 
3346 out:
3347 	if (vlan)
3348 		batadv_softif_vlan_free_ref(vlan);
3349 	if (tt_global_entry)
3350 		batadv_tt_global_entry_free_ref(tt_global_entry);
3351 	if (tt_local_entry)
3352 		batadv_tt_local_entry_free_ref(tt_local_entry);
3353 	return ret;
3354 }
3355 
3356 /**
3357  * batadv_tt_update_orig - update global translation table with new tt
3358  *  information received via ogms
3359  * @bat_priv: the bat priv with all the soft interface information
3360  * @orig: the orig_node of the ogm
3361  * @tt_vlan: pointer to the first tvlv VLAN entry
3362  * @tt_num_vlan: number of tvlv VLAN entries
3363  * @tt_change: pointer to the first entry in the TT buffer
3364  * @tt_num_changes: number of tt changes inside the tt buffer
3365  * @ttvn: translation table version number of this changeset
3366  * @tt_crc: crc32 checksum of orig node's translation table
3367  */
3368 static void batadv_tt_update_orig(struct batadv_priv *bat_priv,
3369 				  struct batadv_orig_node *orig_node,
3370 				  const void *tt_buff, u16 tt_num_vlan,
3371 				  struct batadv_tvlv_tt_change *tt_change,
3372 				  u16 tt_num_changes, u8 ttvn)
3373 {
3374 	u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn);
3375 	struct batadv_tvlv_tt_vlan_data *tt_vlan;
3376 	bool full_table = true;
3377 	bool has_tt_init;
3378 
3379 	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff;
3380 	has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT,
3381 			       &orig_node->capa_initialized);
3382 
3383 	/* orig table not initialised AND first diff is in the OGM OR the ttvn
3384 	 * increased by one -> we can apply the attached changes
3385 	 */
3386 	if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) {
3387 		/* the OGM could not contain the changes due to their size or
3388 		 * because they have already been sent BATADV_TT_OGM_APPEND_MAX
3389 		 * times.
3390 		 * In this case send a tt request
3391 		 */
3392 		if (!tt_num_changes) {
3393 			full_table = false;
3394 			goto request_table;
3395 		}
3396 
3397 		spin_lock_bh(&orig_node->tt_lock);
3398 
3399 		batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes,
3400 					 ttvn, tt_change);
3401 
3402 		/* Even if we received the precomputed crc with the OGM, we
3403 		 * prefer to recompute it to spot any possible inconsistency
3404 		 * in the global table
3405 		 */
3406 		batadv_tt_global_update_crc(bat_priv, orig_node);
3407 
3408 		spin_unlock_bh(&orig_node->tt_lock);
3409 
3410 		/* The ttvn alone is not enough to guarantee consistency
3411 		 * because a single value could represent different states
3412 		 * (due to the wrap around). Thus a node has to check whether
3413 		 * the resulting table (after applying the changes) is still
3414 		 * consistent or not. E.g. a node could disconnect while its
3415 		 * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case
3416 		 * checking the CRC value is mandatory to detect the
3417 		 * inconsistency
3418 		 */
3419 		if (!batadv_tt_global_check_crc(orig_node, tt_vlan,
3420 						tt_num_vlan))
3421 			goto request_table;
3422 	} else {
3423 		/* if we missed more than one change or our tables are not
3424 		 * in sync anymore -> request fresh tt data
3425 		 */
3426 		if (!has_tt_init || ttvn != orig_ttvn ||
3427 		    !batadv_tt_global_check_crc(orig_node, tt_vlan,
3428 						tt_num_vlan)) {
3429 request_table:
3430 			batadv_dbg(BATADV_DBG_TT, bat_priv,
3431 				   "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n",
3432 				   orig_node->orig, ttvn, orig_ttvn,
3433 				   tt_num_changes);
3434 			batadv_send_tt_request(bat_priv, orig_node, ttvn,
3435 					       tt_vlan, tt_num_vlan,
3436 					       full_table);
3437 			return;
3438 		}
3439 	}
3440 }
3441 
3442 /**
3443  * batadv_tt_global_client_is_roaming - check if a client is marked as roaming
3444  * @bat_priv: the bat priv with all the soft interface information
3445  * @addr: the mac address of the client to check
3446  * @vid: VLAN identifier
3447  *
3448  * Returns true if we know that the client has moved from its old originator
3449  * to another one. This entry is still kept for consistency purposes and will be
3450  * deleted later by a DEL or because of timeout
3451  */
3452 bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv,
3453 					u8 *addr, unsigned short vid)
3454 {
3455 	struct batadv_tt_global_entry *tt_global_entry;
3456 	bool ret = false;
3457 
3458 	tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid);
3459 	if (!tt_global_entry)
3460 		goto out;
3461 
3462 	ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3463 	batadv_tt_global_entry_free_ref(tt_global_entry);
3464 out:
3465 	return ret;
3466 }
3467 
3468 /**
3469  * batadv_tt_local_client_is_roaming - tells whether the client is roaming
3470  * @bat_priv: the bat priv with all the soft interface information
3471  * @addr: the mac address of the local client to query
3472  * @vid: VLAN identifier
3473  *
3474  * Returns true if the local client is known to be roaming (it is not served by
3475  * this node anymore) or not. If yes, the client is still present in the table
3476  * to keep the latter consistent with the node TTVN
3477  */
3478 bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv,
3479 				       u8 *addr, unsigned short vid)
3480 {
3481 	struct batadv_tt_local_entry *tt_local_entry;
3482 	bool ret = false;
3483 
3484 	tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid);
3485 	if (!tt_local_entry)
3486 		goto out;
3487 
3488 	ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM;
3489 	batadv_tt_local_entry_free_ref(tt_local_entry);
3490 out:
3491 	return ret;
3492 }
3493 
3494 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv,
3495 					  struct batadv_orig_node *orig_node,
3496 					  const unsigned char *addr,
3497 					  unsigned short vid)
3498 {
3499 	bool ret = false;
3500 
3501 	if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid,
3502 				  BATADV_TT_CLIENT_TEMP,
3503 				  atomic_read(&orig_node->last_ttvn)))
3504 		goto out;
3505 
3506 	batadv_dbg(BATADV_DBG_TT, bat_priv,
3507 		   "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n",
3508 		   addr, BATADV_PRINT_VID(vid), orig_node->orig);
3509 	ret = true;
3510 out:
3511 	return ret;
3512 }
3513 
3514 /**
3515  * batadv_tt_local_resize_to_mtu - resize the local translation table fit the
3516  *  maximum packet size that can be transported through the mesh
3517  * @soft_iface: netdev struct of the mesh interface
3518  *
3519  * Remove entries older than 'timeout' and half timeout if more entries need
3520  * to be removed.
3521  */
3522 void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface)
3523 {
3524 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
3525 	int packet_size_max = atomic_read(&bat_priv->packet_size_max);
3526 	int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2;
3527 	bool reduced = false;
3528 
3529 	spin_lock_bh(&bat_priv->tt.commit_lock);
3530 
3531 	while (true) {
3532 		table_size = batadv_tt_local_table_transmit_size(bat_priv);
3533 		if (packet_size_max >= table_size)
3534 			break;
3535 
3536 		batadv_tt_local_purge(bat_priv, timeout);
3537 		batadv_tt_local_purge_pending_clients(bat_priv);
3538 
3539 		timeout /= 2;
3540 		reduced = true;
3541 		net_ratelimited_function(batadv_info, soft_iface,
3542 					 "Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n",
3543 					 packet_size_max);
3544 	}
3545 
3546 	/* commit these changes immediately, to avoid synchronization problem
3547 	 * with the TTVN
3548 	 */
3549 	if (reduced)
3550 		batadv_tt_local_commit_changes_nolock(bat_priv);
3551 
3552 	spin_unlock_bh(&bat_priv->tt.commit_lock);
3553 }
3554 
3555 /**
3556  * batadv_tt_tvlv_ogm_handler_v1 - process incoming tt tvlv container
3557  * @bat_priv: the bat priv with all the soft interface information
3558  * @orig: the orig_node of the ogm
3559  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
3560  * @tvlv_value: tvlv buffer containing the gateway data
3561  * @tvlv_value_len: tvlv buffer length
3562  */
3563 static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
3564 					  struct batadv_orig_node *orig,
3565 					  u8 flags, void *tvlv_value,
3566 					  u16 tvlv_value_len)
3567 {
3568 	struct batadv_tvlv_tt_vlan_data *tt_vlan;
3569 	struct batadv_tvlv_tt_change *tt_change;
3570 	struct batadv_tvlv_tt_data *tt_data;
3571 	u16 num_entries, num_vlan;
3572 
3573 	if (tvlv_value_len < sizeof(*tt_data))
3574 		return;
3575 
3576 	tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
3577 	tvlv_value_len -= sizeof(*tt_data);
3578 
3579 	num_vlan = ntohs(tt_data->num_vlan);
3580 
3581 	if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan)
3582 		return;
3583 
3584 	tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1);
3585 	tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan);
3586 	tvlv_value_len -= sizeof(*tt_vlan) * num_vlan;
3587 
3588 	num_entries = batadv_tt_entries(tvlv_value_len);
3589 
3590 	batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change,
3591 			      num_entries, tt_data->ttvn);
3592 }
3593 
3594 /**
3595  * batadv_tt_tvlv_unicast_handler_v1 - process incoming (unicast) tt tvlv
3596  *  container
3597  * @bat_priv: the bat priv with all the soft interface information
3598  * @src: mac address of tt tvlv sender
3599  * @dst: mac address of tt tvlv recipient
3600  * @tvlv_value: tvlv buffer containing the tt data
3601  * @tvlv_value_len: tvlv buffer length
3602  *
3603  * Returns NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS
3604  * otherwise.
3605  */
3606 static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3607 					     u8 *src, u8 *dst,
3608 					     void *tvlv_value,
3609 					     u16 tvlv_value_len)
3610 {
3611 	struct batadv_tvlv_tt_data *tt_data;
3612 	u16 tt_vlan_len, tt_num_entries;
3613 	char tt_flag;
3614 	bool ret;
3615 
3616 	if (tvlv_value_len < sizeof(*tt_data))
3617 		return NET_RX_SUCCESS;
3618 
3619 	tt_data = (struct batadv_tvlv_tt_data *)tvlv_value;
3620 	tvlv_value_len -= sizeof(*tt_data);
3621 
3622 	tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data);
3623 	tt_vlan_len *= ntohs(tt_data->num_vlan);
3624 
3625 	if (tvlv_value_len < tt_vlan_len)
3626 		return NET_RX_SUCCESS;
3627 
3628 	tvlv_value_len -= tt_vlan_len;
3629 	tt_num_entries = batadv_tt_entries(tvlv_value_len);
3630 
3631 	switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) {
3632 	case BATADV_TT_REQUEST:
3633 		batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX);
3634 
3635 		/* If this node cannot provide a TT response the tt_request is
3636 		 * forwarded
3637 		 */
3638 		ret = batadv_send_tt_response(bat_priv, tt_data, src, dst);
3639 		if (!ret) {
3640 			if (tt_data->flags & BATADV_TT_FULL_TABLE)
3641 				tt_flag = 'F';
3642 			else
3643 				tt_flag = '.';
3644 
3645 			batadv_dbg(BATADV_DBG_TT, bat_priv,
3646 				   "Routing TT_REQUEST to %pM [%c]\n",
3647 				   dst, tt_flag);
3648 			/* tvlv API will re-route the packet */
3649 			return NET_RX_DROP;
3650 		}
3651 		break;
3652 	case BATADV_TT_RESPONSE:
3653 		batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX);
3654 
3655 		if (batadv_is_my_mac(bat_priv, dst)) {
3656 			batadv_handle_tt_response(bat_priv, tt_data,
3657 						  src, tt_num_entries);
3658 			return NET_RX_SUCCESS;
3659 		}
3660 
3661 		if (tt_data->flags & BATADV_TT_FULL_TABLE)
3662 			tt_flag =  'F';
3663 		else
3664 			tt_flag = '.';
3665 
3666 		batadv_dbg(BATADV_DBG_TT, bat_priv,
3667 			   "Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag);
3668 
3669 		/* tvlv API will re-route the packet */
3670 		return NET_RX_DROP;
3671 	}
3672 
3673 	return NET_RX_SUCCESS;
3674 }
3675 
3676 /**
3677  * batadv_roam_tvlv_unicast_handler_v1 - process incoming tt roam tvlv container
3678  * @bat_priv: the bat priv with all the soft interface information
3679  * @src: mac address of tt tvlv sender
3680  * @dst: mac address of tt tvlv recipient
3681  * @tvlv_value: tvlv buffer containing the tt data
3682  * @tvlv_value_len: tvlv buffer length
3683  *
3684  * Returns NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS
3685  * otherwise.
3686  */
3687 static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv,
3688 					       u8 *src, u8 *dst,
3689 					       void *tvlv_value,
3690 					       u16 tvlv_value_len)
3691 {
3692 	struct batadv_tvlv_roam_adv *roaming_adv;
3693 	struct batadv_orig_node *orig_node = NULL;
3694 
3695 	/* If this node is not the intended recipient of the
3696 	 * roaming advertisement the packet is forwarded
3697 	 * (the tvlv API will re-route the packet).
3698 	 */
3699 	if (!batadv_is_my_mac(bat_priv, dst))
3700 		return NET_RX_DROP;
3701 
3702 	if (tvlv_value_len < sizeof(*roaming_adv))
3703 		goto out;
3704 
3705 	orig_node = batadv_orig_hash_find(bat_priv, src);
3706 	if (!orig_node)
3707 		goto out;
3708 
3709 	batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX);
3710 	roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value;
3711 
3712 	batadv_dbg(BATADV_DBG_TT, bat_priv,
3713 		   "Received ROAMING_ADV from %pM (client %pM)\n",
3714 		   src, roaming_adv->client);
3715 
3716 	batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client,
3717 			     ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM,
3718 			     atomic_read(&orig_node->last_ttvn) + 1);
3719 
3720 out:
3721 	if (orig_node)
3722 		batadv_orig_node_free_ref(orig_node);
3723 	return NET_RX_SUCCESS;
3724 }
3725 
3726 /**
3727  * batadv_tt_init - initialise the translation table internals
3728  * @bat_priv: the bat priv with all the soft interface information
3729  *
3730  * Return 0 on success or negative error number in case of failure.
3731  */
3732 int batadv_tt_init(struct batadv_priv *bat_priv)
3733 {
3734 	int ret;
3735 
3736 	/* synchronized flags must be remote */
3737 	BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK));
3738 
3739 	ret = batadv_tt_local_init(bat_priv);
3740 	if (ret < 0)
3741 		return ret;
3742 
3743 	ret = batadv_tt_global_init(bat_priv);
3744 	if (ret < 0)
3745 		return ret;
3746 
3747 	batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1,
3748 				     batadv_tt_tvlv_unicast_handler_v1,
3749 				     BATADV_TVLV_TT, 1, BATADV_NO_FLAGS);
3750 
3751 	batadv_tvlv_handler_register(bat_priv, NULL,
3752 				     batadv_roam_tvlv_unicast_handler_v1,
3753 				     BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS);
3754 
3755 	INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge);
3756 	queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work,
3757 			   msecs_to_jiffies(BATADV_TT_WORK_PERIOD));
3758 
3759 	return 1;
3760 }
3761 
3762 /**
3763  * batadv_tt_global_is_isolated - check if a client is marked as isolated
3764  * @bat_priv: the bat priv with all the soft interface information
3765  * @addr: the mac address of the client
3766  * @vid: the identifier of the VLAN where this client is connected
3767  *
3768  * Returns true if the client is marked with the TT_CLIENT_ISOLA flag, false
3769  * otherwise
3770  */
3771 bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv,
3772 				  const u8 *addr, unsigned short vid)
3773 {
3774 	struct batadv_tt_global_entry *tt;
3775 	bool ret;
3776 
3777 	tt = batadv_tt_global_hash_find(bat_priv, addr, vid);
3778 	if (!tt)
3779 		return false;
3780 
3781 	ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA;
3782 
3783 	batadv_tt_global_entry_free_ref(tt);
3784 
3785 	return ret;
3786 }
3787