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