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