1 /*
2 * Copyright (C) 2009-2012 B.A.T.M.A.N. contributors:
3 *
4 * Marek Lindner, Simon Wunderlich
5 *
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.
9 *
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.
14 *
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
18 * 02110-1301, USA
19 *
20 */
21
22 #include "main.h"
23 #include "originator.h"
24 #include "hash.h"
25 #include "translation-table.h"
26 #include "routing.h"
27 #include "gateway_client.h"
28 #include "hard-interface.h"
29 #include "unicast.h"
30 #include "soft-interface.h"
31
32 static void purge_orig(struct work_struct *work);
33
start_purge_timer(struct bat_priv * bat_priv)34 static void start_purge_timer(struct bat_priv *bat_priv)
35 {
36 INIT_DELAYED_WORK(&bat_priv->orig_work, purge_orig);
37 queue_delayed_work(bat_event_workqueue, &bat_priv->orig_work, 1 * HZ);
38 }
39
40 /* returns 1 if they are the same originator */
compare_orig(const struct hlist_node * node,const void * data2)41 static int compare_orig(const struct hlist_node *node, const void *data2)
42 {
43 const void *data1 = container_of(node, struct orig_node, hash_entry);
44
45 return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0);
46 }
47
originator_init(struct bat_priv * bat_priv)48 int originator_init(struct bat_priv *bat_priv)
49 {
50 if (bat_priv->orig_hash)
51 return 1;
52
53 bat_priv->orig_hash = hash_new(1024);
54
55 if (!bat_priv->orig_hash)
56 goto err;
57
58 start_purge_timer(bat_priv);
59 return 1;
60
61 err:
62 return 0;
63 }
64
neigh_node_free_ref(struct neigh_node * neigh_node)65 void neigh_node_free_ref(struct neigh_node *neigh_node)
66 {
67 if (atomic_dec_and_test(&neigh_node->refcount))
68 kfree_rcu(neigh_node, rcu);
69 }
70
71 /* increases the refcounter of a found router */
orig_node_get_router(struct orig_node * orig_node)72 struct neigh_node *orig_node_get_router(struct orig_node *orig_node)
73 {
74 struct neigh_node *router;
75
76 rcu_read_lock();
77 router = rcu_dereference(orig_node->router);
78
79 if (router && !atomic_inc_not_zero(&router->refcount))
80 router = NULL;
81
82 rcu_read_unlock();
83 return router;
84 }
85
create_neighbor(struct orig_node * orig_node,struct orig_node * orig_neigh_node,const uint8_t * neigh,struct hard_iface * if_incoming)86 struct neigh_node *create_neighbor(struct orig_node *orig_node,
87 struct orig_node *orig_neigh_node,
88 const uint8_t *neigh,
89 struct hard_iface *if_incoming)
90 {
91 struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
92 struct neigh_node *neigh_node;
93
94 bat_dbg(DBG_BATMAN, bat_priv,
95 "Creating new last-hop neighbor of originator\n");
96
97 neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC);
98 if (!neigh_node)
99 return NULL;
100
101 INIT_HLIST_NODE(&neigh_node->list);
102 INIT_LIST_HEAD(&neigh_node->bonding_list);
103 spin_lock_init(&neigh_node->tq_lock);
104
105 memcpy(neigh_node->addr, neigh, ETH_ALEN);
106 neigh_node->orig_node = orig_neigh_node;
107 neigh_node->if_incoming = if_incoming;
108
109 /* extra reference for return */
110 atomic_set(&neigh_node->refcount, 2);
111
112 spin_lock_bh(&orig_node->neigh_list_lock);
113 hlist_add_head_rcu(&neigh_node->list, &orig_node->neigh_list);
114 spin_unlock_bh(&orig_node->neigh_list_lock);
115 return neigh_node;
116 }
117
orig_node_free_rcu(struct rcu_head * rcu)118 static void orig_node_free_rcu(struct rcu_head *rcu)
119 {
120 struct hlist_node *node, *node_tmp;
121 struct neigh_node *neigh_node, *tmp_neigh_node;
122 struct orig_node *orig_node;
123
124 orig_node = container_of(rcu, struct orig_node, rcu);
125
126 spin_lock_bh(&orig_node->neigh_list_lock);
127
128 /* for all bonding members ... */
129 list_for_each_entry_safe(neigh_node, tmp_neigh_node,
130 &orig_node->bond_list, bonding_list) {
131 list_del_rcu(&neigh_node->bonding_list);
132 neigh_node_free_ref(neigh_node);
133 }
134
135 /* for all neighbors towards this originator ... */
136 hlist_for_each_entry_safe(neigh_node, node, node_tmp,
137 &orig_node->neigh_list, list) {
138 hlist_del_rcu(&neigh_node->list);
139 neigh_node_free_ref(neigh_node);
140 }
141
142 spin_unlock_bh(&orig_node->neigh_list_lock);
143
144 frag_list_free(&orig_node->frag_list);
145 tt_global_del_orig(orig_node->bat_priv, orig_node,
146 "originator timed out");
147
148 kfree(orig_node->tt_buff);
149 kfree(orig_node->bcast_own);
150 kfree(orig_node->bcast_own_sum);
151 kfree(orig_node);
152 }
153
orig_node_free_ref(struct orig_node * orig_node)154 void orig_node_free_ref(struct orig_node *orig_node)
155 {
156 if (atomic_dec_and_test(&orig_node->refcount))
157 call_rcu(&orig_node->rcu, orig_node_free_rcu);
158 }
159
originator_free(struct bat_priv * bat_priv)160 void originator_free(struct bat_priv *bat_priv)
161 {
162 struct hashtable_t *hash = bat_priv->orig_hash;
163 struct hlist_node *node, *node_tmp;
164 struct hlist_head *head;
165 spinlock_t *list_lock; /* spinlock to protect write access */
166 struct orig_node *orig_node;
167 uint32_t i;
168
169 if (!hash)
170 return;
171
172 cancel_delayed_work_sync(&bat_priv->orig_work);
173
174 bat_priv->orig_hash = NULL;
175
176 for (i = 0; i < hash->size; i++) {
177 head = &hash->table[i];
178 list_lock = &hash->list_locks[i];
179
180 spin_lock_bh(list_lock);
181 hlist_for_each_entry_safe(orig_node, node, node_tmp,
182 head, hash_entry) {
183
184 hlist_del_rcu(node);
185 orig_node_free_ref(orig_node);
186 }
187 spin_unlock_bh(list_lock);
188 }
189
190 hash_destroy(hash);
191 }
192
193 /* this function finds or creates an originator entry for the given
194 * address if it does not exits */
get_orig_node(struct bat_priv * bat_priv,const uint8_t * addr)195 struct orig_node *get_orig_node(struct bat_priv *bat_priv, const uint8_t *addr)
196 {
197 struct orig_node *orig_node;
198 int size;
199 int hash_added;
200
201 orig_node = orig_hash_find(bat_priv, addr);
202 if (orig_node)
203 return orig_node;
204
205 bat_dbg(DBG_BATMAN, bat_priv,
206 "Creating new originator: %pM\n", addr);
207
208 orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC);
209 if (!orig_node)
210 return NULL;
211
212 INIT_HLIST_HEAD(&orig_node->neigh_list);
213 INIT_LIST_HEAD(&orig_node->bond_list);
214 spin_lock_init(&orig_node->ogm_cnt_lock);
215 spin_lock_init(&orig_node->bcast_seqno_lock);
216 spin_lock_init(&orig_node->neigh_list_lock);
217 spin_lock_init(&orig_node->tt_buff_lock);
218
219 /* extra reference for return */
220 atomic_set(&orig_node->refcount, 2);
221
222 orig_node->tt_initialised = false;
223 orig_node->tt_poss_change = false;
224 orig_node->bat_priv = bat_priv;
225 memcpy(orig_node->orig, addr, ETH_ALEN);
226 orig_node->router = NULL;
227 orig_node->tt_crc = 0;
228 atomic_set(&orig_node->last_ttvn, 0);
229 orig_node->tt_buff = NULL;
230 orig_node->tt_buff_len = 0;
231 atomic_set(&orig_node->tt_size, 0);
232 orig_node->bcast_seqno_reset = jiffies - 1
233 - msecs_to_jiffies(RESET_PROTECTION_MS);
234 orig_node->batman_seqno_reset = jiffies - 1
235 - msecs_to_jiffies(RESET_PROTECTION_MS);
236
237 atomic_set(&orig_node->bond_candidates, 0);
238
239 size = bat_priv->num_ifaces * sizeof(unsigned long) * NUM_WORDS;
240
241 orig_node->bcast_own = kzalloc(size, GFP_ATOMIC);
242 if (!orig_node->bcast_own)
243 goto free_orig_node;
244
245 size = bat_priv->num_ifaces * sizeof(uint8_t);
246 orig_node->bcast_own_sum = kzalloc(size, GFP_ATOMIC);
247
248 INIT_LIST_HEAD(&orig_node->frag_list);
249 orig_node->last_frag_packet = 0;
250
251 if (!orig_node->bcast_own_sum)
252 goto free_bcast_own;
253
254 hash_added = hash_add(bat_priv->orig_hash, compare_orig,
255 choose_orig, orig_node, &orig_node->hash_entry);
256 if (hash_added != 0)
257 goto free_bcast_own_sum;
258
259 return orig_node;
260 free_bcast_own_sum:
261 kfree(orig_node->bcast_own_sum);
262 free_bcast_own:
263 kfree(orig_node->bcast_own);
264 free_orig_node:
265 kfree(orig_node);
266 return NULL;
267 }
268
purge_orig_neighbors(struct bat_priv * bat_priv,struct orig_node * orig_node,struct neigh_node ** best_neigh_node)269 static bool purge_orig_neighbors(struct bat_priv *bat_priv,
270 struct orig_node *orig_node,
271 struct neigh_node **best_neigh_node)
272 {
273 struct hlist_node *node, *node_tmp;
274 struct neigh_node *neigh_node;
275 bool neigh_purged = false;
276
277 *best_neigh_node = NULL;
278
279 spin_lock_bh(&orig_node->neigh_list_lock);
280
281 /* for all neighbors towards this originator ... */
282 hlist_for_each_entry_safe(neigh_node, node, node_tmp,
283 &orig_node->neigh_list, list) {
284
285 if ((has_timed_out(neigh_node->last_valid, PURGE_TIMEOUT)) ||
286 (neigh_node->if_incoming->if_status == IF_INACTIVE) ||
287 (neigh_node->if_incoming->if_status == IF_NOT_IN_USE) ||
288 (neigh_node->if_incoming->if_status == IF_TO_BE_REMOVED)) {
289
290 if ((neigh_node->if_incoming->if_status ==
291 IF_INACTIVE) ||
292 (neigh_node->if_incoming->if_status ==
293 IF_NOT_IN_USE) ||
294 (neigh_node->if_incoming->if_status ==
295 IF_TO_BE_REMOVED))
296 bat_dbg(DBG_BATMAN, bat_priv,
297 "neighbor purge: originator %pM, neighbor: %pM, iface: %s\n",
298 orig_node->orig, neigh_node->addr,
299 neigh_node->if_incoming->net_dev->name);
300 else
301 bat_dbg(DBG_BATMAN, bat_priv,
302 "neighbor timeout: originator %pM, neighbor: %pM, last_valid: %lu\n",
303 orig_node->orig, neigh_node->addr,
304 (neigh_node->last_valid / HZ));
305
306 neigh_purged = true;
307
308 hlist_del_rcu(&neigh_node->list);
309 bonding_candidate_del(orig_node, neigh_node);
310 neigh_node_free_ref(neigh_node);
311 } else {
312 if ((!*best_neigh_node) ||
313 (neigh_node->tq_avg > (*best_neigh_node)->tq_avg))
314 *best_neigh_node = neigh_node;
315 }
316 }
317
318 spin_unlock_bh(&orig_node->neigh_list_lock);
319 return neigh_purged;
320 }
321
purge_orig_node(struct bat_priv * bat_priv,struct orig_node * orig_node)322 static bool purge_orig_node(struct bat_priv *bat_priv,
323 struct orig_node *orig_node)
324 {
325 struct neigh_node *best_neigh_node;
326
327 if (has_timed_out(orig_node->last_valid, 2 * PURGE_TIMEOUT)) {
328 bat_dbg(DBG_BATMAN, bat_priv,
329 "Originator timeout: originator %pM, last_valid %lu\n",
330 orig_node->orig, (orig_node->last_valid / HZ));
331 return true;
332 } else {
333 if (purge_orig_neighbors(bat_priv, orig_node,
334 &best_neigh_node))
335 update_route(bat_priv, orig_node, best_neigh_node);
336 }
337
338 return false;
339 }
340
_purge_orig(struct bat_priv * bat_priv)341 static void _purge_orig(struct bat_priv *bat_priv)
342 {
343 struct hashtable_t *hash = bat_priv->orig_hash;
344 struct hlist_node *node, *node_tmp;
345 struct hlist_head *head;
346 spinlock_t *list_lock; /* spinlock to protect write access */
347 struct orig_node *orig_node;
348 uint32_t i;
349
350 if (!hash)
351 return;
352
353 /* for all origins... */
354 for (i = 0; i < hash->size; i++) {
355 head = &hash->table[i];
356 list_lock = &hash->list_locks[i];
357
358 spin_lock_bh(list_lock);
359 hlist_for_each_entry_safe(orig_node, node, node_tmp,
360 head, hash_entry) {
361 if (purge_orig_node(bat_priv, orig_node)) {
362 if (orig_node->gw_flags)
363 gw_node_delete(bat_priv, orig_node);
364 hlist_del_rcu(node);
365 orig_node_free_ref(orig_node);
366 continue;
367 }
368
369 if (has_timed_out(orig_node->last_frag_packet,
370 FRAG_TIMEOUT))
371 frag_list_free(&orig_node->frag_list);
372 }
373 spin_unlock_bh(list_lock);
374 }
375
376 gw_node_purge(bat_priv);
377 gw_election(bat_priv);
378
379 softif_neigh_purge(bat_priv);
380 }
381
purge_orig(struct work_struct * work)382 static void purge_orig(struct work_struct *work)
383 {
384 struct delayed_work *delayed_work =
385 container_of(work, struct delayed_work, work);
386 struct bat_priv *bat_priv =
387 container_of(delayed_work, struct bat_priv, orig_work);
388
389 _purge_orig(bat_priv);
390 start_purge_timer(bat_priv);
391 }
392
purge_orig_ref(struct bat_priv * bat_priv)393 void purge_orig_ref(struct bat_priv *bat_priv)
394 {
395 _purge_orig(bat_priv);
396 }
397
orig_seq_print_text(struct seq_file * seq,void * offset)398 int orig_seq_print_text(struct seq_file *seq, void *offset)
399 {
400 struct net_device *net_dev = (struct net_device *)seq->private;
401 struct bat_priv *bat_priv = netdev_priv(net_dev);
402 struct hashtable_t *hash = bat_priv->orig_hash;
403 struct hlist_node *node, *node_tmp;
404 struct hlist_head *head;
405 struct hard_iface *primary_if;
406 struct orig_node *orig_node;
407 struct neigh_node *neigh_node, *neigh_node_tmp;
408 int batman_count = 0;
409 int last_seen_secs;
410 int last_seen_msecs;
411 uint32_t i;
412 int ret = 0;
413
414 primary_if = primary_if_get_selected(bat_priv);
415
416 if (!primary_if) {
417 ret = seq_printf(seq,
418 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
419 net_dev->name);
420 goto out;
421 }
422
423 if (primary_if->if_status != IF_ACTIVE) {
424 ret = seq_printf(seq,
425 "BATMAN mesh %s disabled - primary interface not active\n",
426 net_dev->name);
427 goto out;
428 }
429
430 seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s)]\n",
431 SOURCE_VERSION, primary_if->net_dev->name,
432 primary_if->net_dev->dev_addr, net_dev->name);
433 seq_printf(seq, " %-15s %s (%s/%i) %17s [%10s]: %20s ...\n",
434 "Originator", "last-seen", "#", TQ_MAX_VALUE, "Nexthop",
435 "outgoingIF", "Potential nexthops");
436
437 for (i = 0; i < hash->size; i++) {
438 head = &hash->table[i];
439
440 rcu_read_lock();
441 hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
442 neigh_node = orig_node_get_router(orig_node);
443 if (!neigh_node)
444 continue;
445
446 if (neigh_node->tq_avg == 0)
447 goto next;
448
449 last_seen_secs = jiffies_to_msecs(jiffies -
450 orig_node->last_valid) / 1000;
451 last_seen_msecs = jiffies_to_msecs(jiffies -
452 orig_node->last_valid) % 1000;
453
454 seq_printf(seq, "%pM %4i.%03is (%3i) %pM [%10s]:",
455 orig_node->orig, last_seen_secs,
456 last_seen_msecs, neigh_node->tq_avg,
457 neigh_node->addr,
458 neigh_node->if_incoming->net_dev->name);
459
460 hlist_for_each_entry_rcu(neigh_node_tmp, node_tmp,
461 &orig_node->neigh_list, list) {
462 seq_printf(seq, " %pM (%3i)",
463 neigh_node_tmp->addr,
464 neigh_node_tmp->tq_avg);
465 }
466
467 seq_printf(seq, "\n");
468 batman_count++;
469
470 next:
471 neigh_node_free_ref(neigh_node);
472 }
473 rcu_read_unlock();
474 }
475
476 if (batman_count == 0)
477 seq_printf(seq, "No batman nodes in range ...\n");
478
479 out:
480 if (primary_if)
481 hardif_free_ref(primary_if);
482 return ret;
483 }
484
orig_node_add_if(struct orig_node * orig_node,int max_if_num)485 static int orig_node_add_if(struct orig_node *orig_node, int max_if_num)
486 {
487 void *data_ptr;
488
489 data_ptr = kmalloc(max_if_num * sizeof(unsigned long) * NUM_WORDS,
490 GFP_ATOMIC);
491 if (!data_ptr)
492 return -1;
493
494 memcpy(data_ptr, orig_node->bcast_own,
495 (max_if_num - 1) * sizeof(unsigned long) * NUM_WORDS);
496 kfree(orig_node->bcast_own);
497 orig_node->bcast_own = data_ptr;
498
499 data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
500 if (!data_ptr)
501 return -1;
502
503 memcpy(data_ptr, orig_node->bcast_own_sum,
504 (max_if_num - 1) * sizeof(uint8_t));
505 kfree(orig_node->bcast_own_sum);
506 orig_node->bcast_own_sum = data_ptr;
507
508 return 0;
509 }
510
orig_hash_add_if(struct hard_iface * hard_iface,int max_if_num)511 int orig_hash_add_if(struct hard_iface *hard_iface, int max_if_num)
512 {
513 struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
514 struct hashtable_t *hash = bat_priv->orig_hash;
515 struct hlist_node *node;
516 struct hlist_head *head;
517 struct orig_node *orig_node;
518 uint32_t i;
519 int ret;
520
521 /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
522 * if_num */
523 for (i = 0; i < hash->size; i++) {
524 head = &hash->table[i];
525
526 rcu_read_lock();
527 hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
528 spin_lock_bh(&orig_node->ogm_cnt_lock);
529 ret = orig_node_add_if(orig_node, max_if_num);
530 spin_unlock_bh(&orig_node->ogm_cnt_lock);
531
532 if (ret == -1)
533 goto err;
534 }
535 rcu_read_unlock();
536 }
537
538 return 0;
539
540 err:
541 rcu_read_unlock();
542 return -ENOMEM;
543 }
544
orig_node_del_if(struct orig_node * orig_node,int max_if_num,int del_if_num)545 static int orig_node_del_if(struct orig_node *orig_node,
546 int max_if_num, int del_if_num)
547 {
548 void *data_ptr = NULL;
549 int chunk_size;
550
551 /* last interface was removed */
552 if (max_if_num == 0)
553 goto free_bcast_own;
554
555 chunk_size = sizeof(unsigned long) * NUM_WORDS;
556 data_ptr = kmalloc(max_if_num * chunk_size, GFP_ATOMIC);
557 if (!data_ptr)
558 return -1;
559
560 /* copy first part */
561 memcpy(data_ptr, orig_node->bcast_own, del_if_num * chunk_size);
562
563 /* copy second part */
564 memcpy((char *)data_ptr + del_if_num * chunk_size,
565 orig_node->bcast_own + ((del_if_num + 1) * chunk_size),
566 (max_if_num - del_if_num) * chunk_size);
567
568 free_bcast_own:
569 kfree(orig_node->bcast_own);
570 orig_node->bcast_own = data_ptr;
571
572 if (max_if_num == 0)
573 goto free_own_sum;
574
575 data_ptr = kmalloc(max_if_num * sizeof(uint8_t), GFP_ATOMIC);
576 if (!data_ptr)
577 return -1;
578
579 memcpy(data_ptr, orig_node->bcast_own_sum,
580 del_if_num * sizeof(uint8_t));
581
582 memcpy((char *)data_ptr + del_if_num * sizeof(uint8_t),
583 orig_node->bcast_own_sum + ((del_if_num + 1) * sizeof(uint8_t)),
584 (max_if_num - del_if_num) * sizeof(uint8_t));
585
586 free_own_sum:
587 kfree(orig_node->bcast_own_sum);
588 orig_node->bcast_own_sum = data_ptr;
589
590 return 0;
591 }
592
orig_hash_del_if(struct hard_iface * hard_iface,int max_if_num)593 int orig_hash_del_if(struct hard_iface *hard_iface, int max_if_num)
594 {
595 struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
596 struct hashtable_t *hash = bat_priv->orig_hash;
597 struct hlist_node *node;
598 struct hlist_head *head;
599 struct hard_iface *hard_iface_tmp;
600 struct orig_node *orig_node;
601 uint32_t i;
602 int ret;
603
604 /* resize all orig nodes because orig_node->bcast_own(_sum) depend on
605 * if_num */
606 for (i = 0; i < hash->size; i++) {
607 head = &hash->table[i];
608
609 rcu_read_lock();
610 hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
611 spin_lock_bh(&orig_node->ogm_cnt_lock);
612 ret = orig_node_del_if(orig_node, max_if_num,
613 hard_iface->if_num);
614 spin_unlock_bh(&orig_node->ogm_cnt_lock);
615
616 if (ret == -1)
617 goto err;
618 }
619 rcu_read_unlock();
620 }
621
622 /* renumber remaining batman interfaces _inside_ of orig_hash_lock */
623 rcu_read_lock();
624 list_for_each_entry_rcu(hard_iface_tmp, &hardif_list, list) {
625 if (hard_iface_tmp->if_status == IF_NOT_IN_USE)
626 continue;
627
628 if (hard_iface == hard_iface_tmp)
629 continue;
630
631 if (hard_iface->soft_iface != hard_iface_tmp->soft_iface)
632 continue;
633
634 if (hard_iface_tmp->if_num > hard_iface->if_num)
635 hard_iface_tmp->if_num--;
636 }
637 rcu_read_unlock();
638
639 hard_iface->if_num = -1;
640 return 0;
641
642 err:
643 rcu_read_unlock();
644 return -ENOMEM;
645 }
646