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