2 * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors:
4 * Marek Lindner, Simon Wunderlich
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 #include "translation-table.h"
24 #include "soft-interface.h"
25 #include "hard-interface.h"
28 #include "originator.h"
31 #include <linux/crc16.h>
33 static void _tt_global_del(struct bat_priv
*bat_priv
,
34 struct tt_global_entry
*tt_global_entry
,
36 static void tt_purge(struct work_struct
*work
);
38 /* returns 1 if they are the same mac addr */
39 static int compare_ltt(const struct hlist_node
*node
, const void *data2
)
41 const void *data1
= container_of(node
, struct tt_local_entry
,
44 return (memcmp(data1
, data2
, ETH_ALEN
) == 0 ? 1 : 0);
47 /* returns 1 if they are the same mac addr */
48 static int compare_gtt(const struct hlist_node
*node
, const void *data2
)
50 const void *data1
= container_of(node
, struct tt_global_entry
,
53 return (memcmp(data1
, data2
, ETH_ALEN
) == 0 ? 1 : 0);
56 static void tt_start_timer(struct bat_priv
*bat_priv
)
58 INIT_DELAYED_WORK(&bat_priv
->tt_work
, tt_purge
);
59 queue_delayed_work(bat_event_workqueue
, &bat_priv
->tt_work
,
60 msecs_to_jiffies(5000));
63 static struct tt_local_entry
*tt_local_hash_find(struct bat_priv
*bat_priv
,
66 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
67 struct hlist_head
*head
;
68 struct hlist_node
*node
;
69 struct tt_local_entry
*tt_local_entry
, *tt_local_entry_tmp
= NULL
;
75 index
= choose_orig(data
, hash
->size
);
76 head
= &hash
->table
[index
];
79 hlist_for_each_entry_rcu(tt_local_entry
, node
, head
, hash_entry
) {
80 if (!compare_eth(tt_local_entry
, data
))
83 if (!atomic_inc_not_zero(&tt_local_entry
->refcount
))
86 tt_local_entry_tmp
= tt_local_entry
;
91 return tt_local_entry_tmp
;
94 static struct tt_global_entry
*tt_global_hash_find(struct bat_priv
*bat_priv
,
97 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
98 struct hlist_head
*head
;
99 struct hlist_node
*node
;
100 struct tt_global_entry
*tt_global_entry
;
101 struct tt_global_entry
*tt_global_entry_tmp
= NULL
;
107 index
= choose_orig(data
, hash
->size
);
108 head
= &hash
->table
[index
];
111 hlist_for_each_entry_rcu(tt_global_entry
, node
, head
, hash_entry
) {
112 if (!compare_eth(tt_global_entry
, data
))
115 if (!atomic_inc_not_zero(&tt_global_entry
->refcount
))
118 tt_global_entry_tmp
= tt_global_entry
;
123 return tt_global_entry_tmp
;
126 static bool is_out_of_time(unsigned long starting_time
, unsigned long timeout
)
128 unsigned long deadline
;
129 deadline
= starting_time
+ msecs_to_jiffies(timeout
);
131 return time_after(jiffies
, deadline
);
134 static void tt_local_entry_free_ref(struct tt_local_entry
*tt_local_entry
)
136 if (atomic_dec_and_test(&tt_local_entry
->refcount
))
137 kfree_rcu(tt_local_entry
, rcu
);
140 static void tt_global_entry_free_rcu(struct rcu_head
*rcu
)
142 struct tt_global_entry
*tt_global_entry
;
144 tt_global_entry
= container_of(rcu
, struct tt_global_entry
, rcu
);
146 if (tt_global_entry
->orig_node
)
147 orig_node_free_ref(tt_global_entry
->orig_node
);
149 kfree(tt_global_entry
);
152 static void tt_global_entry_free_ref(struct tt_global_entry
*tt_global_entry
)
154 if (atomic_dec_and_test(&tt_global_entry
->refcount
))
155 call_rcu(&tt_global_entry
->rcu
, tt_global_entry_free_rcu
);
158 static void tt_local_event(struct bat_priv
*bat_priv
, const uint8_t *addr
,
161 struct tt_change_node
*tt_change_node
;
163 tt_change_node
= kmalloc(sizeof(*tt_change_node
), GFP_ATOMIC
);
168 tt_change_node
->change
.flags
= flags
;
169 memcpy(tt_change_node
->change
.addr
, addr
, ETH_ALEN
);
171 spin_lock_bh(&bat_priv
->tt_changes_list_lock
);
172 /* track the change in the OGMinterval list */
173 list_add_tail(&tt_change_node
->list
, &bat_priv
->tt_changes_list
);
174 atomic_inc(&bat_priv
->tt_local_changes
);
175 spin_unlock_bh(&bat_priv
->tt_changes_list_lock
);
177 atomic_set(&bat_priv
->tt_ogm_append_cnt
, 0);
180 int tt_len(int changes_num
)
182 return changes_num
* sizeof(struct tt_change
);
185 static int tt_local_init(struct bat_priv
*bat_priv
)
187 if (bat_priv
->tt_local_hash
)
190 bat_priv
->tt_local_hash
= hash_new(1024);
192 if (!bat_priv
->tt_local_hash
)
198 void tt_local_add(struct net_device
*soft_iface
, const uint8_t *addr
)
200 struct bat_priv
*bat_priv
= netdev_priv(soft_iface
);
201 struct tt_local_entry
*tt_local_entry
= NULL
;
202 struct tt_global_entry
*tt_global_entry
= NULL
;
204 tt_local_entry
= tt_local_hash_find(bat_priv
, addr
);
206 if (tt_local_entry
) {
207 tt_local_entry
->last_seen
= jiffies
;
211 tt_local_entry
= kmalloc(sizeof(*tt_local_entry
), GFP_ATOMIC
);
215 bat_dbg(DBG_TT
, bat_priv
,
216 "Creating new local tt entry: %pM (ttvn: %d)\n", addr
,
217 (uint8_t)atomic_read(&bat_priv
->ttvn
));
219 memcpy(tt_local_entry
->addr
, addr
, ETH_ALEN
);
220 tt_local_entry
->last_seen
= jiffies
;
221 tt_local_entry
->flags
= NO_FLAGS
;
222 atomic_set(&tt_local_entry
->refcount
, 2);
224 /* the batman interface mac address should never be purged */
225 if (compare_eth(addr
, soft_iface
->dev_addr
))
226 tt_local_entry
->flags
|= TT_CLIENT_NOPURGE
;
228 tt_local_event(bat_priv
, addr
, tt_local_entry
->flags
);
230 /* The local entry has to be marked as NEW to avoid to send it in
231 * a full table response going out before the next ttvn increment
232 * (consistency check) */
233 tt_local_entry
->flags
|= TT_CLIENT_NEW
;
235 hash_add(bat_priv
->tt_local_hash
, compare_ltt
, choose_orig
,
236 tt_local_entry
, &tt_local_entry
->hash_entry
);
238 /* remove address from global hash if present */
239 tt_global_entry
= tt_global_hash_find(bat_priv
, addr
);
241 /* Check whether it is a roaming! */
242 if (tt_global_entry
) {
243 /* This node is probably going to update its tt table */
244 tt_global_entry
->orig_node
->tt_poss_change
= true;
245 /* The global entry has to be marked as PENDING and has to be
246 * kept for consistency purpose */
247 tt_global_entry
->flags
|= TT_CLIENT_PENDING
;
248 send_roam_adv(bat_priv
, tt_global_entry
->addr
,
249 tt_global_entry
->orig_node
);
253 tt_local_entry_free_ref(tt_local_entry
);
255 tt_global_entry_free_ref(tt_global_entry
);
258 int tt_changes_fill_buffer(struct bat_priv
*bat_priv
,
259 unsigned char *buff
, int buff_len
)
261 int count
= 0, tot_changes
= 0;
262 struct tt_change_node
*entry
, *safe
;
265 tot_changes
= buff_len
/ tt_len(1);
267 spin_lock_bh(&bat_priv
->tt_changes_list_lock
);
268 atomic_set(&bat_priv
->tt_local_changes
, 0);
270 list_for_each_entry_safe(entry
, safe
, &bat_priv
->tt_changes_list
,
272 if (count
< tot_changes
) {
273 memcpy(buff
+ tt_len(count
),
274 &entry
->change
, sizeof(struct tt_change
));
277 list_del(&entry
->list
);
280 spin_unlock_bh(&bat_priv
->tt_changes_list_lock
);
282 /* Keep the buffer for possible tt_request */
283 spin_lock_bh(&bat_priv
->tt_buff_lock
);
284 kfree(bat_priv
->tt_buff
);
285 bat_priv
->tt_buff_len
= 0;
286 bat_priv
->tt_buff
= NULL
;
287 /* We check whether this new OGM has no changes due to size
291 * if kmalloc() fails we will reply with the full table
292 * instead of providing the diff
294 bat_priv
->tt_buff
= kmalloc(buff_len
, GFP_ATOMIC
);
295 if (bat_priv
->tt_buff
) {
296 memcpy(bat_priv
->tt_buff
, buff
, buff_len
);
297 bat_priv
->tt_buff_len
= buff_len
;
300 spin_unlock_bh(&bat_priv
->tt_buff_lock
);
305 int tt_local_seq_print_text(struct seq_file
*seq
, void *offset
)
307 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
308 struct bat_priv
*bat_priv
= netdev_priv(net_dev
);
309 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
310 struct tt_local_entry
*tt_local_entry
;
311 struct hard_iface
*primary_if
;
312 struct hlist_node
*node
;
313 struct hlist_head
*head
;
314 size_t buf_size
, pos
;
318 primary_if
= primary_if_get_selected(bat_priv
);
320 ret
= seq_printf(seq
, "BATMAN mesh %s disabled - "
321 "please specify interfaces to enable it\n",
326 if (primary_if
->if_status
!= IF_ACTIVE
) {
327 ret
= seq_printf(seq
, "BATMAN mesh %s disabled - "
328 "primary interface not active\n",
333 seq_printf(seq
, "Locally retrieved addresses (from %s) "
334 "announced via TT (TTVN: %u):\n",
335 net_dev
->name
, (uint8_t)atomic_read(&bat_priv
->ttvn
));
338 /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */
339 for (i
= 0; i
< hash
->size
; i
++) {
340 head
= &hash
->table
[i
];
343 __hlist_for_each_rcu(node
, head
)
348 buff
= kmalloc(buf_size
, GFP_ATOMIC
);
357 for (i
= 0; i
< hash
->size
; i
++) {
358 head
= &hash
->table
[i
];
361 hlist_for_each_entry_rcu(tt_local_entry
, node
,
363 pos
+= snprintf(buff
+ pos
, 22, " * %pM\n",
364 tt_local_entry
->addr
);
369 seq_printf(seq
, "%s", buff
);
373 hardif_free_ref(primary_if
);
377 static void tt_local_set_pending(struct bat_priv
*bat_priv
,
378 struct tt_local_entry
*tt_local_entry
,
381 tt_local_event(bat_priv
, tt_local_entry
->addr
,
382 tt_local_entry
->flags
| flags
);
384 /* The local client has to be merked as "pending to be removed" but has
385 * to be kept in the table in order to send it in an full tables
386 * response issued before the net ttvn increment (consistency check) */
387 tt_local_entry
->flags
|= TT_CLIENT_PENDING
;
390 void tt_local_remove(struct bat_priv
*bat_priv
, const uint8_t *addr
,
391 const char *message
, bool roaming
)
393 struct tt_local_entry
*tt_local_entry
= NULL
;
395 tt_local_entry
= tt_local_hash_find(bat_priv
, addr
);
399 tt_local_set_pending(bat_priv
, tt_local_entry
, TT_CLIENT_DEL
|
400 (roaming
? TT_CLIENT_ROAM
: NO_FLAGS
));
402 bat_dbg(DBG_TT
, bat_priv
, "Local tt entry (%pM) pending to be removed: "
403 "%s\n", tt_local_entry
->addr
, message
);
406 tt_local_entry_free_ref(tt_local_entry
);
409 static void tt_local_purge(struct bat_priv
*bat_priv
)
411 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
412 struct tt_local_entry
*tt_local_entry
;
413 struct hlist_node
*node
, *node_tmp
;
414 struct hlist_head
*head
;
415 spinlock_t
*list_lock
; /* protects write access to the hash lists */
418 for (i
= 0; i
< hash
->size
; i
++) {
419 head
= &hash
->table
[i
];
420 list_lock
= &hash
->list_locks
[i
];
422 spin_lock_bh(list_lock
);
423 hlist_for_each_entry_safe(tt_local_entry
, node
, node_tmp
,
425 if (tt_local_entry
->flags
& TT_CLIENT_NOPURGE
)
428 /* entry already marked for deletion */
429 if (tt_local_entry
->flags
& TT_CLIENT_PENDING
)
432 if (!is_out_of_time(tt_local_entry
->last_seen
,
433 TT_LOCAL_TIMEOUT
* 1000))
436 tt_local_set_pending(bat_priv
, tt_local_entry
,
438 bat_dbg(DBG_TT
, bat_priv
, "Local tt entry (%pM) "
439 "pending to be removed: timed out\n",
440 tt_local_entry
->addr
);
442 spin_unlock_bh(list_lock
);
447 static void tt_local_table_free(struct bat_priv
*bat_priv
)
449 struct hashtable_t
*hash
;
450 spinlock_t
*list_lock
; /* protects write access to the hash lists */
451 struct tt_local_entry
*tt_local_entry
;
452 struct hlist_node
*node
, *node_tmp
;
453 struct hlist_head
*head
;
456 if (!bat_priv
->tt_local_hash
)
459 hash
= bat_priv
->tt_local_hash
;
461 for (i
= 0; i
< hash
->size
; i
++) {
462 head
= &hash
->table
[i
];
463 list_lock
= &hash
->list_locks
[i
];
465 spin_lock_bh(list_lock
);
466 hlist_for_each_entry_safe(tt_local_entry
, node
, node_tmp
,
469 tt_local_entry_free_ref(tt_local_entry
);
471 spin_unlock_bh(list_lock
);
476 bat_priv
->tt_local_hash
= NULL
;
479 static int tt_global_init(struct bat_priv
*bat_priv
)
481 if (bat_priv
->tt_global_hash
)
484 bat_priv
->tt_global_hash
= hash_new(1024);
486 if (!bat_priv
->tt_global_hash
)
492 static void tt_changes_list_free(struct bat_priv
*bat_priv
)
494 struct tt_change_node
*entry
, *safe
;
496 spin_lock_bh(&bat_priv
->tt_changes_list_lock
);
498 list_for_each_entry_safe(entry
, safe
, &bat_priv
->tt_changes_list
,
500 list_del(&entry
->list
);
504 atomic_set(&bat_priv
->tt_local_changes
, 0);
505 spin_unlock_bh(&bat_priv
->tt_changes_list_lock
);
508 /* caller must hold orig_node refcount */
509 int tt_global_add(struct bat_priv
*bat_priv
, struct orig_node
*orig_node
,
510 const unsigned char *tt_addr
, uint8_t ttvn
, bool roaming
)
512 struct tt_global_entry
*tt_global_entry
;
513 struct orig_node
*orig_node_tmp
;
516 tt_global_entry
= tt_global_hash_find(bat_priv
, tt_addr
);
518 if (!tt_global_entry
) {
520 kmalloc(sizeof(*tt_global_entry
),
522 if (!tt_global_entry
)
525 memcpy(tt_global_entry
->addr
, tt_addr
, ETH_ALEN
);
526 /* Assign the new orig_node */
527 atomic_inc(&orig_node
->refcount
);
528 tt_global_entry
->orig_node
= orig_node
;
529 tt_global_entry
->ttvn
= ttvn
;
530 tt_global_entry
->flags
= NO_FLAGS
;
531 tt_global_entry
->roam_at
= 0;
532 atomic_set(&tt_global_entry
->refcount
, 2);
534 hash_add(bat_priv
->tt_global_hash
, compare_gtt
,
535 choose_orig
, tt_global_entry
,
536 &tt_global_entry
->hash_entry
);
537 atomic_inc(&orig_node
->tt_size
);
539 if (tt_global_entry
->orig_node
!= orig_node
) {
540 atomic_dec(&tt_global_entry
->orig_node
->tt_size
);
541 orig_node_tmp
= tt_global_entry
->orig_node
;
542 atomic_inc(&orig_node
->refcount
);
543 tt_global_entry
->orig_node
= orig_node
;
544 orig_node_free_ref(orig_node_tmp
);
545 atomic_inc(&orig_node
->tt_size
);
547 tt_global_entry
->ttvn
= ttvn
;
548 tt_global_entry
->flags
= NO_FLAGS
;
549 tt_global_entry
->roam_at
= 0;
552 bat_dbg(DBG_TT
, bat_priv
,
553 "Creating new global tt entry: %pM (via %pM)\n",
554 tt_global_entry
->addr
, orig_node
->orig
);
556 /* remove address from local hash if present */
557 tt_local_remove(bat_priv
, tt_global_entry
->addr
,
558 "global tt received", roaming
);
562 tt_global_entry_free_ref(tt_global_entry
);
566 int tt_global_seq_print_text(struct seq_file
*seq
, void *offset
)
568 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
569 struct bat_priv
*bat_priv
= netdev_priv(net_dev
);
570 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
571 struct tt_global_entry
*tt_global_entry
;
572 struct hard_iface
*primary_if
;
573 struct hlist_node
*node
;
574 struct hlist_head
*head
;
575 size_t buf_size
, pos
;
579 primary_if
= primary_if_get_selected(bat_priv
);
581 ret
= seq_printf(seq
, "BATMAN mesh %s disabled - please "
582 "specify interfaces to enable it\n",
587 if (primary_if
->if_status
!= IF_ACTIVE
) {
588 ret
= seq_printf(seq
, "BATMAN mesh %s disabled - "
589 "primary interface not active\n",
595 "Globally announced TT entries received via the mesh %s\n",
597 seq_printf(seq
, " %-13s %s %-15s %s\n",
598 "Client", "(TTVN)", "Originator", "(Curr TTVN)");
601 /* Estimate length for: " * xx:xx:xx:xx:xx:xx (ttvn) via
602 * xx:xx:xx:xx:xx:xx (cur_ttvn)\n"*/
603 for (i
= 0; i
< hash
->size
; i
++) {
604 head
= &hash
->table
[i
];
607 __hlist_for_each_rcu(node
, head
)
612 buff
= kmalloc(buf_size
, GFP_ATOMIC
);
621 for (i
= 0; i
< hash
->size
; i
++) {
622 head
= &hash
->table
[i
];
625 hlist_for_each_entry_rcu(tt_global_entry
, node
,
627 pos
+= snprintf(buff
+ pos
, 61,
628 " * %pM (%3u) via %pM (%3u)\n",
629 tt_global_entry
->addr
,
630 tt_global_entry
->ttvn
,
631 tt_global_entry
->orig_node
->orig
,
632 (uint8_t) atomic_read(
633 &tt_global_entry
->orig_node
->
639 seq_printf(seq
, "%s", buff
);
643 hardif_free_ref(primary_if
);
647 static void _tt_global_del(struct bat_priv
*bat_priv
,
648 struct tt_global_entry
*tt_global_entry
,
651 if (!tt_global_entry
)
654 bat_dbg(DBG_TT
, bat_priv
,
655 "Deleting global tt entry %pM (via %pM): %s\n",
656 tt_global_entry
->addr
, tt_global_entry
->orig_node
->orig
,
659 atomic_dec(&tt_global_entry
->orig_node
->tt_size
);
661 hash_remove(bat_priv
->tt_global_hash
, compare_gtt
, choose_orig
,
662 tt_global_entry
->addr
);
665 tt_global_entry_free_ref(tt_global_entry
);
668 void tt_global_del(struct bat_priv
*bat_priv
,
669 struct orig_node
*orig_node
, const unsigned char *addr
,
670 const char *message
, bool roaming
)
672 struct tt_global_entry
*tt_global_entry
= NULL
;
674 tt_global_entry
= tt_global_hash_find(bat_priv
, addr
);
675 if (!tt_global_entry
)
678 if (tt_global_entry
->orig_node
== orig_node
) {
680 tt_global_entry
->flags
|= TT_CLIENT_ROAM
;
681 tt_global_entry
->roam_at
= jiffies
;
684 _tt_global_del(bat_priv
, tt_global_entry
, message
);
688 tt_global_entry_free_ref(tt_global_entry
);
691 void tt_global_del_orig(struct bat_priv
*bat_priv
,
692 struct orig_node
*orig_node
, const char *message
)
694 struct tt_global_entry
*tt_global_entry
;
696 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
697 struct hlist_node
*node
, *safe
;
698 struct hlist_head
*head
;
699 spinlock_t
*list_lock
; /* protects write access to the hash lists */
701 for (i
= 0; i
< hash
->size
; i
++) {
702 head
= &hash
->table
[i
];
703 list_lock
= &hash
->list_locks
[i
];
705 spin_lock_bh(list_lock
);
706 hlist_for_each_entry_safe(tt_global_entry
, node
, safe
,
708 if (tt_global_entry
->orig_node
== orig_node
) {
709 bat_dbg(DBG_TT
, bat_priv
,
710 "Deleting global tt entry %pM "
711 "(via %pM): originator time out\n",
712 tt_global_entry
->addr
,
713 tt_global_entry
->orig_node
->orig
);
715 tt_global_entry_free_ref(tt_global_entry
);
718 spin_unlock_bh(list_lock
);
720 atomic_set(&orig_node
->tt_size
, 0);
723 static void tt_global_roam_purge(struct bat_priv
*bat_priv
)
725 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
726 struct tt_global_entry
*tt_global_entry
;
727 struct hlist_node
*node
, *node_tmp
;
728 struct hlist_head
*head
;
729 spinlock_t
*list_lock
; /* protects write access to the hash lists */
732 for (i
= 0; i
< hash
->size
; i
++) {
733 head
= &hash
->table
[i
];
734 list_lock
= &hash
->list_locks
[i
];
736 spin_lock_bh(list_lock
);
737 hlist_for_each_entry_safe(tt_global_entry
, node
, node_tmp
,
739 if (!(tt_global_entry
->flags
& TT_CLIENT_ROAM
))
741 if (!is_out_of_time(tt_global_entry
->roam_at
,
742 TT_CLIENT_ROAM_TIMEOUT
* 1000))
745 bat_dbg(DBG_TT
, bat_priv
, "Deleting global "
746 "tt entry (%pM): Roaming timeout\n",
747 tt_global_entry
->addr
);
748 atomic_dec(&tt_global_entry
->orig_node
->tt_size
);
750 tt_global_entry_free_ref(tt_global_entry
);
752 spin_unlock_bh(list_lock
);
757 static void tt_global_table_free(struct bat_priv
*bat_priv
)
759 struct hashtable_t
*hash
;
760 spinlock_t
*list_lock
; /* protects write access to the hash lists */
761 struct tt_global_entry
*tt_global_entry
;
762 struct hlist_node
*node
, *node_tmp
;
763 struct hlist_head
*head
;
766 if (!bat_priv
->tt_global_hash
)
769 hash
= bat_priv
->tt_global_hash
;
771 for (i
= 0; i
< hash
->size
; i
++) {
772 head
= &hash
->table
[i
];
773 list_lock
= &hash
->list_locks
[i
];
775 spin_lock_bh(list_lock
);
776 hlist_for_each_entry_safe(tt_global_entry
, node
, node_tmp
,
779 tt_global_entry_free_ref(tt_global_entry
);
781 spin_unlock_bh(list_lock
);
786 bat_priv
->tt_global_hash
= NULL
;
789 struct orig_node
*transtable_search(struct bat_priv
*bat_priv
,
792 struct tt_global_entry
*tt_global_entry
;
793 struct orig_node
*orig_node
= NULL
;
795 tt_global_entry
= tt_global_hash_find(bat_priv
, addr
);
797 if (!tt_global_entry
)
800 if (!atomic_inc_not_zero(&tt_global_entry
->orig_node
->refcount
))
803 /* A global client marked as PENDING has already moved from that
805 if (tt_global_entry
->flags
& TT_CLIENT_PENDING
)
808 orig_node
= tt_global_entry
->orig_node
;
811 tt_global_entry_free_ref(tt_global_entry
);
816 /* Calculates the checksum of the local table of a given orig_node */
817 uint16_t tt_global_crc(struct bat_priv
*bat_priv
, struct orig_node
*orig_node
)
819 uint16_t total
= 0, total_one
;
820 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
821 struct tt_global_entry
*tt_global_entry
;
822 struct hlist_node
*node
;
823 struct hlist_head
*head
;
826 for (i
= 0; i
< hash
->size
; i
++) {
827 head
= &hash
->table
[i
];
830 hlist_for_each_entry_rcu(tt_global_entry
, node
,
832 if (compare_eth(tt_global_entry
->orig_node
,
834 /* Roaming clients are in the global table for
835 * consistency only. They don't have to be
836 * taken into account while computing the
838 if (tt_global_entry
->flags
& TT_CLIENT_ROAM
)
841 for (j
= 0; j
< ETH_ALEN
; j
++)
842 total_one
= crc16_byte(total_one
,
843 tt_global_entry
->addr
[j
]);
853 /* Calculates the checksum of the local table */
854 uint16_t tt_local_crc(struct bat_priv
*bat_priv
)
856 uint16_t total
= 0, total_one
;
857 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
858 struct tt_local_entry
*tt_local_entry
;
859 struct hlist_node
*node
;
860 struct hlist_head
*head
;
863 for (i
= 0; i
< hash
->size
; i
++) {
864 head
= &hash
->table
[i
];
867 hlist_for_each_entry_rcu(tt_local_entry
, node
,
869 /* not yet committed clients have not to be taken into
870 * account while computing the CRC */
871 if (tt_local_entry
->flags
& TT_CLIENT_NEW
)
874 for (j
= 0; j
< ETH_ALEN
; j
++)
875 total_one
= crc16_byte(total_one
,
876 tt_local_entry
->addr
[j
]);
885 static void tt_req_list_free(struct bat_priv
*bat_priv
)
887 struct tt_req_node
*node
, *safe
;
889 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
891 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_req_list
, list
) {
892 list_del(&node
->list
);
896 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
899 void tt_save_orig_buffer(struct bat_priv
*bat_priv
, struct orig_node
*orig_node
,
900 const unsigned char *tt_buff
, uint8_t tt_num_changes
)
902 uint16_t tt_buff_len
= tt_len(tt_num_changes
);
904 /* Replace the old buffer only if I received something in the
905 * last OGM (the OGM could carry no changes) */
906 spin_lock_bh(&orig_node
->tt_buff_lock
);
907 if (tt_buff_len
> 0) {
908 kfree(orig_node
->tt_buff
);
909 orig_node
->tt_buff_len
= 0;
910 orig_node
->tt_buff
= kmalloc(tt_buff_len
, GFP_ATOMIC
);
911 if (orig_node
->tt_buff
) {
912 memcpy(orig_node
->tt_buff
, tt_buff
, tt_buff_len
);
913 orig_node
->tt_buff_len
= tt_buff_len
;
916 spin_unlock_bh(&orig_node
->tt_buff_lock
);
919 static void tt_req_purge(struct bat_priv
*bat_priv
)
921 struct tt_req_node
*node
, *safe
;
923 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
924 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_req_list
, list
) {
925 if (is_out_of_time(node
->issued_at
,
926 TT_REQUEST_TIMEOUT
* 1000)) {
927 list_del(&node
->list
);
931 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
934 /* returns the pointer to the new tt_req_node struct if no request
935 * has already been issued for this orig_node, NULL otherwise */
936 static struct tt_req_node
*new_tt_req_node(struct bat_priv
*bat_priv
,
937 struct orig_node
*orig_node
)
939 struct tt_req_node
*tt_req_node_tmp
, *tt_req_node
= NULL
;
941 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
942 list_for_each_entry(tt_req_node_tmp
, &bat_priv
->tt_req_list
, list
) {
943 if (compare_eth(tt_req_node_tmp
, orig_node
) &&
944 !is_out_of_time(tt_req_node_tmp
->issued_at
,
945 TT_REQUEST_TIMEOUT
* 1000))
949 tt_req_node
= kmalloc(sizeof(*tt_req_node
), GFP_ATOMIC
);
953 memcpy(tt_req_node
->addr
, orig_node
->orig
, ETH_ALEN
);
954 tt_req_node
->issued_at
= jiffies
;
956 list_add(&tt_req_node
->list
, &bat_priv
->tt_req_list
);
958 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
962 /* data_ptr is useless here, but has to be kept to respect the prototype */
963 static int tt_local_valid_entry(const void *entry_ptr
, const void *data_ptr
)
965 const struct tt_local_entry
*tt_local_entry
= entry_ptr
;
967 if (tt_local_entry
->flags
& TT_CLIENT_NEW
)
972 static int tt_global_valid_entry(const void *entry_ptr
, const void *data_ptr
)
974 const struct tt_global_entry
*tt_global_entry
= entry_ptr
;
975 const struct orig_node
*orig_node
= data_ptr
;
977 if (tt_global_entry
->flags
& TT_CLIENT_ROAM
)
980 return (tt_global_entry
->orig_node
== orig_node
);
983 static struct sk_buff
*tt_response_fill_table(uint16_t tt_len
, uint8_t ttvn
,
984 struct hashtable_t
*hash
,
985 struct hard_iface
*primary_if
,
986 int (*valid_cb
)(const void *,
990 struct tt_local_entry
*tt_local_entry
;
991 struct tt_query_packet
*tt_response
;
992 struct tt_change
*tt_change
;
993 struct hlist_node
*node
;
994 struct hlist_head
*head
;
995 struct sk_buff
*skb
= NULL
;
996 uint16_t tt_tot
, tt_count
;
997 ssize_t tt_query_size
= sizeof(struct tt_query_packet
);
1000 if (tt_query_size
+ tt_len
> primary_if
->soft_iface
->mtu
) {
1001 tt_len
= primary_if
->soft_iface
->mtu
- tt_query_size
;
1002 tt_len
-= tt_len
% sizeof(struct tt_change
);
1004 tt_tot
= tt_len
/ sizeof(struct tt_change
);
1006 skb
= dev_alloc_skb(tt_query_size
+ tt_len
+ ETH_HLEN
);
1010 skb_reserve(skb
, ETH_HLEN
);
1011 tt_response
= (struct tt_query_packet
*)skb_put(skb
,
1012 tt_query_size
+ tt_len
);
1013 tt_response
->ttvn
= ttvn
;
1015 tt_change
= (struct tt_change
*)(skb
->data
+ tt_query_size
);
1019 for (i
= 0; i
< hash
->size
; i
++) {
1020 head
= &hash
->table
[i
];
1022 hlist_for_each_entry_rcu(tt_local_entry
, node
,
1024 if (tt_count
== tt_tot
)
1027 if ((valid_cb
) && (!valid_cb(tt_local_entry
, cb_data
)))
1030 memcpy(tt_change
->addr
, tt_local_entry
->addr
, ETH_ALEN
);
1031 tt_change
->flags
= NO_FLAGS
;
1039 /* store in the message the number of entries we have successfully
1041 tt_response
->tt_data
= htons(tt_count
);
1047 int send_tt_request(struct bat_priv
*bat_priv
, struct orig_node
*dst_orig_node
,
1048 uint8_t ttvn
, uint16_t tt_crc
, bool full_table
)
1050 struct sk_buff
*skb
= NULL
;
1051 struct tt_query_packet
*tt_request
;
1052 struct neigh_node
*neigh_node
= NULL
;
1053 struct hard_iface
*primary_if
;
1054 struct tt_req_node
*tt_req_node
= NULL
;
1057 primary_if
= primary_if_get_selected(bat_priv
);
1061 /* The new tt_req will be issued only if I'm not waiting for a
1062 * reply from the same orig_node yet */
1063 tt_req_node
= new_tt_req_node(bat_priv
, dst_orig_node
);
1067 skb
= dev_alloc_skb(sizeof(struct tt_query_packet
) + ETH_HLEN
);
1071 skb_reserve(skb
, ETH_HLEN
);
1073 tt_request
= (struct tt_query_packet
*)skb_put(skb
,
1074 sizeof(struct tt_query_packet
));
1076 tt_request
->packet_type
= BAT_TT_QUERY
;
1077 tt_request
->version
= COMPAT_VERSION
;
1078 memcpy(tt_request
->src
, primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
1079 memcpy(tt_request
->dst
, dst_orig_node
->orig
, ETH_ALEN
);
1080 tt_request
->ttl
= TTL
;
1081 tt_request
->ttvn
= ttvn
;
1082 tt_request
->tt_data
= tt_crc
;
1083 tt_request
->flags
= TT_REQUEST
;
1086 tt_request
->flags
|= TT_FULL_TABLE
;
1088 neigh_node
= orig_node_get_router(dst_orig_node
);
1092 bat_dbg(DBG_TT
, bat_priv
, "Sending TT_REQUEST to %pM via %pM "
1093 "[%c]\n", dst_orig_node
->orig
, neigh_node
->addr
,
1094 (full_table
? 'F' : '.'));
1096 send_skb_packet(skb
, neigh_node
->if_incoming
, neigh_node
->addr
);
1101 neigh_node_free_ref(neigh_node
);
1103 hardif_free_ref(primary_if
);
1106 if (ret
&& tt_req_node
) {
1107 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
1108 list_del(&tt_req_node
->list
);
1109 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
1115 static bool send_other_tt_response(struct bat_priv
*bat_priv
,
1116 struct tt_query_packet
*tt_request
)
1118 struct orig_node
*req_dst_orig_node
= NULL
, *res_dst_orig_node
= NULL
;
1119 struct neigh_node
*neigh_node
= NULL
;
1120 struct hard_iface
*primary_if
= NULL
;
1121 uint8_t orig_ttvn
, req_ttvn
, ttvn
;
1123 unsigned char *tt_buff
;
1125 uint16_t tt_len
, tt_tot
;
1126 struct sk_buff
*skb
= NULL
;
1127 struct tt_query_packet
*tt_response
;
1129 bat_dbg(DBG_TT
, bat_priv
,
1130 "Received TT_REQUEST from %pM for "
1131 "ttvn: %u (%pM) [%c]\n", tt_request
->src
,
1132 tt_request
->ttvn
, tt_request
->dst
,
1133 (tt_request
->flags
& TT_FULL_TABLE
? 'F' : '.'));
1135 /* Let's get the orig node of the REAL destination */
1136 req_dst_orig_node
= get_orig_node(bat_priv
, tt_request
->dst
);
1137 if (!req_dst_orig_node
)
1140 res_dst_orig_node
= get_orig_node(bat_priv
, tt_request
->src
);
1141 if (!res_dst_orig_node
)
1144 neigh_node
= orig_node_get_router(res_dst_orig_node
);
1148 primary_if
= primary_if_get_selected(bat_priv
);
1152 orig_ttvn
= (uint8_t)atomic_read(&req_dst_orig_node
->last_ttvn
);
1153 req_ttvn
= tt_request
->ttvn
;
1155 /* I have not the requested data */
1156 if (orig_ttvn
!= req_ttvn
||
1157 tt_request
->tt_data
!= req_dst_orig_node
->tt_crc
)
1160 /* If it has explicitly been requested the full table */
1161 if (tt_request
->flags
& TT_FULL_TABLE
||
1162 !req_dst_orig_node
->tt_buff
)
1167 /* In this version, fragmentation is not implemented, then
1168 * I'll send only one packet with as much TT entries as I can */
1170 spin_lock_bh(&req_dst_orig_node
->tt_buff_lock
);
1171 tt_len
= req_dst_orig_node
->tt_buff_len
;
1172 tt_tot
= tt_len
/ sizeof(struct tt_change
);
1174 skb
= dev_alloc_skb(sizeof(struct tt_query_packet
) +
1179 skb_reserve(skb
, ETH_HLEN
);
1180 tt_response
= (struct tt_query_packet
*)skb_put(skb
,
1181 sizeof(struct tt_query_packet
) + tt_len
);
1182 tt_response
->ttvn
= req_ttvn
;
1183 tt_response
->tt_data
= htons(tt_tot
);
1185 tt_buff
= skb
->data
+ sizeof(struct tt_query_packet
);
1186 /* Copy the last orig_node's OGM buffer */
1187 memcpy(tt_buff
, req_dst_orig_node
->tt_buff
,
1188 req_dst_orig_node
->tt_buff_len
);
1190 spin_unlock_bh(&req_dst_orig_node
->tt_buff_lock
);
1192 tt_len
= (uint16_t)atomic_read(&req_dst_orig_node
->tt_size
) *
1193 sizeof(struct tt_change
);
1194 ttvn
= (uint8_t)atomic_read(&req_dst_orig_node
->last_ttvn
);
1196 skb
= tt_response_fill_table(tt_len
, ttvn
,
1197 bat_priv
->tt_global_hash
,
1198 primary_if
, tt_global_valid_entry
,
1203 tt_response
= (struct tt_query_packet
*)skb
->data
;
1206 tt_response
->packet_type
= BAT_TT_QUERY
;
1207 tt_response
->version
= COMPAT_VERSION
;
1208 tt_response
->ttl
= TTL
;
1209 memcpy(tt_response
->src
, req_dst_orig_node
->orig
, ETH_ALEN
);
1210 memcpy(tt_response
->dst
, tt_request
->src
, ETH_ALEN
);
1211 tt_response
->flags
= TT_RESPONSE
;
1214 tt_response
->flags
|= TT_FULL_TABLE
;
1216 bat_dbg(DBG_TT
, bat_priv
,
1217 "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
1218 res_dst_orig_node
->orig
, neigh_node
->addr
,
1219 req_dst_orig_node
->orig
, req_ttvn
);
1221 send_skb_packet(skb
, neigh_node
->if_incoming
, neigh_node
->addr
);
1226 spin_unlock_bh(&req_dst_orig_node
->tt_buff_lock
);
1229 if (res_dst_orig_node
)
1230 orig_node_free_ref(res_dst_orig_node
);
1231 if (req_dst_orig_node
)
1232 orig_node_free_ref(req_dst_orig_node
);
1234 neigh_node_free_ref(neigh_node
);
1236 hardif_free_ref(primary_if
);
1242 static bool send_my_tt_response(struct bat_priv
*bat_priv
,
1243 struct tt_query_packet
*tt_request
)
1245 struct orig_node
*orig_node
= NULL
;
1246 struct neigh_node
*neigh_node
= NULL
;
1247 struct hard_iface
*primary_if
= NULL
;
1248 uint8_t my_ttvn
, req_ttvn
, ttvn
;
1250 unsigned char *tt_buff
;
1252 uint16_t tt_len
, tt_tot
;
1253 struct sk_buff
*skb
= NULL
;
1254 struct tt_query_packet
*tt_response
;
1256 bat_dbg(DBG_TT
, bat_priv
,
1257 "Received TT_REQUEST from %pM for "
1258 "ttvn: %u (me) [%c]\n", tt_request
->src
,
1260 (tt_request
->flags
& TT_FULL_TABLE
? 'F' : '.'));
1263 my_ttvn
= (uint8_t)atomic_read(&bat_priv
->ttvn
);
1264 req_ttvn
= tt_request
->ttvn
;
1266 orig_node
= get_orig_node(bat_priv
, tt_request
->src
);
1270 neigh_node
= orig_node_get_router(orig_node
);
1274 primary_if
= primary_if_get_selected(bat_priv
);
1278 /* If the full table has been explicitly requested or the gap
1279 * is too big send the whole local translation table */
1280 if (tt_request
->flags
& TT_FULL_TABLE
|| my_ttvn
!= req_ttvn
||
1286 /* In this version, fragmentation is not implemented, then
1287 * I'll send only one packet with as much TT entries as I can */
1289 spin_lock_bh(&bat_priv
->tt_buff_lock
);
1290 tt_len
= bat_priv
->tt_buff_len
;
1291 tt_tot
= tt_len
/ sizeof(struct tt_change
);
1293 skb
= dev_alloc_skb(sizeof(struct tt_query_packet
) +
1298 skb_reserve(skb
, ETH_HLEN
);
1299 tt_response
= (struct tt_query_packet
*)skb_put(skb
,
1300 sizeof(struct tt_query_packet
) + tt_len
);
1301 tt_response
->ttvn
= req_ttvn
;
1302 tt_response
->tt_data
= htons(tt_tot
);
1304 tt_buff
= skb
->data
+ sizeof(struct tt_query_packet
);
1305 memcpy(tt_buff
, bat_priv
->tt_buff
,
1306 bat_priv
->tt_buff_len
);
1307 spin_unlock_bh(&bat_priv
->tt_buff_lock
);
1309 tt_len
= (uint16_t)atomic_read(&bat_priv
->num_local_tt
) *
1310 sizeof(struct tt_change
);
1311 ttvn
= (uint8_t)atomic_read(&bat_priv
->ttvn
);
1313 skb
= tt_response_fill_table(tt_len
, ttvn
,
1314 bat_priv
->tt_local_hash
,
1315 primary_if
, tt_local_valid_entry
,
1320 tt_response
= (struct tt_query_packet
*)skb
->data
;
1323 tt_response
->packet_type
= BAT_TT_QUERY
;
1324 tt_response
->version
= COMPAT_VERSION
;
1325 tt_response
->ttl
= TTL
;
1326 memcpy(tt_response
->src
, primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
1327 memcpy(tt_response
->dst
, tt_request
->src
, ETH_ALEN
);
1328 tt_response
->flags
= TT_RESPONSE
;
1331 tt_response
->flags
|= TT_FULL_TABLE
;
1333 bat_dbg(DBG_TT
, bat_priv
,
1334 "Sending TT_RESPONSE to %pM via %pM [%c]\n",
1335 orig_node
->orig
, neigh_node
->addr
,
1336 (tt_response
->flags
& TT_FULL_TABLE
? 'F' : '.'));
1338 send_skb_packet(skb
, neigh_node
->if_incoming
, neigh_node
->addr
);
1343 spin_unlock_bh(&bat_priv
->tt_buff_lock
);
1346 orig_node_free_ref(orig_node
);
1348 neigh_node_free_ref(neigh_node
);
1350 hardif_free_ref(primary_if
);
1353 /* This packet was for me, so it doesn't need to be re-routed */
1357 bool send_tt_response(struct bat_priv
*bat_priv
,
1358 struct tt_query_packet
*tt_request
)
1360 if (is_my_mac(tt_request
->dst
))
1361 return send_my_tt_response(bat_priv
, tt_request
);
1363 return send_other_tt_response(bat_priv
, tt_request
);
1366 static void _tt_update_changes(struct bat_priv
*bat_priv
,
1367 struct orig_node
*orig_node
,
1368 struct tt_change
*tt_change
,
1369 uint16_t tt_num_changes
, uint8_t ttvn
)
1373 for (i
= 0; i
< tt_num_changes
; i
++) {
1374 if ((tt_change
+ i
)->flags
& TT_CLIENT_DEL
)
1375 tt_global_del(bat_priv
, orig_node
,
1376 (tt_change
+ i
)->addr
,
1377 "tt removed by changes",
1378 (tt_change
+ i
)->flags
& TT_CLIENT_ROAM
);
1380 if (!tt_global_add(bat_priv
, orig_node
,
1381 (tt_change
+ i
)->addr
, ttvn
, false))
1382 /* In case of problem while storing a
1383 * global_entry, we stop the updating
1384 * procedure without committing the
1385 * ttvn change. This will avoid to send
1386 * corrupted data on tt_request
1392 static void tt_fill_gtable(struct bat_priv
*bat_priv
,
1393 struct tt_query_packet
*tt_response
)
1395 struct orig_node
*orig_node
= NULL
;
1397 orig_node
= orig_hash_find(bat_priv
, tt_response
->src
);
1401 /* Purge the old table first.. */
1402 tt_global_del_orig(bat_priv
, orig_node
, "Received full table");
1404 _tt_update_changes(bat_priv
, orig_node
,
1405 (struct tt_change
*)(tt_response
+ 1),
1406 tt_response
->tt_data
, tt_response
->ttvn
);
1408 spin_lock_bh(&orig_node
->tt_buff_lock
);
1409 kfree(orig_node
->tt_buff
);
1410 orig_node
->tt_buff_len
= 0;
1411 orig_node
->tt_buff
= NULL
;
1412 spin_unlock_bh(&orig_node
->tt_buff_lock
);
1414 atomic_set(&orig_node
->last_ttvn
, tt_response
->ttvn
);
1418 orig_node_free_ref(orig_node
);
1421 void tt_update_changes(struct bat_priv
*bat_priv
, struct orig_node
*orig_node
,
1422 uint16_t tt_num_changes
, uint8_t ttvn
,
1423 struct tt_change
*tt_change
)
1425 _tt_update_changes(bat_priv
, orig_node
, tt_change
, tt_num_changes
,
1428 tt_save_orig_buffer(bat_priv
, orig_node
, (unsigned char *)tt_change
,
1430 atomic_set(&orig_node
->last_ttvn
, ttvn
);
1433 bool is_my_client(struct bat_priv
*bat_priv
, const uint8_t *addr
)
1435 struct tt_local_entry
*tt_local_entry
= NULL
;
1438 tt_local_entry
= tt_local_hash_find(bat_priv
, addr
);
1439 if (!tt_local_entry
)
1441 /* Check if the client has been logically deleted (but is kept for
1442 * consistency purpose) */
1443 if (tt_local_entry
->flags
& TT_CLIENT_PENDING
)
1448 tt_local_entry_free_ref(tt_local_entry
);
1452 void handle_tt_response(struct bat_priv
*bat_priv
,
1453 struct tt_query_packet
*tt_response
)
1455 struct tt_req_node
*node
, *safe
;
1456 struct orig_node
*orig_node
= NULL
;
1458 bat_dbg(DBG_TT
, bat_priv
, "Received TT_RESPONSE from %pM for "
1459 "ttvn %d t_size: %d [%c]\n",
1460 tt_response
->src
, tt_response
->ttvn
,
1461 tt_response
->tt_data
,
1462 (tt_response
->flags
& TT_FULL_TABLE
? 'F' : '.'));
1464 orig_node
= orig_hash_find(bat_priv
, tt_response
->src
);
1468 if (tt_response
->flags
& TT_FULL_TABLE
)
1469 tt_fill_gtable(bat_priv
, tt_response
);
1471 tt_update_changes(bat_priv
, orig_node
, tt_response
->tt_data
,
1473 (struct tt_change
*)(tt_response
+ 1));
1475 /* Delete the tt_req_node from pending tt_requests list */
1476 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
1477 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_req_list
, list
) {
1478 if (!compare_eth(node
->addr
, tt_response
->src
))
1480 list_del(&node
->list
);
1483 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
1485 /* Recalculate the CRC for this orig_node and store it */
1486 orig_node
->tt_crc
= tt_global_crc(bat_priv
, orig_node
);
1487 /* Roaming phase is over: tables are in sync again. I can
1489 orig_node
->tt_poss_change
= false;
1492 orig_node_free_ref(orig_node
);
1495 int tt_init(struct bat_priv
*bat_priv
)
1497 if (!tt_local_init(bat_priv
))
1500 if (!tt_global_init(bat_priv
))
1503 tt_start_timer(bat_priv
);
1508 static void tt_roam_list_free(struct bat_priv
*bat_priv
)
1510 struct tt_roam_node
*node
, *safe
;
1512 spin_lock_bh(&bat_priv
->tt_roam_list_lock
);
1514 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_roam_list
, list
) {
1515 list_del(&node
->list
);
1519 spin_unlock_bh(&bat_priv
->tt_roam_list_lock
);
1522 static void tt_roam_purge(struct bat_priv
*bat_priv
)
1524 struct tt_roam_node
*node
, *safe
;
1526 spin_lock_bh(&bat_priv
->tt_roam_list_lock
);
1527 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_roam_list
, list
) {
1528 if (!is_out_of_time(node
->first_time
,
1529 ROAMING_MAX_TIME
* 1000))
1532 list_del(&node
->list
);
1535 spin_unlock_bh(&bat_priv
->tt_roam_list_lock
);
1538 /* This function checks whether the client already reached the
1539 * maximum number of possible roaming phases. In this case the ROAMING_ADV
1542 * returns true if the ROAMING_ADV can be sent, false otherwise */
1543 static bool tt_check_roam_count(struct bat_priv
*bat_priv
,
1546 struct tt_roam_node
*tt_roam_node
;
1549 spin_lock_bh(&bat_priv
->tt_roam_list_lock
);
1550 /* The new tt_req will be issued only if I'm not waiting for a
1551 * reply from the same orig_node yet */
1552 list_for_each_entry(tt_roam_node
, &bat_priv
->tt_roam_list
, list
) {
1553 if (!compare_eth(tt_roam_node
->addr
, client
))
1556 if (is_out_of_time(tt_roam_node
->first_time
,
1557 ROAMING_MAX_TIME
* 1000))
1560 if (!atomic_dec_not_zero(&tt_roam_node
->counter
))
1561 /* Sorry, you roamed too many times! */
1568 tt_roam_node
= kmalloc(sizeof(*tt_roam_node
), GFP_ATOMIC
);
1572 tt_roam_node
->first_time
= jiffies
;
1573 atomic_set(&tt_roam_node
->counter
, ROAMING_MAX_COUNT
- 1);
1574 memcpy(tt_roam_node
->addr
, client
, ETH_ALEN
);
1576 list_add(&tt_roam_node
->list
, &bat_priv
->tt_roam_list
);
1581 spin_unlock_bh(&bat_priv
->tt_roam_list_lock
);
1585 void send_roam_adv(struct bat_priv
*bat_priv
, uint8_t *client
,
1586 struct orig_node
*orig_node
)
1588 struct neigh_node
*neigh_node
= NULL
;
1589 struct sk_buff
*skb
= NULL
;
1590 struct roam_adv_packet
*roam_adv_packet
;
1592 struct hard_iface
*primary_if
;
1594 /* before going on we have to check whether the client has
1595 * already roamed to us too many times */
1596 if (!tt_check_roam_count(bat_priv
, client
))
1599 skb
= dev_alloc_skb(sizeof(struct roam_adv_packet
) + ETH_HLEN
);
1603 skb_reserve(skb
, ETH_HLEN
);
1605 roam_adv_packet
= (struct roam_adv_packet
*)skb_put(skb
,
1606 sizeof(struct roam_adv_packet
));
1608 roam_adv_packet
->packet_type
= BAT_ROAM_ADV
;
1609 roam_adv_packet
->version
= COMPAT_VERSION
;
1610 roam_adv_packet
->ttl
= TTL
;
1611 primary_if
= primary_if_get_selected(bat_priv
);
1614 memcpy(roam_adv_packet
->src
, primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
1615 hardif_free_ref(primary_if
);
1616 memcpy(roam_adv_packet
->dst
, orig_node
->orig
, ETH_ALEN
);
1617 memcpy(roam_adv_packet
->client
, client
, ETH_ALEN
);
1619 neigh_node
= orig_node_get_router(orig_node
);
1623 bat_dbg(DBG_TT
, bat_priv
,
1624 "Sending ROAMING_ADV to %pM (client %pM) via %pM\n",
1625 orig_node
->orig
, client
, neigh_node
->addr
);
1627 send_skb_packet(skb
, neigh_node
->if_incoming
, neigh_node
->addr
);
1632 neigh_node_free_ref(neigh_node
);
1638 static void tt_purge(struct work_struct
*work
)
1640 struct delayed_work
*delayed_work
=
1641 container_of(work
, struct delayed_work
, work
);
1642 struct bat_priv
*bat_priv
=
1643 container_of(delayed_work
, struct bat_priv
, tt_work
);
1645 tt_local_purge(bat_priv
);
1646 tt_global_roam_purge(bat_priv
);
1647 tt_req_purge(bat_priv
);
1648 tt_roam_purge(bat_priv
);
1650 tt_start_timer(bat_priv
);
1653 void tt_free(struct bat_priv
*bat_priv
)
1655 cancel_delayed_work_sync(&bat_priv
->tt_work
);
1657 tt_local_table_free(bat_priv
);
1658 tt_global_table_free(bat_priv
);
1659 tt_req_list_free(bat_priv
);
1660 tt_changes_list_free(bat_priv
);
1661 tt_roam_list_free(bat_priv
);
1663 kfree(bat_priv
->tt_buff
);
1666 /* This function will reset the specified flags from all the entries in
1667 * the given hash table and will increment num_local_tt for each involved
1669 static void tt_local_reset_flags(struct bat_priv
*bat_priv
, uint16_t flags
)
1672 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
1673 struct hlist_head
*head
;
1674 struct hlist_node
*node
;
1675 struct tt_local_entry
*tt_local_entry
;
1680 for (i
= 0; i
< hash
->size
; i
++) {
1681 head
= &hash
->table
[i
];
1684 hlist_for_each_entry_rcu(tt_local_entry
, node
,
1686 if (!(tt_local_entry
->flags
& flags
))
1688 tt_local_entry
->flags
&= ~flags
;
1689 atomic_inc(&bat_priv
->num_local_tt
);
1696 /* Purge out all the tt local entries marked with TT_CLIENT_PENDING */
1697 static void tt_local_purge_pending_clients(struct bat_priv
*bat_priv
)
1699 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
1700 struct tt_local_entry
*tt_local_entry
;
1701 struct hlist_node
*node
, *node_tmp
;
1702 struct hlist_head
*head
;
1703 spinlock_t
*list_lock
; /* protects write access to the hash lists */
1709 for (i
= 0; i
< hash
->size
; i
++) {
1710 head
= &hash
->table
[i
];
1711 list_lock
= &hash
->list_locks
[i
];
1713 spin_lock_bh(list_lock
);
1714 hlist_for_each_entry_safe(tt_local_entry
, node
, node_tmp
,
1716 if (!(tt_local_entry
->flags
& TT_CLIENT_PENDING
))
1719 bat_dbg(DBG_TT
, bat_priv
, "Deleting local tt entry "
1720 "(%pM): pending\n", tt_local_entry
->addr
);
1722 atomic_dec(&bat_priv
->num_local_tt
);
1723 hlist_del_rcu(node
);
1724 tt_local_entry_free_ref(tt_local_entry
);
1726 spin_unlock_bh(list_lock
);
1731 void tt_commit_changes(struct bat_priv
*bat_priv
)
1733 tt_local_reset_flags(bat_priv
, TT_CLIENT_NEW
);
1734 tt_local_purge_pending_clients(bat_priv
);
1736 /* Increment the TTVN only once per OGM interval */
1737 atomic_inc(&bat_priv
->ttvn
);
1738 bat_priv
->tt_poss_change
= false;