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