2 * Copyright (C) 2009-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
22 /* increase the reference counter for this originator */
25 #include "originator.h"
27 #include "translation-table.h"
29 #include "gateway_client.h"
30 #include "hard-interface.h"
32 #include "soft-interface.h"
34 static void purge_orig(struct work_struct
*work
);
36 static void start_purge_timer(struct bat_priv
*bat_priv
)
38 INIT_DELAYED_WORK(&bat_priv
->orig_work
, purge_orig
);
39 queue_delayed_work(bat_event_workqueue
, &bat_priv
->orig_work
, 1 * HZ
);
42 int originator_init(struct bat_priv
*bat_priv
)
44 if (bat_priv
->orig_hash
)
47 spin_lock_bh(&bat_priv
->orig_hash_lock
);
48 bat_priv
->orig_hash
= hash_new(1024);
50 if (!bat_priv
->orig_hash
)
53 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
54 start_purge_timer(bat_priv
);
58 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
62 static void neigh_node_free_rcu(struct rcu_head
*rcu
)
64 struct neigh_node
*neigh_node
;
66 neigh_node
= container_of(rcu
, struct neigh_node
, rcu
);
70 void neigh_node_free_ref(struct neigh_node
*neigh_node
)
72 if (atomic_dec_and_test(&neigh_node
->refcount
))
73 call_rcu(&neigh_node
->rcu
, neigh_node_free_rcu
);
76 struct neigh_node
*create_neighbor(struct orig_node
*orig_node
,
77 struct orig_node
*orig_neigh_node
,
79 struct batman_if
*if_incoming
)
81 struct bat_priv
*bat_priv
= netdev_priv(if_incoming
->soft_iface
);
82 struct neigh_node
*neigh_node
;
84 bat_dbg(DBG_BATMAN
, bat_priv
,
85 "Creating new last-hop neighbor of originator\n");
87 neigh_node
= kzalloc(sizeof(struct neigh_node
), GFP_ATOMIC
);
91 INIT_HLIST_NODE(&neigh_node
->list
);
92 INIT_LIST_HEAD(&neigh_node
->bonding_list
);
94 memcpy(neigh_node
->addr
, neigh
, ETH_ALEN
);
95 neigh_node
->orig_node
= orig_neigh_node
;
96 neigh_node
->if_incoming
= if_incoming
;
97 atomic_set(&neigh_node
->refcount
, 1);
99 spin_lock_bh(&orig_node
->neigh_list_lock
);
100 hlist_add_head_rcu(&neigh_node
->list
, &orig_node
->neigh_list
);
101 spin_unlock_bh(&orig_node
->neigh_list_lock
);
105 void orig_node_free_ref(struct kref
*refcount
)
107 struct hlist_node
*node
, *node_tmp
;
108 struct neigh_node
*neigh_node
, *tmp_neigh_node
;
109 struct orig_node
*orig_node
;
111 orig_node
= container_of(refcount
, struct orig_node
, refcount
);
113 spin_lock_bh(&orig_node
->neigh_list_lock
);
115 /* for all bonding members ... */
116 list_for_each_entry_safe(neigh_node
, tmp_neigh_node
,
117 &orig_node
->bond_list
, bonding_list
) {
118 list_del_rcu(&neigh_node
->bonding_list
);
119 neigh_node_free_ref(neigh_node
);
122 /* for all neighbors towards this originator ... */
123 hlist_for_each_entry_safe(neigh_node
, node
, node_tmp
,
124 &orig_node
->neigh_list
, list
) {
125 hlist_del_rcu(&neigh_node
->list
);
126 neigh_node_free_ref(neigh_node
);
129 spin_unlock_bh(&orig_node
->neigh_list_lock
);
131 frag_list_free(&orig_node
->frag_list
);
132 hna_global_del_orig(orig_node
->bat_priv
, orig_node
,
133 "originator timed out");
135 kfree(orig_node
->bcast_own
);
136 kfree(orig_node
->bcast_own_sum
);
140 void originator_free(struct bat_priv
*bat_priv
)
142 struct hashtable_t
*hash
= bat_priv
->orig_hash
;
143 struct hlist_node
*walk
, *safe
;
144 struct hlist_head
*head
;
145 struct element_t
*bucket
;
146 spinlock_t
*list_lock
; /* spinlock to protect write access */
147 struct orig_node
*orig_node
;
153 cancel_delayed_work_sync(&bat_priv
->orig_work
);
155 spin_lock_bh(&bat_priv
->orig_hash_lock
);
156 bat_priv
->orig_hash
= NULL
;
158 for (i
= 0; i
< hash
->size
; i
++) {
159 head
= &hash
->table
[i
];
160 list_lock
= &hash
->list_locks
[i
];
162 spin_lock_bh(list_lock
);
163 hlist_for_each_entry_safe(bucket
, walk
, safe
, head
, hlist
) {
164 orig_node
= bucket
->data
;
167 call_rcu(&bucket
->rcu
, bucket_free_rcu
);
168 kref_put(&orig_node
->refcount
, orig_node_free_ref
);
170 spin_unlock_bh(list_lock
);
174 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
177 static void bucket_free_orig_rcu(struct rcu_head
*rcu
)
179 struct element_t
*bucket
;
180 struct orig_node
*orig_node
;
182 bucket
= container_of(rcu
, struct element_t
, rcu
);
183 orig_node
= bucket
->data
;
185 kref_put(&orig_node
->refcount
, orig_node_free_ref
);
189 /* this function finds or creates an originator entry for the given
190 * address if it does not exits */
191 struct orig_node
*get_orig_node(struct bat_priv
*bat_priv
, uint8_t *addr
)
193 struct orig_node
*orig_node
;
198 orig_node
= ((struct orig_node
*)hash_find(bat_priv
->orig_hash
,
199 compare_orig
, choose_orig
,
204 kref_get(&orig_node
->refcount
);
208 bat_dbg(DBG_BATMAN
, bat_priv
,
209 "Creating new originator: %pM\n", addr
);
211 orig_node
= kzalloc(sizeof(struct orig_node
), GFP_ATOMIC
);
215 INIT_HLIST_HEAD(&orig_node
->neigh_list
);
216 INIT_LIST_HEAD(&orig_node
->bond_list
);
217 spin_lock_init(&orig_node
->ogm_cnt_lock
);
218 spin_lock_init(&orig_node
->bcast_seqno_lock
);
219 spin_lock_init(&orig_node
->neigh_list_lock
);
220 kref_init(&orig_node
->refcount
);
222 orig_node
->bat_priv
= bat_priv
;
223 memcpy(orig_node
->orig
, addr
, ETH_ALEN
);
224 orig_node
->router
= NULL
;
225 orig_node
->hna_buff
= NULL
;
226 orig_node
->bcast_seqno_reset
= jiffies
- 1
227 - msecs_to_jiffies(RESET_PROTECTION_MS
);
228 orig_node
->batman_seqno_reset
= jiffies
- 1
229 - msecs_to_jiffies(RESET_PROTECTION_MS
);
231 atomic_set(&orig_node
->bond_candidates
, 0);
233 size
= bat_priv
->num_ifaces
* sizeof(unsigned long) * NUM_WORDS
;
235 orig_node
->bcast_own
= kzalloc(size
, GFP_ATOMIC
);
236 if (!orig_node
->bcast_own
)
239 size
= bat_priv
->num_ifaces
* sizeof(uint8_t);
240 orig_node
->bcast_own_sum
= kzalloc(size
, GFP_ATOMIC
);
242 INIT_LIST_HEAD(&orig_node
->frag_list
);
243 orig_node
->last_frag_packet
= 0;
245 if (!orig_node
->bcast_own_sum
)
248 hash_added
= hash_add(bat_priv
->orig_hash
, compare_orig
, choose_orig
,
251 goto free_bcast_own_sum
;
253 /* extra reference for return */
254 kref_get(&orig_node
->refcount
);
257 kfree(orig_node
->bcast_own_sum
);
259 kfree(orig_node
->bcast_own
);
265 static bool purge_orig_neighbors(struct bat_priv
*bat_priv
,
266 struct orig_node
*orig_node
,
267 struct neigh_node
**best_neigh_node
)
269 struct hlist_node
*node
, *node_tmp
;
270 struct neigh_node
*neigh_node
;
271 bool neigh_purged
= false;
273 *best_neigh_node
= NULL
;
275 spin_lock_bh(&orig_node
->neigh_list_lock
);
277 /* for all neighbors towards this originator ... */
278 hlist_for_each_entry_safe(neigh_node
, node
, node_tmp
,
279 &orig_node
->neigh_list
, list
) {
281 if ((time_after(jiffies
,
282 neigh_node
->last_valid
+ PURGE_TIMEOUT
* HZ
)) ||
283 (neigh_node
->if_incoming
->if_status
== IF_INACTIVE
) ||
284 (neigh_node
->if_incoming
->if_status
== IF_NOT_IN_USE
) ||
285 (neigh_node
->if_incoming
->if_status
== IF_TO_BE_REMOVED
)) {
287 if ((neigh_node
->if_incoming
->if_status
==
289 (neigh_node
->if_incoming
->if_status
==
291 (neigh_node
->if_incoming
->if_status
==
293 bat_dbg(DBG_BATMAN
, bat_priv
,
294 "neighbor purge: originator %pM, "
295 "neighbor: %pM, iface: %s\n",
296 orig_node
->orig
, neigh_node
->addr
,
297 neigh_node
->if_incoming
->net_dev
->name
);
299 bat_dbg(DBG_BATMAN
, bat_priv
,
300 "neighbor timeout: originator %pM, "
301 "neighbor: %pM, last_valid: %lu\n",
302 orig_node
->orig
, neigh_node
->addr
,
303 (neigh_node
->last_valid
/ HZ
));
307 hlist_del_rcu(&neigh_node
->list
);
308 bonding_candidate_del(orig_node
, neigh_node
);
309 neigh_node_free_ref(neigh_node
);
311 if ((!*best_neigh_node
) ||
312 (neigh_node
->tq_avg
> (*best_neigh_node
)->tq_avg
))
313 *best_neigh_node
= neigh_node
;
317 spin_unlock_bh(&orig_node
->neigh_list_lock
);
321 static bool purge_orig_node(struct bat_priv
*bat_priv
,
322 struct orig_node
*orig_node
)
324 struct neigh_node
*best_neigh_node
;
326 if (time_after(jiffies
,
327 orig_node
->last_valid
+ 2 * PURGE_TIMEOUT
* HZ
)) {
329 bat_dbg(DBG_BATMAN
, bat_priv
,
330 "Originator timeout: originator %pM, last_valid %lu\n",
331 orig_node
->orig
, (orig_node
->last_valid
/ HZ
));
334 if (purge_orig_neighbors(bat_priv
, orig_node
,
336 update_routes(bat_priv
, orig_node
,
339 orig_node
->hna_buff_len
);
346 static void _purge_orig(struct bat_priv
*bat_priv
)
348 struct hashtable_t
*hash
= bat_priv
->orig_hash
;
349 struct hlist_node
*walk
, *safe
;
350 struct hlist_head
*head
;
351 struct element_t
*bucket
;
352 spinlock_t
*list_lock
; /* spinlock to protect write access */
353 struct orig_node
*orig_node
;
359 spin_lock_bh(&bat_priv
->orig_hash_lock
);
361 /* for all origins... */
362 for (i
= 0; i
< hash
->size
; i
++) {
363 head
= &hash
->table
[i
];
364 list_lock
= &hash
->list_locks
[i
];
366 spin_lock_bh(list_lock
);
367 hlist_for_each_entry_safe(bucket
, walk
, safe
, head
, hlist
) {
368 orig_node
= bucket
->data
;
370 if (purge_orig_node(bat_priv
, orig_node
)) {
371 if (orig_node
->gw_flags
)
372 gw_node_delete(bat_priv
, orig_node
);
374 call_rcu(&bucket
->rcu
, bucket_free_orig_rcu
);
378 if (time_after(jiffies
, orig_node
->last_frag_packet
+
379 msecs_to_jiffies(FRAG_TIMEOUT
)))
380 frag_list_free(&orig_node
->frag_list
);
382 spin_unlock_bh(list_lock
);
385 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
387 gw_node_purge(bat_priv
);
388 gw_election(bat_priv
);
390 softif_neigh_purge(bat_priv
);
393 static void purge_orig(struct work_struct
*work
)
395 struct delayed_work
*delayed_work
=
396 container_of(work
, struct delayed_work
, work
);
397 struct bat_priv
*bat_priv
=
398 container_of(delayed_work
, struct bat_priv
, orig_work
);
400 _purge_orig(bat_priv
);
401 start_purge_timer(bat_priv
);
404 void purge_orig_ref(struct bat_priv
*bat_priv
)
406 _purge_orig(bat_priv
);
409 int orig_seq_print_text(struct seq_file
*seq
, void *offset
)
411 struct net_device
*net_dev
= (struct net_device
*)seq
->private;
412 struct bat_priv
*bat_priv
= netdev_priv(net_dev
);
413 struct hashtable_t
*hash
= bat_priv
->orig_hash
;
414 struct hlist_node
*walk
, *node
;
415 struct hlist_head
*head
;
416 struct element_t
*bucket
;
417 struct orig_node
*orig_node
;
418 struct neigh_node
*neigh_node
;
419 int batman_count
= 0;
424 if ((!bat_priv
->primary_if
) ||
425 (bat_priv
->primary_if
->if_status
!= IF_ACTIVE
)) {
426 if (!bat_priv
->primary_if
)
427 return seq_printf(seq
, "BATMAN mesh %s disabled - "
428 "please specify interfaces to enable it\n",
431 return seq_printf(seq
, "BATMAN mesh %s "
432 "disabled - primary interface not active\n",
436 seq_printf(seq
, "[B.A.T.M.A.N. adv %s%s, MainIF/MAC: %s/%pM (%s)]\n",
437 SOURCE_VERSION
, REVISION_VERSION_STR
,
438 bat_priv
->primary_if
->net_dev
->name
,
439 bat_priv
->primary_if
->net_dev
->dev_addr
, net_dev
->name
);
440 seq_printf(seq
, " %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",
441 "Originator", "last-seen", "#", TQ_MAX_VALUE
, "Nexthop",
442 "outgoingIF", "Potential nexthops");
444 spin_lock_bh(&bat_priv
->orig_hash_lock
);
446 for (i
= 0; i
< hash
->size
; i
++) {
447 head
= &hash
->table
[i
];
450 hlist_for_each_entry_rcu(bucket
, walk
, head
, hlist
) {
451 orig_node
= bucket
->data
;
453 if (!orig_node
->router
)
456 if (orig_node
->router
->tq_avg
== 0)
459 last_seen_secs
= jiffies_to_msecs(jiffies
-
460 orig_node
->last_valid
) / 1000;
461 last_seen_msecs
= jiffies_to_msecs(jiffies
-
462 orig_node
->last_valid
) % 1000;
464 neigh_node
= orig_node
->router
;
465 seq_printf(seq
, "%pM %4i.%03is (%3i) %pM [%10s]:",
466 orig_node
->orig
, last_seen_secs
,
467 last_seen_msecs
, neigh_node
->tq_avg
,
469 neigh_node
->if_incoming
->net_dev
->name
);
471 hlist_for_each_entry_rcu(neigh_node
, node
,
472 &orig_node
->neigh_list
, list
) {
473 seq_printf(seq
, " %pM (%3i)", neigh_node
->addr
,
477 seq_printf(seq
, "\n");
483 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
485 if ((batman_count
== 0))
486 seq_printf(seq
, "No batman nodes in range ...\n");
491 static int orig_node_add_if(struct orig_node
*orig_node
, int max_if_num
)
495 data_ptr
= kmalloc(max_if_num
* sizeof(unsigned long) * NUM_WORDS
,
498 pr_err("Can't resize orig: out of memory\n");
502 memcpy(data_ptr
, orig_node
->bcast_own
,
503 (max_if_num
- 1) * sizeof(unsigned long) * NUM_WORDS
);
504 kfree(orig_node
->bcast_own
);
505 orig_node
->bcast_own
= data_ptr
;
507 data_ptr
= kmalloc(max_if_num
* sizeof(uint8_t), GFP_ATOMIC
);
509 pr_err("Can't resize orig: out of memory\n");
513 memcpy(data_ptr
, orig_node
->bcast_own_sum
,
514 (max_if_num
- 1) * sizeof(uint8_t));
515 kfree(orig_node
->bcast_own_sum
);
516 orig_node
->bcast_own_sum
= data_ptr
;
521 int orig_hash_add_if(struct batman_if
*batman_if
, int max_if_num
)
523 struct bat_priv
*bat_priv
= netdev_priv(batman_if
->soft_iface
);
524 struct hashtable_t
*hash
= bat_priv
->orig_hash
;
525 struct hlist_node
*walk
;
526 struct hlist_head
*head
;
527 struct element_t
*bucket
;
528 struct orig_node
*orig_node
;
531 /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
533 spin_lock_bh(&bat_priv
->orig_hash_lock
);
535 for (i
= 0; i
< hash
->size
; i
++) {
536 head
= &hash
->table
[i
];
539 hlist_for_each_entry_rcu(bucket
, walk
, head
, hlist
) {
540 orig_node
= bucket
->data
;
542 spin_lock_bh(&orig_node
->ogm_cnt_lock
);
543 ret
= orig_node_add_if(orig_node
, max_if_num
);
544 spin_unlock_bh(&orig_node
->ogm_cnt_lock
);
552 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
557 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
561 static int orig_node_del_if(struct orig_node
*orig_node
,
562 int max_if_num
, int del_if_num
)
564 void *data_ptr
= NULL
;
567 /* last interface was removed */
571 chunk_size
= sizeof(unsigned long) * NUM_WORDS
;
572 data_ptr
= kmalloc(max_if_num
* chunk_size
, GFP_ATOMIC
);
574 pr_err("Can't resize orig: out of memory\n");
578 /* copy first part */
579 memcpy(data_ptr
, orig_node
->bcast_own
, del_if_num
* chunk_size
);
581 /* copy second part */
582 memcpy(data_ptr
+ del_if_num
* chunk_size
,
583 orig_node
->bcast_own
+ ((del_if_num
+ 1) * chunk_size
),
584 (max_if_num
- del_if_num
) * chunk_size
);
587 kfree(orig_node
->bcast_own
);
588 orig_node
->bcast_own
= data_ptr
;
593 data_ptr
= kmalloc(max_if_num
* sizeof(uint8_t), GFP_ATOMIC
);
595 pr_err("Can't resize orig: out of memory\n");
599 memcpy(data_ptr
, orig_node
->bcast_own_sum
,
600 del_if_num
* sizeof(uint8_t));
602 memcpy(data_ptr
+ del_if_num
* sizeof(uint8_t),
603 orig_node
->bcast_own_sum
+ ((del_if_num
+ 1) * sizeof(uint8_t)),
604 (max_if_num
- del_if_num
) * sizeof(uint8_t));
607 kfree(orig_node
->bcast_own_sum
);
608 orig_node
->bcast_own_sum
= data_ptr
;
613 int orig_hash_del_if(struct batman_if
*batman_if
, int max_if_num
)
615 struct bat_priv
*bat_priv
= netdev_priv(batman_if
->soft_iface
);
616 struct hashtable_t
*hash
= bat_priv
->orig_hash
;
617 struct hlist_node
*walk
;
618 struct hlist_head
*head
;
619 struct element_t
*bucket
;
620 struct batman_if
*batman_if_tmp
;
621 struct orig_node
*orig_node
;
624 /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
626 spin_lock_bh(&bat_priv
->orig_hash_lock
);
628 for (i
= 0; i
< hash
->size
; i
++) {
629 head
= &hash
->table
[i
];
632 hlist_for_each_entry_rcu(bucket
, walk
, head
, hlist
) {
633 orig_node
= bucket
->data
;
635 spin_lock_bh(&orig_node
->ogm_cnt_lock
);
636 ret
= orig_node_del_if(orig_node
, max_if_num
,
638 spin_unlock_bh(&orig_node
->ogm_cnt_lock
);
646 /* renumber remaining batman interfaces _inside_ of orig_hash_lock */
648 list_for_each_entry_rcu(batman_if_tmp
, &if_list
, list
) {
649 if (batman_if_tmp
->if_status
== IF_NOT_IN_USE
)
652 if (batman_if
== batman_if_tmp
)
655 if (batman_if
->soft_iface
!= batman_if_tmp
->soft_iface
)
658 if (batman_if_tmp
->if_num
> batman_if
->if_num
)
659 batman_if_tmp
->if_num
--;
663 batman_if
->if_num
= -1;
664 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
669 spin_unlock_bh(&bat_priv
->orig_hash_lock
);
This page took 0.049362 seconds and 5 git commands to generate.