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