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_ref(struct tt_global_entry
*tt_global_entry
)
142 if (atomic_dec_and_test(&tt_global_entry
->refcount
))
143 kfree_rcu(tt_global_entry
, rcu
);
146 static void tt_local_event(struct bat_priv
*bat_priv
, const uint8_t *addr
,
149 struct tt_change_node
*tt_change_node
;
151 tt_change_node
= kmalloc(sizeof(*tt_change_node
), GFP_ATOMIC
);
156 tt_change_node
->change
.flags
= flags
;
157 memcpy(tt_change_node
->change
.addr
, addr
, ETH_ALEN
);
159 spin_lock_bh(&bat_priv
->tt_changes_list_lock
);
160 /* track the change in the OGMinterval list */
161 list_add_tail(&tt_change_node
->list
, &bat_priv
->tt_changes_list
);
162 atomic_inc(&bat_priv
->tt_local_changes
);
163 spin_unlock_bh(&bat_priv
->tt_changes_list_lock
);
165 atomic_set(&bat_priv
->tt_ogm_append_cnt
, 0);
168 int tt_len(int changes_num
)
170 return changes_num
* sizeof(struct tt_change
);
173 static int tt_local_init(struct bat_priv
*bat_priv
)
175 if (bat_priv
->tt_local_hash
)
178 bat_priv
->tt_local_hash
= hash_new(1024);
180 if (!bat_priv
->tt_local_hash
)
186 void tt_local_add(struct net_device
*soft_iface
, const uint8_t *addr
,
189 struct bat_priv
*bat_priv
= netdev_priv(soft_iface
);
190 struct tt_local_entry
*tt_local_entry
= NULL
;
191 struct tt_global_entry
*tt_global_entry
= NULL
;
193 tt_local_entry
= tt_local_hash_find(bat_priv
, addr
);
195 if (tt_local_entry
) {
196 tt_local_entry
->last_seen
= jiffies
;
200 tt_local_entry
= kmalloc(sizeof(*tt_local_entry
), GFP_ATOMIC
);
204 bat_dbg(DBG_TT
, bat_priv
,
205 "Creating new local tt entry: %pM (ttvn: %d)\n", addr
,
206 (uint8_t)atomic_read(&bat_priv
->ttvn
));
208 memcpy(tt_local_entry
->addr
, addr
, ETH_ALEN
);
209 tt_local_entry
->last_seen
= jiffies
;
210 tt_local_entry
->flags
= NO_FLAGS
;
211 if (is_wifi_iface(ifindex
))
212 tt_local_entry
->flags
|= TT_CLIENT_WIFI
;
213 atomic_set(&tt_local_entry
->refcount
, 2);
215 /* the batman interface mac address should never be purged */
216 if (compare_eth(addr
, soft_iface
->dev_addr
))
217 tt_local_entry
->flags
|= TT_CLIENT_NOPURGE
;
219 tt_local_event(bat_priv
, addr
, tt_local_entry
->flags
);
221 /* The local entry has to be marked as NEW to avoid to send it in
222 * a full table response going out before the next ttvn increment
223 * (consistency check) */
224 tt_local_entry
->flags
|= TT_CLIENT_NEW
;
226 hash_add(bat_priv
->tt_local_hash
, compare_ltt
, choose_orig
,
227 tt_local_entry
, &tt_local_entry
->hash_entry
);
229 /* remove address from global hash if present */
230 tt_global_entry
= tt_global_hash_find(bat_priv
, addr
);
232 /* Check whether it is a roaming! */
233 if (tt_global_entry
) {
234 /* This node is probably going to update its tt table */
235 tt_global_entry
->orig_node
->tt_poss_change
= true;
236 /* The global entry has to be marked as PENDING and has to be
237 * kept for consistency purpose */
238 tt_global_entry
->flags
|= TT_CLIENT_PENDING
;
239 send_roam_adv(bat_priv
, tt_global_entry
->addr
,
240 tt_global_entry
->orig_node
);
244 tt_local_entry_free_ref(tt_local_entry
);
246 tt_global_entry_free_ref(tt_global_entry
);
249 int tt_changes_fill_buffer(struct bat_priv
*bat_priv
,
250 unsigned char *buff
, int buff_len
)
252 int count
= 0, tot_changes
= 0;
253 struct tt_change_node
*entry
, *safe
;
256 tot_changes
= buff_len
/ tt_len(1);
258 spin_lock_bh(&bat_priv
->tt_changes_list_lock
);
259 atomic_set(&bat_priv
->tt_local_changes
, 0);
261 list_for_each_entry_safe(entry
, safe
, &bat_priv
->tt_changes_list
,
263 if (count
< tot_changes
) {
264 memcpy(buff
+ tt_len(count
),
265 &entry
->change
, sizeof(struct tt_change
));
268 list_del(&entry
->list
);
271 spin_unlock_bh(&bat_priv
->tt_changes_list_lock
);
273 /* Keep the buffer for possible tt_request */
274 spin_lock_bh(&bat_priv
->tt_buff_lock
);
275 kfree(bat_priv
->tt_buff
);
276 bat_priv
->tt_buff_len
= 0;
277 bat_priv
->tt_buff
= NULL
;
278 /* We check whether this new OGM has no changes due to size
282 * if kmalloc() fails we will reply with the full table
283 * instead of providing the diff
285 bat_priv
->tt_buff
= kmalloc(buff_len
, GFP_ATOMIC
);
286 if (bat_priv
->tt_buff
) {
287 memcpy(bat_priv
->tt_buff
, buff
, buff_len
);
288 bat_priv
->tt_buff_len
= buff_len
;
291 spin_unlock_bh(&bat_priv
->tt_buff_lock
);
296 int tt_local_seq_print_text(struct seq_file
*seq
, void *offset
)
298 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
299 struct bat_priv
*bat_priv
= netdev_priv(net_dev
);
300 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
301 struct tt_local_entry
*tt_local_entry
;
302 struct hard_iface
*primary_if
;
303 struct hlist_node
*node
;
304 struct hlist_head
*head
;
305 size_t buf_size
, pos
;
309 primary_if
= primary_if_get_selected(bat_priv
);
311 ret
= seq_printf(seq
, "BATMAN mesh %s disabled - "
312 "please specify interfaces to enable it\n",
317 if (primary_if
->if_status
!= IF_ACTIVE
) {
318 ret
= seq_printf(seq
, "BATMAN mesh %s disabled - "
319 "primary interface not active\n",
324 seq_printf(seq
, "Locally retrieved addresses (from %s) "
325 "announced via TT (TTVN: %u):\n",
326 net_dev
->name
, (uint8_t)atomic_read(&bat_priv
->ttvn
));
329 /* Estimate length for: " * xx:xx:xx:xx:xx:xx\n" */
330 for (i
= 0; i
< hash
->size
; i
++) {
331 head
= &hash
->table
[i
];
334 __hlist_for_each_rcu(node
, head
)
339 buff
= kmalloc(buf_size
, GFP_ATOMIC
);
348 for (i
= 0; i
< hash
->size
; i
++) {
349 head
= &hash
->table
[i
];
352 hlist_for_each_entry_rcu(tt_local_entry
, node
,
354 pos
+= snprintf(buff
+ pos
, 22, " * %pM\n",
355 tt_local_entry
->addr
);
360 seq_printf(seq
, "%s", buff
);
364 hardif_free_ref(primary_if
);
368 static void tt_local_set_pending(struct bat_priv
*bat_priv
,
369 struct tt_local_entry
*tt_local_entry
,
372 tt_local_event(bat_priv
, tt_local_entry
->addr
,
373 tt_local_entry
->flags
| flags
);
375 /* The local client has to be marked as "pending to be removed" but has
376 * to be kept in the table in order to send it in a full table
377 * response issued before the net ttvn increment (consistency check) */
378 tt_local_entry
->flags
|= TT_CLIENT_PENDING
;
381 void tt_local_remove(struct bat_priv
*bat_priv
, const uint8_t *addr
,
382 const char *message
, bool roaming
)
384 struct tt_local_entry
*tt_local_entry
= NULL
;
386 tt_local_entry
= tt_local_hash_find(bat_priv
, addr
);
390 tt_local_set_pending(bat_priv
, tt_local_entry
, TT_CLIENT_DEL
|
391 (roaming
? TT_CLIENT_ROAM
: NO_FLAGS
));
393 bat_dbg(DBG_TT
, bat_priv
, "Local tt entry (%pM) pending to be removed: "
394 "%s\n", tt_local_entry
->addr
, message
);
397 tt_local_entry_free_ref(tt_local_entry
);
400 static void tt_local_purge(struct bat_priv
*bat_priv
)
402 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
403 struct tt_local_entry
*tt_local_entry
;
404 struct hlist_node
*node
, *node_tmp
;
405 struct hlist_head
*head
;
406 spinlock_t
*list_lock
; /* protects write access to the hash lists */
409 for (i
= 0; i
< hash
->size
; i
++) {
410 head
= &hash
->table
[i
];
411 list_lock
= &hash
->list_locks
[i
];
413 spin_lock_bh(list_lock
);
414 hlist_for_each_entry_safe(tt_local_entry
, node
, node_tmp
,
416 if (tt_local_entry
->flags
& TT_CLIENT_NOPURGE
)
419 /* entry already marked for deletion */
420 if (tt_local_entry
->flags
& TT_CLIENT_PENDING
)
423 if (!is_out_of_time(tt_local_entry
->last_seen
,
424 TT_LOCAL_TIMEOUT
* 1000))
427 tt_local_set_pending(bat_priv
, tt_local_entry
,
429 bat_dbg(DBG_TT
, bat_priv
, "Local tt entry (%pM) "
430 "pending to be removed: timed out\n",
431 tt_local_entry
->addr
);
433 spin_unlock_bh(list_lock
);
438 static void tt_local_table_free(struct bat_priv
*bat_priv
)
440 struct hashtable_t
*hash
;
441 spinlock_t
*list_lock
; /* protects write access to the hash lists */
442 struct tt_local_entry
*tt_local_entry
;
443 struct hlist_node
*node
, *node_tmp
;
444 struct hlist_head
*head
;
447 if (!bat_priv
->tt_local_hash
)
450 hash
= bat_priv
->tt_local_hash
;
452 for (i
= 0; i
< hash
->size
; i
++) {
453 head
= &hash
->table
[i
];
454 list_lock
= &hash
->list_locks
[i
];
456 spin_lock_bh(list_lock
);
457 hlist_for_each_entry_safe(tt_local_entry
, node
, node_tmp
,
460 tt_local_entry_free_ref(tt_local_entry
);
462 spin_unlock_bh(list_lock
);
467 bat_priv
->tt_local_hash
= NULL
;
470 static int tt_global_init(struct bat_priv
*bat_priv
)
472 if (bat_priv
->tt_global_hash
)
475 bat_priv
->tt_global_hash
= hash_new(1024);
477 if (!bat_priv
->tt_global_hash
)
483 static void tt_changes_list_free(struct bat_priv
*bat_priv
)
485 struct tt_change_node
*entry
, *safe
;
487 spin_lock_bh(&bat_priv
->tt_changes_list_lock
);
489 list_for_each_entry_safe(entry
, safe
, &bat_priv
->tt_changes_list
,
491 list_del(&entry
->list
);
495 atomic_set(&bat_priv
->tt_local_changes
, 0);
496 spin_unlock_bh(&bat_priv
->tt_changes_list_lock
);
499 /* caller must hold orig_node refcount */
500 int tt_global_add(struct bat_priv
*bat_priv
, struct orig_node
*orig_node
,
501 const unsigned char *tt_addr
, uint8_t ttvn
, bool roaming
,
504 struct tt_global_entry
*tt_global_entry
;
505 struct orig_node
*orig_node_tmp
;
508 tt_global_entry
= tt_global_hash_find(bat_priv
, tt_addr
);
510 if (!tt_global_entry
) {
512 kmalloc(sizeof(*tt_global_entry
),
514 if (!tt_global_entry
)
517 memcpy(tt_global_entry
->addr
, tt_addr
, ETH_ALEN
);
518 /* Assign the new orig_node */
519 atomic_inc(&orig_node
->refcount
);
520 tt_global_entry
->orig_node
= orig_node
;
521 tt_global_entry
->ttvn
= ttvn
;
522 tt_global_entry
->flags
= NO_FLAGS
;
523 tt_global_entry
->roam_at
= 0;
524 atomic_set(&tt_global_entry
->refcount
, 2);
526 hash_add(bat_priv
->tt_global_hash
, compare_gtt
,
527 choose_orig
, tt_global_entry
,
528 &tt_global_entry
->hash_entry
);
529 atomic_inc(&orig_node
->tt_size
);
531 if (tt_global_entry
->orig_node
!= orig_node
) {
532 atomic_dec(&tt_global_entry
->orig_node
->tt_size
);
533 orig_node_tmp
= tt_global_entry
->orig_node
;
534 atomic_inc(&orig_node
->refcount
);
535 tt_global_entry
->orig_node
= orig_node
;
536 orig_node_free_ref(orig_node_tmp
);
537 atomic_inc(&orig_node
->tt_size
);
539 tt_global_entry
->ttvn
= ttvn
;
540 tt_global_entry
->flags
= NO_FLAGS
;
541 tt_global_entry
->roam_at
= 0;
545 tt_global_entry
->flags
|= TT_CLIENT_WIFI
;
547 bat_dbg(DBG_TT
, bat_priv
,
548 "Creating new global tt entry: %pM (via %pM)\n",
549 tt_global_entry
->addr
, orig_node
->orig
);
551 /* remove address from local hash if present */
552 tt_local_remove(bat_priv
, tt_global_entry
->addr
,
553 "global tt received", roaming
);
557 tt_global_entry_free_ref(tt_global_entry
);
561 int tt_global_seq_print_text(struct seq_file
*seq
, void *offset
)
563 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
564 struct bat_priv
*bat_priv
= netdev_priv(net_dev
);
565 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
566 struct tt_global_entry
*tt_global_entry
;
567 struct hard_iface
*primary_if
;
568 struct hlist_node
*node
;
569 struct hlist_head
*head
;
570 size_t buf_size
, pos
;
574 primary_if
= primary_if_get_selected(bat_priv
);
576 ret
= seq_printf(seq
, "BATMAN mesh %s disabled - please "
577 "specify interfaces to enable it\n",
582 if (primary_if
->if_status
!= IF_ACTIVE
) {
583 ret
= seq_printf(seq
, "BATMAN mesh %s disabled - "
584 "primary interface not active\n",
590 "Globally announced TT entries received via the mesh %s\n",
592 seq_printf(seq
, " %-13s %s %-15s %s\n",
593 "Client", "(TTVN)", "Originator", "(Curr TTVN)");
596 /* Estimate length for: " * xx:xx:xx:xx:xx:xx (ttvn) via
597 * xx:xx:xx:xx:xx:xx (cur_ttvn)\n"*/
598 for (i
= 0; i
< hash
->size
; i
++) {
599 head
= &hash
->table
[i
];
602 __hlist_for_each_rcu(node
, head
)
607 buff
= kmalloc(buf_size
, GFP_ATOMIC
);
616 for (i
= 0; i
< hash
->size
; i
++) {
617 head
= &hash
->table
[i
];
620 hlist_for_each_entry_rcu(tt_global_entry
, node
,
622 pos
+= snprintf(buff
+ pos
, 61,
623 " * %pM (%3u) via %pM (%3u)\n",
624 tt_global_entry
->addr
,
625 tt_global_entry
->ttvn
,
626 tt_global_entry
->orig_node
->orig
,
627 (uint8_t) atomic_read(
628 &tt_global_entry
->orig_node
->
634 seq_printf(seq
, "%s", buff
);
638 hardif_free_ref(primary_if
);
642 static void _tt_global_del(struct bat_priv
*bat_priv
,
643 struct tt_global_entry
*tt_global_entry
,
646 if (!tt_global_entry
)
649 bat_dbg(DBG_TT
, bat_priv
,
650 "Deleting global tt entry %pM (via %pM): %s\n",
651 tt_global_entry
->addr
, tt_global_entry
->orig_node
->orig
,
654 atomic_dec(&tt_global_entry
->orig_node
->tt_size
);
656 hash_remove(bat_priv
->tt_global_hash
, compare_gtt
, choose_orig
,
657 tt_global_entry
->addr
);
660 tt_global_entry_free_ref(tt_global_entry
);
663 void tt_global_del(struct bat_priv
*bat_priv
,
664 struct orig_node
*orig_node
, const unsigned char *addr
,
665 const char *message
, bool roaming
)
667 struct tt_global_entry
*tt_global_entry
= NULL
;
669 tt_global_entry
= tt_global_hash_find(bat_priv
, addr
);
670 if (!tt_global_entry
)
673 if (tt_global_entry
->orig_node
== orig_node
) {
675 tt_global_entry
->flags
|= TT_CLIENT_ROAM
;
676 tt_global_entry
->roam_at
= jiffies
;
679 _tt_global_del(bat_priv
, tt_global_entry
, message
);
683 tt_global_entry_free_ref(tt_global_entry
);
686 void tt_global_del_orig(struct bat_priv
*bat_priv
,
687 struct orig_node
*orig_node
, const char *message
)
689 struct tt_global_entry
*tt_global_entry
;
691 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
692 struct hlist_node
*node
, *safe
;
693 struct hlist_head
*head
;
694 spinlock_t
*list_lock
; /* protects write access to the hash lists */
696 for (i
= 0; i
< hash
->size
; i
++) {
697 head
= &hash
->table
[i
];
698 list_lock
= &hash
->list_locks
[i
];
700 spin_lock_bh(list_lock
);
701 hlist_for_each_entry_safe(tt_global_entry
, node
, safe
,
703 if (tt_global_entry
->orig_node
== orig_node
) {
704 bat_dbg(DBG_TT
, bat_priv
,
705 "Deleting global tt entry %pM "
706 "(via %pM): originator time out\n",
707 tt_global_entry
->addr
,
708 tt_global_entry
->orig_node
->orig
);
710 tt_global_entry_free_ref(tt_global_entry
);
713 spin_unlock_bh(list_lock
);
715 atomic_set(&orig_node
->tt_size
, 0);
718 static void tt_global_roam_purge(struct bat_priv
*bat_priv
)
720 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
721 struct tt_global_entry
*tt_global_entry
;
722 struct hlist_node
*node
, *node_tmp
;
723 struct hlist_head
*head
;
724 spinlock_t
*list_lock
; /* protects write access to the hash lists */
727 for (i
= 0; i
< hash
->size
; i
++) {
728 head
= &hash
->table
[i
];
729 list_lock
= &hash
->list_locks
[i
];
731 spin_lock_bh(list_lock
);
732 hlist_for_each_entry_safe(tt_global_entry
, node
, node_tmp
,
734 if (!(tt_global_entry
->flags
& TT_CLIENT_ROAM
))
736 if (!is_out_of_time(tt_global_entry
->roam_at
,
737 TT_CLIENT_ROAM_TIMEOUT
* 1000))
740 bat_dbg(DBG_TT
, bat_priv
, "Deleting global "
741 "tt entry (%pM): Roaming timeout\n",
742 tt_global_entry
->addr
);
743 atomic_dec(&tt_global_entry
->orig_node
->tt_size
);
745 tt_global_entry_free_ref(tt_global_entry
);
747 spin_unlock_bh(list_lock
);
752 static void tt_global_table_free(struct bat_priv
*bat_priv
)
754 struct hashtable_t
*hash
;
755 spinlock_t
*list_lock
; /* protects write access to the hash lists */
756 struct tt_global_entry
*tt_global_entry
;
757 struct hlist_node
*node
, *node_tmp
;
758 struct hlist_head
*head
;
761 if (!bat_priv
->tt_global_hash
)
764 hash
= bat_priv
->tt_global_hash
;
766 for (i
= 0; i
< hash
->size
; i
++) {
767 head
= &hash
->table
[i
];
768 list_lock
= &hash
->list_locks
[i
];
770 spin_lock_bh(list_lock
);
771 hlist_for_each_entry_safe(tt_global_entry
, node
, node_tmp
,
774 tt_global_entry_free_ref(tt_global_entry
);
776 spin_unlock_bh(list_lock
);
781 bat_priv
->tt_global_hash
= NULL
;
784 struct orig_node
*transtable_search(struct bat_priv
*bat_priv
,
787 struct tt_global_entry
*tt_global_entry
;
788 struct orig_node
*orig_node
= NULL
;
790 tt_global_entry
= tt_global_hash_find(bat_priv
, addr
);
792 if (!tt_global_entry
)
795 if (!atomic_inc_not_zero(&tt_global_entry
->orig_node
->refcount
))
798 /* A global client marked as PENDING has already moved from that
800 if (tt_global_entry
->flags
& TT_CLIENT_PENDING
)
803 orig_node
= tt_global_entry
->orig_node
;
806 tt_global_entry_free_ref(tt_global_entry
);
811 /* Calculates the checksum of the local table of a given orig_node */
812 uint16_t tt_global_crc(struct bat_priv
*bat_priv
, struct orig_node
*orig_node
)
814 uint16_t total
= 0, total_one
;
815 struct hashtable_t
*hash
= bat_priv
->tt_global_hash
;
816 struct tt_global_entry
*tt_global_entry
;
817 struct hlist_node
*node
;
818 struct hlist_head
*head
;
821 for (i
= 0; i
< hash
->size
; i
++) {
822 head
= &hash
->table
[i
];
825 hlist_for_each_entry_rcu(tt_global_entry
, node
,
827 if (compare_eth(tt_global_entry
->orig_node
,
829 /* Roaming clients are in the global table for
830 * consistency only. They don't have to be
831 * taken into account while computing the
833 if (tt_global_entry
->flags
& TT_CLIENT_ROAM
)
836 for (j
= 0; j
< ETH_ALEN
; j
++)
837 total_one
= crc16_byte(total_one
,
838 tt_global_entry
->addr
[j
]);
848 /* Calculates the checksum of the local table */
849 uint16_t tt_local_crc(struct bat_priv
*bat_priv
)
851 uint16_t total
= 0, total_one
;
852 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
853 struct tt_local_entry
*tt_local_entry
;
854 struct hlist_node
*node
;
855 struct hlist_head
*head
;
858 for (i
= 0; i
< hash
->size
; i
++) {
859 head
= &hash
->table
[i
];
862 hlist_for_each_entry_rcu(tt_local_entry
, node
,
864 /* not yet committed clients have not to be taken into
865 * account while computing the CRC */
866 if (tt_local_entry
->flags
& TT_CLIENT_NEW
)
869 for (j
= 0; j
< ETH_ALEN
; j
++)
870 total_one
= crc16_byte(total_one
,
871 tt_local_entry
->addr
[j
]);
880 static void tt_req_list_free(struct bat_priv
*bat_priv
)
882 struct tt_req_node
*node
, *safe
;
884 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
886 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_req_list
, list
) {
887 list_del(&node
->list
);
891 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
894 void tt_save_orig_buffer(struct bat_priv
*bat_priv
, struct orig_node
*orig_node
,
895 const unsigned char *tt_buff
, uint8_t tt_num_changes
)
897 uint16_t tt_buff_len
= tt_len(tt_num_changes
);
899 /* Replace the old buffer only if I received something in the
900 * last OGM (the OGM could carry no changes) */
901 spin_lock_bh(&orig_node
->tt_buff_lock
);
902 if (tt_buff_len
> 0) {
903 kfree(orig_node
->tt_buff
);
904 orig_node
->tt_buff_len
= 0;
905 orig_node
->tt_buff
= kmalloc(tt_buff_len
, GFP_ATOMIC
);
906 if (orig_node
->tt_buff
) {
907 memcpy(orig_node
->tt_buff
, tt_buff
, tt_buff_len
);
908 orig_node
->tt_buff_len
= tt_buff_len
;
911 spin_unlock_bh(&orig_node
->tt_buff_lock
);
914 static void tt_req_purge(struct bat_priv
*bat_priv
)
916 struct tt_req_node
*node
, *safe
;
918 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
919 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_req_list
, list
) {
920 if (is_out_of_time(node
->issued_at
,
921 TT_REQUEST_TIMEOUT
* 1000)) {
922 list_del(&node
->list
);
926 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
929 /* returns the pointer to the new tt_req_node struct if no request
930 * has already been issued for this orig_node, NULL otherwise */
931 static struct tt_req_node
*new_tt_req_node(struct bat_priv
*bat_priv
,
932 struct orig_node
*orig_node
)
934 struct tt_req_node
*tt_req_node_tmp
, *tt_req_node
= NULL
;
936 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
937 list_for_each_entry(tt_req_node_tmp
, &bat_priv
->tt_req_list
, list
) {
938 if (compare_eth(tt_req_node_tmp
, orig_node
) &&
939 !is_out_of_time(tt_req_node_tmp
->issued_at
,
940 TT_REQUEST_TIMEOUT
* 1000))
944 tt_req_node
= kmalloc(sizeof(*tt_req_node
), GFP_ATOMIC
);
948 memcpy(tt_req_node
->addr
, orig_node
->orig
, ETH_ALEN
);
949 tt_req_node
->issued_at
= jiffies
;
951 list_add(&tt_req_node
->list
, &bat_priv
->tt_req_list
);
953 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
957 /* data_ptr is useless here, but has to be kept to respect the prototype */
958 static int tt_local_valid_entry(const void *entry_ptr
, const void *data_ptr
)
960 const struct tt_local_entry
*tt_local_entry
= entry_ptr
;
962 if (tt_local_entry
->flags
& TT_CLIENT_NEW
)
967 static int tt_global_valid_entry(const void *entry_ptr
, const void *data_ptr
)
969 const struct tt_global_entry
*tt_global_entry
= entry_ptr
;
970 const struct orig_node
*orig_node
= data_ptr
;
972 if (tt_global_entry
->flags
& TT_CLIENT_ROAM
)
975 return (tt_global_entry
->orig_node
== orig_node
);
978 static struct sk_buff
*tt_response_fill_table(uint16_t tt_len
, uint8_t ttvn
,
979 struct hashtable_t
*hash
,
980 struct hard_iface
*primary_if
,
981 int (*valid_cb
)(const void *,
985 struct tt_local_entry
*tt_local_entry
;
986 struct tt_query_packet
*tt_response
;
987 struct tt_change
*tt_change
;
988 struct hlist_node
*node
;
989 struct hlist_head
*head
;
990 struct sk_buff
*skb
= NULL
;
991 uint16_t tt_tot
, tt_count
;
992 ssize_t tt_query_size
= sizeof(struct tt_query_packet
);
995 if (tt_query_size
+ tt_len
> primary_if
->soft_iface
->mtu
) {
996 tt_len
= primary_if
->soft_iface
->mtu
- tt_query_size
;
997 tt_len
-= tt_len
% sizeof(struct tt_change
);
999 tt_tot
= tt_len
/ sizeof(struct tt_change
);
1001 skb
= dev_alloc_skb(tt_query_size
+ tt_len
+ ETH_HLEN
);
1005 skb_reserve(skb
, ETH_HLEN
);
1006 tt_response
= (struct tt_query_packet
*)skb_put(skb
,
1007 tt_query_size
+ tt_len
);
1008 tt_response
->ttvn
= ttvn
;
1009 tt_response
->tt_data
= htons(tt_tot
);
1011 tt_change
= (struct tt_change
*)(skb
->data
+ tt_query_size
);
1015 for (i
= 0; i
< hash
->size
; i
++) {
1016 head
= &hash
->table
[i
];
1018 hlist_for_each_entry_rcu(tt_local_entry
, node
,
1020 if (tt_count
== tt_tot
)
1023 if ((valid_cb
) && (!valid_cb(tt_local_entry
, cb_data
)))
1026 memcpy(tt_change
->addr
, tt_local_entry
->addr
, ETH_ALEN
);
1027 tt_change
->flags
= NO_FLAGS
;
1039 int send_tt_request(struct bat_priv
*bat_priv
, struct orig_node
*dst_orig_node
,
1040 uint8_t ttvn
, uint16_t tt_crc
, bool full_table
)
1042 struct sk_buff
*skb
= NULL
;
1043 struct tt_query_packet
*tt_request
;
1044 struct neigh_node
*neigh_node
= NULL
;
1045 struct hard_iface
*primary_if
;
1046 struct tt_req_node
*tt_req_node
= NULL
;
1049 primary_if
= primary_if_get_selected(bat_priv
);
1053 /* The new tt_req will be issued only if I'm not waiting for a
1054 * reply from the same orig_node yet */
1055 tt_req_node
= new_tt_req_node(bat_priv
, dst_orig_node
);
1059 skb
= dev_alloc_skb(sizeof(struct tt_query_packet
) + ETH_HLEN
);
1063 skb_reserve(skb
, ETH_HLEN
);
1065 tt_request
= (struct tt_query_packet
*)skb_put(skb
,
1066 sizeof(struct tt_query_packet
));
1068 tt_request
->packet_type
= BAT_TT_QUERY
;
1069 tt_request
->version
= COMPAT_VERSION
;
1070 memcpy(tt_request
->src
, primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
1071 memcpy(tt_request
->dst
, dst_orig_node
->orig
, ETH_ALEN
);
1072 tt_request
->ttl
= TTL
;
1073 tt_request
->ttvn
= ttvn
;
1074 tt_request
->tt_data
= tt_crc
;
1075 tt_request
->flags
= TT_REQUEST
;
1078 tt_request
->flags
|= TT_FULL_TABLE
;
1080 neigh_node
= orig_node_get_router(dst_orig_node
);
1084 bat_dbg(DBG_TT
, bat_priv
, "Sending TT_REQUEST to %pM via %pM "
1085 "[%c]\n", dst_orig_node
->orig
, neigh_node
->addr
,
1086 (full_table
? 'F' : '.'));
1088 send_skb_packet(skb
, neigh_node
->if_incoming
, neigh_node
->addr
);
1093 neigh_node_free_ref(neigh_node
);
1095 hardif_free_ref(primary_if
);
1098 if (ret
&& tt_req_node
) {
1099 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
1100 list_del(&tt_req_node
->list
);
1101 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
1107 static bool send_other_tt_response(struct bat_priv
*bat_priv
,
1108 struct tt_query_packet
*tt_request
)
1110 struct orig_node
*req_dst_orig_node
= NULL
, *res_dst_orig_node
= NULL
;
1111 struct neigh_node
*neigh_node
= NULL
;
1112 struct hard_iface
*primary_if
= NULL
;
1113 uint8_t orig_ttvn
, req_ttvn
, ttvn
;
1115 unsigned char *tt_buff
;
1117 uint16_t tt_len
, tt_tot
;
1118 struct sk_buff
*skb
= NULL
;
1119 struct tt_query_packet
*tt_response
;
1121 bat_dbg(DBG_TT
, bat_priv
,
1122 "Received TT_REQUEST from %pM for "
1123 "ttvn: %u (%pM) [%c]\n", tt_request
->src
,
1124 tt_request
->ttvn
, tt_request
->dst
,
1125 (tt_request
->flags
& TT_FULL_TABLE
? 'F' : '.'));
1127 /* Let's get the orig node of the REAL destination */
1128 req_dst_orig_node
= get_orig_node(bat_priv
, tt_request
->dst
);
1129 if (!req_dst_orig_node
)
1132 res_dst_orig_node
= get_orig_node(bat_priv
, tt_request
->src
);
1133 if (!res_dst_orig_node
)
1136 neigh_node
= orig_node_get_router(res_dst_orig_node
);
1140 primary_if
= primary_if_get_selected(bat_priv
);
1144 orig_ttvn
= (uint8_t)atomic_read(&req_dst_orig_node
->last_ttvn
);
1145 req_ttvn
= tt_request
->ttvn
;
1147 /* I don't have the requested data */
1148 if (orig_ttvn
!= req_ttvn
||
1149 tt_request
->tt_data
!= req_dst_orig_node
->tt_crc
)
1152 /* If the full table has been explicitly requested */
1153 if (tt_request
->flags
& TT_FULL_TABLE
||
1154 !req_dst_orig_node
->tt_buff
)
1159 /* In this version, fragmentation is not implemented, then
1160 * I'll send only one packet with as much TT entries as I can */
1162 spin_lock_bh(&req_dst_orig_node
->tt_buff_lock
);
1163 tt_len
= req_dst_orig_node
->tt_buff_len
;
1164 tt_tot
= tt_len
/ sizeof(struct tt_change
);
1166 skb
= dev_alloc_skb(sizeof(struct tt_query_packet
) +
1171 skb_reserve(skb
, ETH_HLEN
);
1172 tt_response
= (struct tt_query_packet
*)skb_put(skb
,
1173 sizeof(struct tt_query_packet
) + tt_len
);
1174 tt_response
->ttvn
= req_ttvn
;
1175 tt_response
->tt_data
= htons(tt_tot
);
1177 tt_buff
= skb
->data
+ sizeof(struct tt_query_packet
);
1178 /* Copy the last orig_node's OGM buffer */
1179 memcpy(tt_buff
, req_dst_orig_node
->tt_buff
,
1180 req_dst_orig_node
->tt_buff_len
);
1182 spin_unlock_bh(&req_dst_orig_node
->tt_buff_lock
);
1184 tt_len
= (uint16_t)atomic_read(&req_dst_orig_node
->tt_size
) *
1185 sizeof(struct tt_change
);
1186 ttvn
= (uint8_t)atomic_read(&req_dst_orig_node
->last_ttvn
);
1188 skb
= tt_response_fill_table(tt_len
, ttvn
,
1189 bat_priv
->tt_global_hash
,
1190 primary_if
, tt_global_valid_entry
,
1195 tt_response
= (struct tt_query_packet
*)skb
->data
;
1198 tt_response
->packet_type
= BAT_TT_QUERY
;
1199 tt_response
->version
= COMPAT_VERSION
;
1200 tt_response
->ttl
= TTL
;
1201 memcpy(tt_response
->src
, req_dst_orig_node
->orig
, ETH_ALEN
);
1202 memcpy(tt_response
->dst
, tt_request
->src
, ETH_ALEN
);
1203 tt_response
->flags
= TT_RESPONSE
;
1206 tt_response
->flags
|= TT_FULL_TABLE
;
1208 bat_dbg(DBG_TT
, bat_priv
,
1209 "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n",
1210 res_dst_orig_node
->orig
, neigh_node
->addr
,
1211 req_dst_orig_node
->orig
, req_ttvn
);
1213 send_skb_packet(skb
, neigh_node
->if_incoming
, neigh_node
->addr
);
1218 spin_unlock_bh(&req_dst_orig_node
->tt_buff_lock
);
1221 if (res_dst_orig_node
)
1222 orig_node_free_ref(res_dst_orig_node
);
1223 if (req_dst_orig_node
)
1224 orig_node_free_ref(req_dst_orig_node
);
1226 neigh_node_free_ref(neigh_node
);
1228 hardif_free_ref(primary_if
);
1234 static bool send_my_tt_response(struct bat_priv
*bat_priv
,
1235 struct tt_query_packet
*tt_request
)
1237 struct orig_node
*orig_node
= NULL
;
1238 struct neigh_node
*neigh_node
= NULL
;
1239 struct hard_iface
*primary_if
= NULL
;
1240 uint8_t my_ttvn
, req_ttvn
, ttvn
;
1242 unsigned char *tt_buff
;
1244 uint16_t tt_len
, tt_tot
;
1245 struct sk_buff
*skb
= NULL
;
1246 struct tt_query_packet
*tt_response
;
1248 bat_dbg(DBG_TT
, bat_priv
,
1249 "Received TT_REQUEST from %pM for "
1250 "ttvn: %u (me) [%c]\n", tt_request
->src
,
1252 (tt_request
->flags
& TT_FULL_TABLE
? 'F' : '.'));
1255 my_ttvn
= (uint8_t)atomic_read(&bat_priv
->ttvn
);
1256 req_ttvn
= tt_request
->ttvn
;
1258 orig_node
= get_orig_node(bat_priv
, tt_request
->src
);
1262 neigh_node
= orig_node_get_router(orig_node
);
1266 primary_if
= primary_if_get_selected(bat_priv
);
1270 /* If the full table has been explicitly requested or the gap
1271 * is too big send the whole local translation table */
1272 if (tt_request
->flags
& TT_FULL_TABLE
|| my_ttvn
!= req_ttvn
||
1278 /* In this version, fragmentation is not implemented, then
1279 * I'll send only one packet with as much TT entries as I can */
1281 spin_lock_bh(&bat_priv
->tt_buff_lock
);
1282 tt_len
= bat_priv
->tt_buff_len
;
1283 tt_tot
= tt_len
/ sizeof(struct tt_change
);
1285 skb
= dev_alloc_skb(sizeof(struct tt_query_packet
) +
1290 skb_reserve(skb
, ETH_HLEN
);
1291 tt_response
= (struct tt_query_packet
*)skb_put(skb
,
1292 sizeof(struct tt_query_packet
) + tt_len
);
1293 tt_response
->ttvn
= req_ttvn
;
1294 tt_response
->tt_data
= htons(tt_tot
);
1296 tt_buff
= skb
->data
+ sizeof(struct tt_query_packet
);
1297 memcpy(tt_buff
, bat_priv
->tt_buff
,
1298 bat_priv
->tt_buff_len
);
1299 spin_unlock_bh(&bat_priv
->tt_buff_lock
);
1301 tt_len
= (uint16_t)atomic_read(&bat_priv
->num_local_tt
) *
1302 sizeof(struct tt_change
);
1303 ttvn
= (uint8_t)atomic_read(&bat_priv
->ttvn
);
1305 skb
= tt_response_fill_table(tt_len
, ttvn
,
1306 bat_priv
->tt_local_hash
,
1307 primary_if
, tt_local_valid_entry
,
1312 tt_response
= (struct tt_query_packet
*)skb
->data
;
1315 tt_response
->packet_type
= BAT_TT_QUERY
;
1316 tt_response
->version
= COMPAT_VERSION
;
1317 tt_response
->ttl
= TTL
;
1318 memcpy(tt_response
->src
, primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
1319 memcpy(tt_response
->dst
, tt_request
->src
, ETH_ALEN
);
1320 tt_response
->flags
= TT_RESPONSE
;
1323 tt_response
->flags
|= TT_FULL_TABLE
;
1325 bat_dbg(DBG_TT
, bat_priv
,
1326 "Sending TT_RESPONSE to %pM via %pM [%c]\n",
1327 orig_node
->orig
, neigh_node
->addr
,
1328 (tt_response
->flags
& TT_FULL_TABLE
? 'F' : '.'));
1330 send_skb_packet(skb
, neigh_node
->if_incoming
, neigh_node
->addr
);
1335 spin_unlock_bh(&bat_priv
->tt_buff_lock
);
1338 orig_node_free_ref(orig_node
);
1340 neigh_node_free_ref(neigh_node
);
1342 hardif_free_ref(primary_if
);
1345 /* This packet was for me, so it doesn't need to be re-routed */
1349 bool send_tt_response(struct bat_priv
*bat_priv
,
1350 struct tt_query_packet
*tt_request
)
1352 if (is_my_mac(tt_request
->dst
))
1353 return send_my_tt_response(bat_priv
, tt_request
);
1355 return send_other_tt_response(bat_priv
, tt_request
);
1358 static void _tt_update_changes(struct bat_priv
*bat_priv
,
1359 struct orig_node
*orig_node
,
1360 struct tt_change
*tt_change
,
1361 uint16_t tt_num_changes
, uint8_t ttvn
)
1365 for (i
= 0; i
< tt_num_changes
; i
++) {
1366 if ((tt_change
+ i
)->flags
& TT_CLIENT_DEL
)
1367 tt_global_del(bat_priv
, orig_node
,
1368 (tt_change
+ i
)->addr
,
1369 "tt removed by changes",
1370 (tt_change
+ i
)->flags
& TT_CLIENT_ROAM
);
1372 if (!tt_global_add(bat_priv
, orig_node
,
1373 (tt_change
+ i
)->addr
, ttvn
, false,
1374 (tt_change
+ i
)->flags
&
1376 /* In case of problem while storing a
1377 * global_entry, we stop the updating
1378 * procedure without committing the
1379 * ttvn change. This will avoid to send
1380 * corrupted data on tt_request
1386 static void tt_fill_gtable(struct bat_priv
*bat_priv
,
1387 struct tt_query_packet
*tt_response
)
1389 struct orig_node
*orig_node
= NULL
;
1391 orig_node
= orig_hash_find(bat_priv
, tt_response
->src
);
1395 /* Purge the old table first.. */
1396 tt_global_del_orig(bat_priv
, orig_node
, "Received full table");
1398 _tt_update_changes(bat_priv
, orig_node
,
1399 (struct tt_change
*)(tt_response
+ 1),
1400 tt_response
->tt_data
, tt_response
->ttvn
);
1402 spin_lock_bh(&orig_node
->tt_buff_lock
);
1403 kfree(orig_node
->tt_buff
);
1404 orig_node
->tt_buff_len
= 0;
1405 orig_node
->tt_buff
= NULL
;
1406 spin_unlock_bh(&orig_node
->tt_buff_lock
);
1408 atomic_set(&orig_node
->last_ttvn
, tt_response
->ttvn
);
1412 orig_node_free_ref(orig_node
);
1415 void tt_update_changes(struct bat_priv
*bat_priv
, struct orig_node
*orig_node
,
1416 uint16_t tt_num_changes
, uint8_t ttvn
,
1417 struct tt_change
*tt_change
)
1419 _tt_update_changes(bat_priv
, orig_node
, tt_change
, tt_num_changes
,
1422 tt_save_orig_buffer(bat_priv
, orig_node
, (unsigned char *)tt_change
,
1424 atomic_set(&orig_node
->last_ttvn
, ttvn
);
1427 bool is_my_client(struct bat_priv
*bat_priv
, const uint8_t *addr
)
1429 struct tt_local_entry
*tt_local_entry
= NULL
;
1432 tt_local_entry
= tt_local_hash_find(bat_priv
, addr
);
1433 if (!tt_local_entry
)
1435 /* Check if the client has been logically deleted (but is kept for
1436 * consistency purpose) */
1437 if (tt_local_entry
->flags
& TT_CLIENT_PENDING
)
1442 tt_local_entry_free_ref(tt_local_entry
);
1446 void handle_tt_response(struct bat_priv
*bat_priv
,
1447 struct tt_query_packet
*tt_response
)
1449 struct tt_req_node
*node
, *safe
;
1450 struct orig_node
*orig_node
= NULL
;
1452 bat_dbg(DBG_TT
, bat_priv
, "Received TT_RESPONSE from %pM for "
1453 "ttvn %d t_size: %d [%c]\n",
1454 tt_response
->src
, tt_response
->ttvn
,
1455 tt_response
->tt_data
,
1456 (tt_response
->flags
& TT_FULL_TABLE
? 'F' : '.'));
1458 orig_node
= orig_hash_find(bat_priv
, tt_response
->src
);
1462 if (tt_response
->flags
& TT_FULL_TABLE
)
1463 tt_fill_gtable(bat_priv
, tt_response
);
1465 tt_update_changes(bat_priv
, orig_node
, tt_response
->tt_data
,
1467 (struct tt_change
*)(tt_response
+ 1));
1469 /* Delete the tt_req_node from pending tt_requests list */
1470 spin_lock_bh(&bat_priv
->tt_req_list_lock
);
1471 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_req_list
, list
) {
1472 if (!compare_eth(node
->addr
, tt_response
->src
))
1474 list_del(&node
->list
);
1477 spin_unlock_bh(&bat_priv
->tt_req_list_lock
);
1479 /* Recalculate the CRC for this orig_node and store it */
1480 orig_node
->tt_crc
= tt_global_crc(bat_priv
, orig_node
);
1481 /* Roaming phase is over: tables are in sync again. I can
1483 orig_node
->tt_poss_change
= false;
1486 orig_node_free_ref(orig_node
);
1489 int tt_init(struct bat_priv
*bat_priv
)
1491 if (!tt_local_init(bat_priv
))
1494 if (!tt_global_init(bat_priv
))
1497 tt_start_timer(bat_priv
);
1502 static void tt_roam_list_free(struct bat_priv
*bat_priv
)
1504 struct tt_roam_node
*node
, *safe
;
1506 spin_lock_bh(&bat_priv
->tt_roam_list_lock
);
1508 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_roam_list
, list
) {
1509 list_del(&node
->list
);
1513 spin_unlock_bh(&bat_priv
->tt_roam_list_lock
);
1516 static void tt_roam_purge(struct bat_priv
*bat_priv
)
1518 struct tt_roam_node
*node
, *safe
;
1520 spin_lock_bh(&bat_priv
->tt_roam_list_lock
);
1521 list_for_each_entry_safe(node
, safe
, &bat_priv
->tt_roam_list
, list
) {
1522 if (!is_out_of_time(node
->first_time
,
1523 ROAMING_MAX_TIME
* 1000))
1526 list_del(&node
->list
);
1529 spin_unlock_bh(&bat_priv
->tt_roam_list_lock
);
1532 /* This function checks whether the client already reached the
1533 * maximum number of possible roaming phases. In this case the ROAMING_ADV
1536 * returns true if the ROAMING_ADV can be sent, false otherwise */
1537 static bool tt_check_roam_count(struct bat_priv
*bat_priv
,
1540 struct tt_roam_node
*tt_roam_node
;
1543 spin_lock_bh(&bat_priv
->tt_roam_list_lock
);
1544 /* The new tt_req will be issued only if I'm not waiting for a
1545 * reply from the same orig_node yet */
1546 list_for_each_entry(tt_roam_node
, &bat_priv
->tt_roam_list
, list
) {
1547 if (!compare_eth(tt_roam_node
->addr
, client
))
1550 if (is_out_of_time(tt_roam_node
->first_time
,
1551 ROAMING_MAX_TIME
* 1000))
1554 if (!atomic_dec_not_zero(&tt_roam_node
->counter
))
1555 /* Sorry, you roamed too many times! */
1562 tt_roam_node
= kmalloc(sizeof(*tt_roam_node
), GFP_ATOMIC
);
1566 tt_roam_node
->first_time
= jiffies
;
1567 atomic_set(&tt_roam_node
->counter
, ROAMING_MAX_COUNT
- 1);
1568 memcpy(tt_roam_node
->addr
, client
, ETH_ALEN
);
1570 list_add(&tt_roam_node
->list
, &bat_priv
->tt_roam_list
);
1575 spin_unlock_bh(&bat_priv
->tt_roam_list_lock
);
1579 void send_roam_adv(struct bat_priv
*bat_priv
, uint8_t *client
,
1580 struct orig_node
*orig_node
)
1582 struct neigh_node
*neigh_node
= NULL
;
1583 struct sk_buff
*skb
= NULL
;
1584 struct roam_adv_packet
*roam_adv_packet
;
1586 struct hard_iface
*primary_if
;
1588 /* before going on we have to check whether the client has
1589 * already roamed to us too many times */
1590 if (!tt_check_roam_count(bat_priv
, client
))
1593 skb
= dev_alloc_skb(sizeof(struct roam_adv_packet
) + ETH_HLEN
);
1597 skb_reserve(skb
, ETH_HLEN
);
1599 roam_adv_packet
= (struct roam_adv_packet
*)skb_put(skb
,
1600 sizeof(struct roam_adv_packet
));
1602 roam_adv_packet
->packet_type
= BAT_ROAM_ADV
;
1603 roam_adv_packet
->version
= COMPAT_VERSION
;
1604 roam_adv_packet
->ttl
= TTL
;
1605 primary_if
= primary_if_get_selected(bat_priv
);
1608 memcpy(roam_adv_packet
->src
, primary_if
->net_dev
->dev_addr
, ETH_ALEN
);
1609 hardif_free_ref(primary_if
);
1610 memcpy(roam_adv_packet
->dst
, orig_node
->orig
, ETH_ALEN
);
1611 memcpy(roam_adv_packet
->client
, client
, ETH_ALEN
);
1613 neigh_node
= orig_node_get_router(orig_node
);
1617 bat_dbg(DBG_TT
, bat_priv
,
1618 "Sending ROAMING_ADV to %pM (client %pM) via %pM\n",
1619 orig_node
->orig
, client
, neigh_node
->addr
);
1621 send_skb_packet(skb
, neigh_node
->if_incoming
, neigh_node
->addr
);
1626 neigh_node_free_ref(neigh_node
);
1632 static void tt_purge(struct work_struct
*work
)
1634 struct delayed_work
*delayed_work
=
1635 container_of(work
, struct delayed_work
, work
);
1636 struct bat_priv
*bat_priv
=
1637 container_of(delayed_work
, struct bat_priv
, tt_work
);
1639 tt_local_purge(bat_priv
);
1640 tt_global_roam_purge(bat_priv
);
1641 tt_req_purge(bat_priv
);
1642 tt_roam_purge(bat_priv
);
1644 tt_start_timer(bat_priv
);
1647 void tt_free(struct bat_priv
*bat_priv
)
1649 cancel_delayed_work_sync(&bat_priv
->tt_work
);
1651 tt_local_table_free(bat_priv
);
1652 tt_global_table_free(bat_priv
);
1653 tt_req_list_free(bat_priv
);
1654 tt_changes_list_free(bat_priv
);
1655 tt_roam_list_free(bat_priv
);
1657 kfree(bat_priv
->tt_buff
);
1660 /* This function will reset the specified flags from all the entries in
1661 * the given hash table and will increment num_local_tt for each involved
1663 static void tt_local_reset_flags(struct bat_priv
*bat_priv
, uint16_t flags
)
1666 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
1667 struct hlist_head
*head
;
1668 struct hlist_node
*node
;
1669 struct tt_local_entry
*tt_local_entry
;
1674 for (i
= 0; i
< hash
->size
; i
++) {
1675 head
= &hash
->table
[i
];
1678 hlist_for_each_entry_rcu(tt_local_entry
, node
,
1680 tt_local_entry
->flags
&= ~flags
;
1681 atomic_inc(&bat_priv
->num_local_tt
);
1688 /* Purge out all the tt local entries marked with TT_CLIENT_PENDING */
1689 static void tt_local_purge_pending_clients(struct bat_priv
*bat_priv
)
1691 struct hashtable_t
*hash
= bat_priv
->tt_local_hash
;
1692 struct tt_local_entry
*tt_local_entry
;
1693 struct hlist_node
*node
, *node_tmp
;
1694 struct hlist_head
*head
;
1695 spinlock_t
*list_lock
; /* protects write access to the hash lists */
1701 for (i
= 0; i
< hash
->size
; i
++) {
1702 head
= &hash
->table
[i
];
1703 list_lock
= &hash
->list_locks
[i
];
1705 spin_lock_bh(list_lock
);
1706 hlist_for_each_entry_safe(tt_local_entry
, node
, node_tmp
,
1708 if (!(tt_local_entry
->flags
& TT_CLIENT_PENDING
))
1711 bat_dbg(DBG_TT
, bat_priv
, "Deleting local tt entry "
1712 "(%pM): pending\n", tt_local_entry
->addr
);
1714 atomic_dec(&bat_priv
->num_local_tt
);
1715 hlist_del_rcu(node
);
1716 tt_local_entry_free_ref(tt_local_entry
);
1718 spin_unlock_bh(list_lock
);
1723 void tt_commit_changes(struct bat_priv
*bat_priv
)
1725 tt_local_reset_flags(bat_priv
, TT_CLIENT_NEW
);
1726 tt_local_purge_pending_clients(bat_priv
);
1728 /* Increment the TTVN only once per OGM interval */
1729 atomic_inc(&bat_priv
->ttvn
);
1730 bat_priv
->tt_poss_change
= false;
This page took 0.119222 seconds and 5 git commands to generate.