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