1
2
3
4
5
6
7#include "bat_iv_ogm.h"
8#include "main.h"
9
10#include <linux/atomic.h>
11#include <linux/bitmap.h>
12#include <linux/bitops.h>
13#include <linux/bug.h>
14#include <linux/byteorder/generic.h>
15#include <linux/cache.h>
16#include <linux/errno.h>
17#include <linux/etherdevice.h>
18#include <linux/gfp.h>
19#include <linux/if_ether.h>
20#include <linux/init.h>
21#include <linux/jiffies.h>
22#include <linux/kernel.h>
23#include <linux/kref.h>
24#include <linux/list.h>
25#include <linux/lockdep.h>
26#include <linux/mutex.h>
27#include <linux/netdevice.h>
28#include <linux/netlink.h>
29#include <linux/pkt_sched.h>
30#include <linux/printk.h>
31#include <linux/random.h>
32#include <linux/rculist.h>
33#include <linux/rcupdate.h>
34#include <linux/seq_file.h>
35#include <linux/skbuff.h>
36#include <linux/slab.h>
37#include <linux/spinlock.h>
38#include <linux/stddef.h>
39#include <linux/string.h>
40#include <linux/types.h>
41#include <linux/workqueue.h>
42#include <net/genetlink.h>
43#include <net/netlink.h>
44#include <uapi/linux/batadv_packet.h>
45#include <uapi/linux/batman_adv.h>
46
47#include "bat_algo.h"
48#include "bitarray.h"
49#include "gateway_client.h"
50#include "hard-interface.h"
51#include "hash.h"
52#include "log.h"
53#include "netlink.h"
54#include "network-coding.h"
55#include "originator.h"
56#include "routing.h"
57#include "send.h"
58#include "translation-table.h"
59#include "tvlv.h"
60
61static void batadv_iv_send_outstanding_bat_ogm_packet(struct work_struct *work);
62
63
64
65
66enum batadv_dup_status {
67
68 BATADV_NO_DUP = 0,
69
70
71
72
73
74 BATADV_ORIG_DUP,
75
76
77 BATADV_NEIGH_DUP,
78
79
80
81
82 BATADV_PROTECTED,
83};
84
85
86
87
88
89
90
91static void batadv_ring_buffer_set(u8 lq_recv[], u8 *lq_index, u8 value)
92{
93 lq_recv[*lq_index] = value;
94 *lq_index = (*lq_index + 1) % BATADV_TQ_GLOBAL_WINDOW_SIZE;
95}
96
97
98
99
100
101
102
103
104static u8 batadv_ring_buffer_avg(const u8 lq_recv[])
105{
106 const u8 *ptr;
107 u16 count = 0;
108 u16 i = 0;
109 u16 sum = 0;
110
111 ptr = lq_recv;
112
113 while (i < BATADV_TQ_GLOBAL_WINDOW_SIZE) {
114 if (*ptr != 0) {
115 count++;
116 sum += *ptr;
117 }
118
119 i++;
120 ptr++;
121 }
122
123 if (count == 0)
124 return 0;
125
126 return (u8)(sum / count);
127}
128
129
130
131
132
133
134
135
136
137
138
139static struct batadv_orig_node *
140batadv_iv_ogm_orig_get(struct batadv_priv *bat_priv, const u8 *addr)
141{
142 struct batadv_orig_node *orig_node;
143 int hash_added;
144
145 orig_node = batadv_orig_hash_find(bat_priv, addr);
146 if (orig_node)
147 return orig_node;
148
149 orig_node = batadv_orig_node_new(bat_priv, addr);
150 if (!orig_node)
151 return NULL;
152
153 spin_lock_init(&orig_node->bat_iv.ogm_cnt_lock);
154
155 kref_get(&orig_node->refcount);
156 hash_added = batadv_hash_add(bat_priv->orig_hash, batadv_compare_orig,
157 batadv_choose_orig, orig_node,
158 &orig_node->hash_entry);
159 if (hash_added != 0)
160 goto free_orig_node_hash;
161
162 return orig_node;
163
164free_orig_node_hash:
165
166 batadv_orig_node_put(orig_node);
167
168 batadv_orig_node_put(orig_node);
169
170 return NULL;
171}
172
173static struct batadv_neigh_node *
174batadv_iv_ogm_neigh_new(struct batadv_hard_iface *hard_iface,
175 const u8 *neigh_addr,
176 struct batadv_orig_node *orig_node,
177 struct batadv_orig_node *orig_neigh)
178{
179 struct batadv_neigh_node *neigh_node;
180
181 neigh_node = batadv_neigh_node_get_or_create(orig_node,
182 hard_iface, neigh_addr);
183 if (!neigh_node)
184 goto out;
185
186 neigh_node->orig_node = orig_neigh;
187
188out:
189 return neigh_node;
190}
191
192static int batadv_iv_ogm_iface_enable(struct batadv_hard_iface *hard_iface)
193{
194 struct batadv_ogm_packet *batadv_ogm_packet;
195 unsigned char *ogm_buff;
196 u32 random_seqno;
197
198 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex);
199
200
201 get_random_bytes(&random_seqno, sizeof(random_seqno));
202 atomic_set(&hard_iface->bat_iv.ogm_seqno, random_seqno);
203
204 hard_iface->bat_iv.ogm_buff_len = BATADV_OGM_HLEN;
205 ogm_buff = kmalloc(hard_iface->bat_iv.ogm_buff_len, GFP_ATOMIC);
206 if (!ogm_buff) {
207 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex);
208 return -ENOMEM;
209 }
210
211 hard_iface->bat_iv.ogm_buff = ogm_buff;
212
213 batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff;
214 batadv_ogm_packet->packet_type = BATADV_IV_OGM;
215 batadv_ogm_packet->version = BATADV_COMPAT_VERSION;
216 batadv_ogm_packet->ttl = 2;
217 batadv_ogm_packet->flags = BATADV_NO_FLAGS;
218 batadv_ogm_packet->reserved = 0;
219 batadv_ogm_packet->tq = BATADV_TQ_MAX_VALUE;
220
221 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex);
222
223 return 0;
224}
225
226static void batadv_iv_ogm_iface_disable(struct batadv_hard_iface *hard_iface)
227{
228 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex);
229
230 kfree(hard_iface->bat_iv.ogm_buff);
231 hard_iface->bat_iv.ogm_buff = NULL;
232
233 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex);
234}
235
236static void batadv_iv_ogm_iface_update_mac(struct batadv_hard_iface *hard_iface)
237{
238 struct batadv_ogm_packet *batadv_ogm_packet;
239 void *ogm_buff;
240
241 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex);
242
243 ogm_buff = hard_iface->bat_iv.ogm_buff;
244 if (!ogm_buff)
245 goto unlock;
246
247 batadv_ogm_packet = ogm_buff;
248 ether_addr_copy(batadv_ogm_packet->orig,
249 hard_iface->net_dev->dev_addr);
250 ether_addr_copy(batadv_ogm_packet->prev_sender,
251 hard_iface->net_dev->dev_addr);
252
253unlock:
254 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex);
255}
256
257static void
258batadv_iv_ogm_primary_iface_set(struct batadv_hard_iface *hard_iface)
259{
260 struct batadv_ogm_packet *batadv_ogm_packet;
261 void *ogm_buff;
262
263 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex);
264
265 ogm_buff = hard_iface->bat_iv.ogm_buff;
266 if (!ogm_buff)
267 goto unlock;
268
269 batadv_ogm_packet = ogm_buff;
270 batadv_ogm_packet->ttl = BATADV_TTL;
271
272unlock:
273 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex);
274}
275
276
277static unsigned long
278batadv_iv_ogm_emit_send_time(const struct batadv_priv *bat_priv)
279{
280 unsigned int msecs;
281
282 msecs = atomic_read(&bat_priv->orig_interval) - BATADV_JITTER;
283 msecs += prandom_u32() % (2 * BATADV_JITTER);
284
285 return jiffies + msecs_to_jiffies(msecs);
286}
287
288
289static unsigned long batadv_iv_ogm_fwd_send_time(void)
290{
291 return jiffies + msecs_to_jiffies(prandom_u32() % (BATADV_JITTER / 2));
292}
293
294
295static u8 batadv_hop_penalty(u8 tq, const struct batadv_priv *bat_priv)
296{
297 int hop_penalty = atomic_read(&bat_priv->hop_penalty);
298 int new_tq;
299
300 new_tq = tq * (BATADV_TQ_MAX_VALUE - hop_penalty);
301 new_tq /= BATADV_TQ_MAX_VALUE;
302
303 return new_tq;
304}
305
306
307
308
309
310
311
312
313
314static bool
315batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len,
316 const struct batadv_ogm_packet *ogm_packet)
317{
318 int next_buff_pos = 0;
319
320
321 next_buff_pos += buff_pos + sizeof(*ogm_packet);
322 if (next_buff_pos > packet_len)
323 return false;
324
325
326 next_buff_pos += ntohs(ogm_packet->tvlv_len);
327
328 return (next_buff_pos <= packet_len) &&
329 (next_buff_pos <= BATADV_MAX_AGGREGATION_BYTES);
330}
331
332
333static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet,
334 struct batadv_hard_iface *hard_iface)
335{
336 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
337 const char *fwd_str;
338 u8 packet_num;
339 s16 buff_pos;
340 struct batadv_ogm_packet *batadv_ogm_packet;
341 struct sk_buff *skb;
342 u8 *packet_pos;
343
344 if (hard_iface->if_status != BATADV_IF_ACTIVE)
345 return;
346
347 packet_num = 0;
348 buff_pos = 0;
349 packet_pos = forw_packet->skb->data;
350 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
351
352
353 while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
354 batadv_ogm_packet)) {
355
356
357
358 if (forw_packet->direct_link_flags & BIT(packet_num) &&
359 forw_packet->if_incoming == hard_iface)
360 batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
361 else
362 batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
363
364 if (packet_num > 0 || !forw_packet->own)
365 fwd_str = "Forwarding";
366 else
367 fwd_str = "Sending own";
368
369 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
370 "%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s) on interface %s [%pM]\n",
371 fwd_str, (packet_num > 0 ? "aggregated " : ""),
372 batadv_ogm_packet->orig,
373 ntohl(batadv_ogm_packet->seqno),
374 batadv_ogm_packet->tq, batadv_ogm_packet->ttl,
375 ((batadv_ogm_packet->flags & BATADV_DIRECTLINK) ?
376 "on" : "off"),
377 hard_iface->net_dev->name,
378 hard_iface->net_dev->dev_addr);
379
380 buff_pos += BATADV_OGM_HLEN;
381 buff_pos += ntohs(batadv_ogm_packet->tvlv_len);
382 packet_num++;
383 packet_pos = forw_packet->skb->data + buff_pos;
384 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos;
385 }
386
387
388 skb = skb_clone(forw_packet->skb, GFP_ATOMIC);
389 if (skb) {
390 batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_TX);
391 batadv_add_counter(bat_priv, BATADV_CNT_MGMT_TX_BYTES,
392 skb->len + ETH_HLEN);
393 batadv_send_broadcast_skb(skb, hard_iface);
394 }
395}
396
397
398static void batadv_iv_ogm_emit(struct batadv_forw_packet *forw_packet)
399{
400 struct net_device *soft_iface;
401
402 if (!forw_packet->if_incoming) {
403 pr_err("Error - can't forward packet: incoming iface not specified\n");
404 return;
405 }
406
407 soft_iface = forw_packet->if_incoming->soft_iface;
408
409 if (WARN_ON(!forw_packet->if_outgoing))
410 return;
411
412 if (WARN_ON(forw_packet->if_outgoing->soft_iface != soft_iface))
413 return;
414
415 if (forw_packet->if_incoming->if_status != BATADV_IF_ACTIVE)
416 return;
417
418
419 batadv_iv_ogm_send_to_if(forw_packet, forw_packet->if_outgoing);
420}
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436static bool
437batadv_iv_ogm_can_aggregate(const struct batadv_ogm_packet *new_bat_ogm_packet,
438 struct batadv_priv *bat_priv,
439 int packet_len, unsigned long send_time,
440 bool directlink,
441 const struct batadv_hard_iface *if_incoming,
442 const struct batadv_hard_iface *if_outgoing,
443 const struct batadv_forw_packet *forw_packet)
444{
445 struct batadv_ogm_packet *batadv_ogm_packet;
446 int aggregated_bytes = forw_packet->packet_len + packet_len;
447 struct batadv_hard_iface *primary_if = NULL;
448 bool res = false;
449 unsigned long aggregation_end_time;
450
451 batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data;
452 aggregation_end_time = send_time;
453 aggregation_end_time += msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
454
455
456
457
458
459
460
461
462
463 if (!time_before(send_time, forw_packet->send_time) ||
464 !time_after_eq(aggregation_end_time, forw_packet->send_time))
465 return false;
466
467 if (aggregated_bytes > BATADV_MAX_AGGREGATION_BYTES)
468 return false;
469
470
471 if (forw_packet->if_outgoing != if_outgoing)
472 return false;
473
474
475
476
477
478
479
480
481 primary_if = batadv_primary_if_get_selected(bat_priv);
482 if (!primary_if)
483 return false;
484
485
486
487
488 if (!directlink &&
489 !(batadv_ogm_packet->flags & BATADV_DIRECTLINK) &&
490 batadv_ogm_packet->ttl != 1 &&
491
492
493
494
495 (!forw_packet->own ||
496 forw_packet->if_incoming == primary_if)) {
497 res = true;
498 goto out;
499 }
500
501
502
503
504 if (directlink &&
505 new_bat_ogm_packet->ttl == 1 &&
506 forw_packet->if_incoming == if_incoming &&
507
508
509
510
511
512 (batadv_ogm_packet->flags & BATADV_DIRECTLINK ||
513 (forw_packet->own &&
514 forw_packet->if_incoming != primary_if))) {
515 res = true;
516 goto out;
517 }
518
519out:
520 if (primary_if)
521 batadv_hardif_put(primary_if);
522 return res;
523}
524
525
526
527
528
529
530
531
532
533
534
535
536static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
537 int packet_len, unsigned long send_time,
538 bool direct_link,
539 struct batadv_hard_iface *if_incoming,
540 struct batadv_hard_iface *if_outgoing,
541 int own_packet)
542{
543 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
544 struct batadv_forw_packet *forw_packet_aggr;
545 struct sk_buff *skb;
546 unsigned char *skb_buff;
547 unsigned int skb_size;
548 atomic_t *queue_left = own_packet ? NULL : &bat_priv->batman_queue_left;
549
550 if (atomic_read(&bat_priv->aggregated_ogms) &&
551 packet_len < BATADV_MAX_AGGREGATION_BYTES)
552 skb_size = BATADV_MAX_AGGREGATION_BYTES;
553 else
554 skb_size = packet_len;
555
556 skb_size += ETH_HLEN;
557
558 skb = netdev_alloc_skb_ip_align(NULL, skb_size);
559 if (!skb)
560 return;
561
562 forw_packet_aggr = batadv_forw_packet_alloc(if_incoming, if_outgoing,
563 queue_left, bat_priv, skb);
564 if (!forw_packet_aggr) {
565 kfree_skb(skb);
566 return;
567 }
568
569 forw_packet_aggr->skb->priority = TC_PRIO_CONTROL;
570 skb_reserve(forw_packet_aggr->skb, ETH_HLEN);
571
572 skb_buff = skb_put(forw_packet_aggr->skb, packet_len);
573 forw_packet_aggr->packet_len = packet_len;
574 memcpy(skb_buff, packet_buff, packet_len);
575
576 forw_packet_aggr->own = own_packet;
577 forw_packet_aggr->direct_link_flags = BATADV_NO_FLAGS;
578 forw_packet_aggr->send_time = send_time;
579
580
581 if (direct_link)
582 forw_packet_aggr->direct_link_flags |= 1;
583
584 INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work,
585 batadv_iv_send_outstanding_bat_ogm_packet);
586
587 batadv_forw_packet_ogmv1_queue(bat_priv, forw_packet_aggr, send_time);
588}
589
590
591static void batadv_iv_ogm_aggregate(struct batadv_forw_packet *forw_packet_aggr,
592 const unsigned char *packet_buff,
593 int packet_len, bool direct_link)
594{
595 unsigned long new_direct_link_flag;
596
597 skb_put_data(forw_packet_aggr->skb, packet_buff, packet_len);
598 forw_packet_aggr->packet_len += packet_len;
599 forw_packet_aggr->num_packets++;
600
601
602 if (direct_link) {
603 new_direct_link_flag = BIT(forw_packet_aggr->num_packets);
604 forw_packet_aggr->direct_link_flags |= new_direct_link_flag;
605 }
606}
607
608
609
610
611
612
613
614
615
616
617
618static void batadv_iv_ogm_queue_add(struct batadv_priv *bat_priv,
619 unsigned char *packet_buff,
620 int packet_len,
621 struct batadv_hard_iface *if_incoming,
622 struct batadv_hard_iface *if_outgoing,
623 int own_packet, unsigned long send_time)
624{
625
626
627
628 struct batadv_forw_packet *forw_packet_aggr = NULL;
629 struct batadv_forw_packet *forw_packet_pos = NULL;
630 struct batadv_ogm_packet *batadv_ogm_packet;
631 bool direct_link;
632 unsigned long max_aggregation_jiffies;
633
634 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff;
635 direct_link = !!(batadv_ogm_packet->flags & BATADV_DIRECTLINK);
636 max_aggregation_jiffies = msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS);
637
638
639 spin_lock_bh(&bat_priv->forw_bat_list_lock);
640
641 if (atomic_read(&bat_priv->aggregated_ogms) && !own_packet) {
642 hlist_for_each_entry(forw_packet_pos,
643 &bat_priv->forw_bat_list, list) {
644 if (batadv_iv_ogm_can_aggregate(batadv_ogm_packet,
645 bat_priv, packet_len,
646 send_time, direct_link,
647 if_incoming,
648 if_outgoing,
649 forw_packet_pos)) {
650 forw_packet_aggr = forw_packet_pos;
651 break;
652 }
653 }
654 }
655
656
657
658
659 if (!forw_packet_aggr) {
660
661 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
662
663
664
665
666
667 if (!own_packet && atomic_read(&bat_priv->aggregated_ogms))
668 send_time += max_aggregation_jiffies;
669
670 batadv_iv_ogm_aggregate_new(packet_buff, packet_len,
671 send_time, direct_link,
672 if_incoming, if_outgoing,
673 own_packet);
674 } else {
675 batadv_iv_ogm_aggregate(forw_packet_aggr, packet_buff,
676 packet_len, direct_link);
677 spin_unlock_bh(&bat_priv->forw_bat_list_lock);
678 }
679}
680
681static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node,
682 const struct ethhdr *ethhdr,
683 struct batadv_ogm_packet *batadv_ogm_packet,
684 bool is_single_hop_neigh,
685 bool is_from_best_next_hop,
686 struct batadv_hard_iface *if_incoming,
687 struct batadv_hard_iface *if_outgoing)
688{
689 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
690 u16 tvlv_len;
691
692 if (batadv_ogm_packet->ttl <= 1) {
693 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "ttl exceeded\n");
694 return;
695 }
696
697 if (!is_from_best_next_hop) {
698
699
700
701
702
703
704 if (is_single_hop_neigh)
705 batadv_ogm_packet->flags |= BATADV_NOT_BEST_NEXT_HOP;
706 else
707 return;
708 }
709
710 tvlv_len = ntohs(batadv_ogm_packet->tvlv_len);
711
712 batadv_ogm_packet->ttl--;
713 ether_addr_copy(batadv_ogm_packet->prev_sender, ethhdr->h_source);
714
715
716 batadv_ogm_packet->tq = batadv_hop_penalty(batadv_ogm_packet->tq,
717 bat_priv);
718
719 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
720 "Forwarding packet: tq: %i, ttl: %i\n",
721 batadv_ogm_packet->tq, batadv_ogm_packet->ttl);
722
723 if (is_single_hop_neigh)
724 batadv_ogm_packet->flags |= BATADV_DIRECTLINK;
725 else
726 batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK;
727
728 batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batadv_ogm_packet,
729 BATADV_OGM_HLEN + tvlv_len,
730 if_incoming, if_outgoing, 0,
731 batadv_iv_ogm_fwd_send_time());
732}
733
734
735
736
737
738
739static void
740batadv_iv_ogm_slide_own_bcast_window(struct batadv_hard_iface *hard_iface)
741{
742 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
743 struct batadv_hashtable *hash = bat_priv->orig_hash;
744 struct hlist_head *head;
745 struct batadv_orig_node *orig_node;
746 struct batadv_orig_ifinfo *orig_ifinfo;
747 unsigned long *word;
748 u32 i;
749 u8 *w;
750
751 for (i = 0; i < hash->size; i++) {
752 head = &hash->table[i];
753
754 rcu_read_lock();
755 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
756 hlist_for_each_entry_rcu(orig_ifinfo,
757 &orig_node->ifinfo_list,
758 list) {
759 if (orig_ifinfo->if_outgoing != hard_iface)
760 continue;
761
762 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
763 word = orig_ifinfo->bat_iv.bcast_own;
764 batadv_bit_get_packet(bat_priv, word, 1, 0);
765 w = &orig_ifinfo->bat_iv.bcast_own_sum;
766 *w = bitmap_weight(word,
767 BATADV_TQ_LOCAL_WINDOW_SIZE);
768 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
769 }
770 }
771 rcu_read_unlock();
772 }
773}
774
775
776
777
778
779static void batadv_iv_ogm_schedule_buff(struct batadv_hard_iface *hard_iface)
780{
781 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
782 unsigned char **ogm_buff = &hard_iface->bat_iv.ogm_buff;
783 struct batadv_ogm_packet *batadv_ogm_packet;
784 struct batadv_hard_iface *primary_if, *tmp_hard_iface;
785 int *ogm_buff_len = &hard_iface->bat_iv.ogm_buff_len;
786 u32 seqno;
787 u16 tvlv_len = 0;
788 unsigned long send_time;
789
790 lockdep_assert_held(&hard_iface->bat_iv.ogm_buff_mutex);
791
792
793
794
795
796
797
798 if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED)
799 hard_iface->if_status = BATADV_IF_ACTIVE;
800
801 primary_if = batadv_primary_if_get_selected(bat_priv);
802
803 if (hard_iface == primary_if) {
804
805
806
807 batadv_tt_local_commit_changes(bat_priv);
808 tvlv_len = batadv_tvlv_container_ogm_append(bat_priv, ogm_buff,
809 ogm_buff_len,
810 BATADV_OGM_HLEN);
811 }
812
813 batadv_ogm_packet = (struct batadv_ogm_packet *)(*ogm_buff);
814 batadv_ogm_packet->tvlv_len = htons(tvlv_len);
815
816
817 seqno = (u32)atomic_read(&hard_iface->bat_iv.ogm_seqno);
818 batadv_ogm_packet->seqno = htonl(seqno);
819 atomic_inc(&hard_iface->bat_iv.ogm_seqno);
820
821 batadv_iv_ogm_slide_own_bcast_window(hard_iface);
822
823 send_time = batadv_iv_ogm_emit_send_time(bat_priv);
824
825 if (hard_iface != primary_if) {
826
827
828
829 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff, *ogm_buff_len,
830 hard_iface, hard_iface, 1, send_time);
831 goto out;
832 }
833
834
835
836
837 rcu_read_lock();
838 list_for_each_entry_rcu(tmp_hard_iface, &batadv_hardif_list, list) {
839 if (tmp_hard_iface->soft_iface != hard_iface->soft_iface)
840 continue;
841
842 if (!kref_get_unless_zero(&tmp_hard_iface->refcount))
843 continue;
844
845 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff,
846 *ogm_buff_len, hard_iface,
847 tmp_hard_iface, 1, send_time);
848
849 batadv_hardif_put(tmp_hard_iface);
850 }
851 rcu_read_unlock();
852
853out:
854 if (primary_if)
855 batadv_hardif_put(primary_if);
856}
857
858static void batadv_iv_ogm_schedule(struct batadv_hard_iface *hard_iface)
859{
860 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE ||
861 hard_iface->if_status == BATADV_IF_TO_BE_REMOVED)
862 return;
863
864 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex);
865 batadv_iv_ogm_schedule_buff(hard_iface);
866 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex);
867}
868
869
870
871
872
873
874
875
876
877
878
879static u8 batadv_iv_orig_ifinfo_sum(struct batadv_orig_node *orig_node,
880 struct batadv_hard_iface *if_outgoing)
881{
882 struct batadv_orig_ifinfo *orig_ifinfo;
883 u8 sum;
884
885 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, if_outgoing);
886 if (!orig_ifinfo)
887 return 0;
888
889 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
890 sum = orig_ifinfo->bat_iv.bcast_own_sum;
891 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
892
893 batadv_orig_ifinfo_put(orig_ifinfo);
894
895 return sum;
896}
897
898
899
900
901
902
903
904
905
906
907
908
909
910static void
911batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv,
912 struct batadv_orig_node *orig_node,
913 struct batadv_orig_ifinfo *orig_ifinfo,
914 const struct ethhdr *ethhdr,
915 const struct batadv_ogm_packet *batadv_ogm_packet,
916 struct batadv_hard_iface *if_incoming,
917 struct batadv_hard_iface *if_outgoing,
918 enum batadv_dup_status dup_status)
919{
920 struct batadv_neigh_ifinfo *neigh_ifinfo = NULL;
921 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
922 struct batadv_neigh_node *neigh_node = NULL;
923 struct batadv_neigh_node *tmp_neigh_node = NULL;
924 struct batadv_neigh_node *router = NULL;
925 u8 sum_orig, sum_neigh;
926 u8 *neigh_addr;
927 u8 tq_avg;
928
929 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
930 "%s(): Searching and updating originator entry of received packet\n",
931 __func__);
932
933 rcu_read_lock();
934 hlist_for_each_entry_rcu(tmp_neigh_node,
935 &orig_node->neigh_list, list) {
936 neigh_addr = tmp_neigh_node->addr;
937 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
938 tmp_neigh_node->if_incoming == if_incoming &&
939 kref_get_unless_zero(&tmp_neigh_node->refcount)) {
940 if (WARN(neigh_node, "too many matching neigh_nodes"))
941 batadv_neigh_node_put(neigh_node);
942 neigh_node = tmp_neigh_node;
943 continue;
944 }
945
946 if (dup_status != BATADV_NO_DUP)
947 continue;
948
949
950 neigh_ifinfo = batadv_neigh_ifinfo_get(tmp_neigh_node,
951 if_outgoing);
952 if (!neigh_ifinfo)
953 continue;
954
955 spin_lock_bh(&tmp_neigh_node->ifinfo_lock);
956 batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv,
957 &neigh_ifinfo->bat_iv.tq_index, 0);
958 tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv);
959 neigh_ifinfo->bat_iv.tq_avg = tq_avg;
960 spin_unlock_bh(&tmp_neigh_node->ifinfo_lock);
961
962 batadv_neigh_ifinfo_put(neigh_ifinfo);
963 neigh_ifinfo = NULL;
964 }
965
966 if (!neigh_node) {
967 struct batadv_orig_node *orig_tmp;
968
969 orig_tmp = batadv_iv_ogm_orig_get(bat_priv, ethhdr->h_source);
970 if (!orig_tmp)
971 goto unlock;
972
973 neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
974 ethhdr->h_source,
975 orig_node, orig_tmp);
976
977 batadv_orig_node_put(orig_tmp);
978 if (!neigh_node)
979 goto unlock;
980 } else {
981 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
982 "Updating existing last-hop neighbor of originator\n");
983 }
984
985 rcu_read_unlock();
986 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing);
987 if (!neigh_ifinfo)
988 goto out;
989
990 neigh_node->last_seen = jiffies;
991
992 spin_lock_bh(&neigh_node->ifinfo_lock);
993 batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv,
994 &neigh_ifinfo->bat_iv.tq_index,
995 batadv_ogm_packet->tq);
996 tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv);
997 neigh_ifinfo->bat_iv.tq_avg = tq_avg;
998 spin_unlock_bh(&neigh_node->ifinfo_lock);
999
1000 if (dup_status == BATADV_NO_DUP) {
1001 orig_ifinfo->last_ttl = batadv_ogm_packet->ttl;
1002 neigh_ifinfo->last_ttl = batadv_ogm_packet->ttl;
1003 }
1004
1005
1006
1007
1008 router = batadv_orig_router_get(orig_node, if_outgoing);
1009 if (router == neigh_node)
1010 goto out;
1011
1012 if (router) {
1013 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing);
1014 if (!router_ifinfo)
1015 goto out;
1016
1017
1018
1019
1020 if (router_ifinfo->bat_iv.tq_avg > neigh_ifinfo->bat_iv.tq_avg)
1021 goto out;
1022 }
1023
1024
1025
1026
1027 if (router_ifinfo &&
1028 neigh_ifinfo->bat_iv.tq_avg == router_ifinfo->bat_iv.tq_avg) {
1029 sum_orig = batadv_iv_orig_ifinfo_sum(router->orig_node,
1030 router->if_incoming);
1031 sum_neigh = batadv_iv_orig_ifinfo_sum(neigh_node->orig_node,
1032 neigh_node->if_incoming);
1033 if (sum_orig >= sum_neigh)
1034 goto out;
1035 }
1036
1037 batadv_update_route(bat_priv, orig_node, if_outgoing, neigh_node);
1038 goto out;
1039
1040unlock:
1041 rcu_read_unlock();
1042out:
1043 if (neigh_node)
1044 batadv_neigh_node_put(neigh_node);
1045 if (router)
1046 batadv_neigh_node_put(router);
1047 if (neigh_ifinfo)
1048 batadv_neigh_ifinfo_put(neigh_ifinfo);
1049 if (router_ifinfo)
1050 batadv_neigh_ifinfo_put(router_ifinfo);
1051}
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063static bool batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node,
1064 struct batadv_orig_node *orig_neigh_node,
1065 struct batadv_ogm_packet *batadv_ogm_packet,
1066 struct batadv_hard_iface *if_incoming,
1067 struct batadv_hard_iface *if_outgoing)
1068{
1069 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1070 struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node;
1071 struct batadv_neigh_ifinfo *neigh_ifinfo;
1072 u8 total_count;
1073 u8 orig_eq_count, neigh_rq_count, neigh_rq_inv, tq_own;
1074 unsigned int neigh_rq_inv_cube, neigh_rq_max_cube;
1075 unsigned int tq_asym_penalty, inv_asym_penalty;
1076 unsigned int combined_tq;
1077 unsigned int tq_iface_penalty;
1078 bool ret = false;
1079
1080
1081 rcu_read_lock();
1082 hlist_for_each_entry_rcu(tmp_neigh_node,
1083 &orig_neigh_node->neigh_list, list) {
1084 if (!batadv_compare_eth(tmp_neigh_node->addr,
1085 orig_neigh_node->orig))
1086 continue;
1087
1088 if (tmp_neigh_node->if_incoming != if_incoming)
1089 continue;
1090
1091 if (!kref_get_unless_zero(&tmp_neigh_node->refcount))
1092 continue;
1093
1094 neigh_node = tmp_neigh_node;
1095 break;
1096 }
1097 rcu_read_unlock();
1098
1099 if (!neigh_node)
1100 neigh_node = batadv_iv_ogm_neigh_new(if_incoming,
1101 orig_neigh_node->orig,
1102 orig_neigh_node,
1103 orig_neigh_node);
1104
1105 if (!neigh_node)
1106 goto out;
1107
1108
1109 if (orig_node == orig_neigh_node)
1110 neigh_node->last_seen = jiffies;
1111
1112 orig_node->last_seen = jiffies;
1113
1114
1115 orig_eq_count = batadv_iv_orig_ifinfo_sum(orig_neigh_node, if_incoming);
1116 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing);
1117 if (neigh_ifinfo) {
1118 neigh_rq_count = neigh_ifinfo->bat_iv.real_packet_count;
1119 batadv_neigh_ifinfo_put(neigh_ifinfo);
1120 } else {
1121 neigh_rq_count = 0;
1122 }
1123
1124
1125 if (orig_eq_count > neigh_rq_count)
1126 total_count = neigh_rq_count;
1127 else
1128 total_count = orig_eq_count;
1129
1130
1131
1132
1133 if (total_count < BATADV_TQ_LOCAL_BIDRECT_SEND_MINIMUM ||
1134 neigh_rq_count < BATADV_TQ_LOCAL_BIDRECT_RECV_MINIMUM)
1135 tq_own = 0;
1136 else
1137
1138
1139
1140
1141 tq_own = (BATADV_TQ_MAX_VALUE * total_count) / neigh_rq_count;
1142
1143
1144
1145
1146
1147
1148 neigh_rq_inv = BATADV_TQ_LOCAL_WINDOW_SIZE - neigh_rq_count;
1149 neigh_rq_inv_cube = neigh_rq_inv * neigh_rq_inv * neigh_rq_inv;
1150 neigh_rq_max_cube = BATADV_TQ_LOCAL_WINDOW_SIZE *
1151 BATADV_TQ_LOCAL_WINDOW_SIZE *
1152 BATADV_TQ_LOCAL_WINDOW_SIZE;
1153 inv_asym_penalty = BATADV_TQ_MAX_VALUE * neigh_rq_inv_cube;
1154 inv_asym_penalty /= neigh_rq_max_cube;
1155 tq_asym_penalty = BATADV_TQ_MAX_VALUE - inv_asym_penalty;
1156
1157
1158
1159
1160
1161 tq_iface_penalty = BATADV_TQ_MAX_VALUE;
1162 if (if_outgoing && if_incoming == if_outgoing &&
1163 batadv_is_wifi_hardif(if_outgoing))
1164 tq_iface_penalty = batadv_hop_penalty(BATADV_TQ_MAX_VALUE,
1165 bat_priv);
1166
1167 combined_tq = batadv_ogm_packet->tq *
1168 tq_own *
1169 tq_asym_penalty *
1170 tq_iface_penalty;
1171 combined_tq /= BATADV_TQ_MAX_VALUE *
1172 BATADV_TQ_MAX_VALUE *
1173 BATADV_TQ_MAX_VALUE;
1174 batadv_ogm_packet->tq = combined_tq;
1175
1176 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1177 "bidirectional: orig = %pM neigh = %pM => own_bcast = %2i, real recv = %2i, local tq: %3i, asym_penalty: %3i, iface_penalty: %3i, total tq: %3i, if_incoming = %s, if_outgoing = %s\n",
1178 orig_node->orig, orig_neigh_node->orig, total_count,
1179 neigh_rq_count, tq_own, tq_asym_penalty, tq_iface_penalty,
1180 batadv_ogm_packet->tq, if_incoming->net_dev->name,
1181 if_outgoing ? if_outgoing->net_dev->name : "DEFAULT");
1182
1183
1184
1185
1186 if (batadv_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT)
1187 ret = true;
1188
1189out:
1190 if (neigh_node)
1191 batadv_neigh_node_put(neigh_node);
1192 return ret;
1193}
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205static enum batadv_dup_status
1206batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
1207 const struct batadv_ogm_packet *batadv_ogm_packet,
1208 const struct batadv_hard_iface *if_incoming,
1209 struct batadv_hard_iface *if_outgoing)
1210{
1211 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1212 struct batadv_orig_node *orig_node;
1213 struct batadv_orig_ifinfo *orig_ifinfo = NULL;
1214 struct batadv_neigh_node *neigh_node;
1215 struct batadv_neigh_ifinfo *neigh_ifinfo;
1216 bool is_dup;
1217 s32 seq_diff;
1218 bool need_update = false;
1219 int set_mark;
1220 enum batadv_dup_status ret = BATADV_NO_DUP;
1221 u32 seqno = ntohl(batadv_ogm_packet->seqno);
1222 u8 *neigh_addr;
1223 u8 packet_count;
1224 unsigned long *bitmap;
1225
1226 orig_node = batadv_iv_ogm_orig_get(bat_priv, batadv_ogm_packet->orig);
1227 if (!orig_node)
1228 return BATADV_NO_DUP;
1229
1230 orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing);
1231 if (WARN_ON(!orig_ifinfo)) {
1232 batadv_orig_node_put(orig_node);
1233 return 0;
1234 }
1235
1236 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1237 seq_diff = seqno - orig_ifinfo->last_real_seqno;
1238
1239
1240 if (!hlist_empty(&orig_node->neigh_list) &&
1241 batadv_window_protected(bat_priv, seq_diff,
1242 BATADV_TQ_LOCAL_WINDOW_SIZE,
1243 &orig_ifinfo->batman_seqno_reset, NULL)) {
1244 ret = BATADV_PROTECTED;
1245 goto out;
1246 }
1247
1248 rcu_read_lock();
1249 hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1250 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node,
1251 if_outgoing);
1252 if (!neigh_ifinfo)
1253 continue;
1254
1255 neigh_addr = neigh_node->addr;
1256 is_dup = batadv_test_bit(neigh_ifinfo->bat_iv.real_bits,
1257 orig_ifinfo->last_real_seqno,
1258 seqno);
1259
1260 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
1261 neigh_node->if_incoming == if_incoming) {
1262 set_mark = 1;
1263 if (is_dup)
1264 ret = BATADV_NEIGH_DUP;
1265 } else {
1266 set_mark = 0;
1267 if (is_dup && ret != BATADV_NEIGH_DUP)
1268 ret = BATADV_ORIG_DUP;
1269 }
1270
1271
1272 bitmap = neigh_ifinfo->bat_iv.real_bits;
1273 need_update |= batadv_bit_get_packet(bat_priv, bitmap,
1274 seq_diff, set_mark);
1275
1276 packet_count = bitmap_weight(bitmap,
1277 BATADV_TQ_LOCAL_WINDOW_SIZE);
1278 neigh_ifinfo->bat_iv.real_packet_count = packet_count;
1279 batadv_neigh_ifinfo_put(neigh_ifinfo);
1280 }
1281 rcu_read_unlock();
1282
1283 if (need_update) {
1284 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1285 "%s updating last_seqno: old %u, new %u\n",
1286 if_outgoing ? if_outgoing->net_dev->name : "DEFAULT",
1287 orig_ifinfo->last_real_seqno, seqno);
1288 orig_ifinfo->last_real_seqno = seqno;
1289 }
1290
1291out:
1292 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1293 batadv_orig_node_put(orig_node);
1294 batadv_orig_ifinfo_put(orig_ifinfo);
1295 return ret;
1296}
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307static void
1308batadv_iv_ogm_process_per_outif(const struct sk_buff *skb, int ogm_offset,
1309 struct batadv_orig_node *orig_node,
1310 struct batadv_hard_iface *if_incoming,
1311 struct batadv_hard_iface *if_outgoing)
1312{
1313 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1314 struct batadv_hardif_neigh_node *hardif_neigh = NULL;
1315 struct batadv_neigh_node *router = NULL;
1316 struct batadv_neigh_node *router_router = NULL;
1317 struct batadv_orig_node *orig_neigh_node;
1318 struct batadv_orig_ifinfo *orig_ifinfo;
1319 struct batadv_neigh_node *orig_neigh_router = NULL;
1320 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
1321 struct batadv_ogm_packet *ogm_packet;
1322 enum batadv_dup_status dup_status;
1323 bool is_from_best_next_hop = false;
1324 bool is_single_hop_neigh = false;
1325 bool sameseq, similar_ttl;
1326 struct sk_buff *skb_priv;
1327 struct ethhdr *ethhdr;
1328 u8 *prev_sender;
1329 bool is_bidirect;
1330
1331
1332
1333
1334 skb_priv = skb_copy(skb, GFP_ATOMIC);
1335 if (!skb_priv)
1336 return;
1337
1338 ethhdr = eth_hdr(skb_priv);
1339 ogm_packet = (struct batadv_ogm_packet *)(skb_priv->data + ogm_offset);
1340
1341 dup_status = batadv_iv_ogm_update_seqnos(ethhdr, ogm_packet,
1342 if_incoming, if_outgoing);
1343 if (batadv_compare_eth(ethhdr->h_source, ogm_packet->orig))
1344 is_single_hop_neigh = true;
1345
1346 if (dup_status == BATADV_PROTECTED) {
1347 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1348 "Drop packet: packet within seqno protection time (sender: %pM)\n",
1349 ethhdr->h_source);
1350 goto out;
1351 }
1352
1353 if (ogm_packet->tq == 0) {
1354 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1355 "Drop packet: originator packet with tq equal 0\n");
1356 goto out;
1357 }
1358
1359 if (is_single_hop_neigh) {
1360 hardif_neigh = batadv_hardif_neigh_get(if_incoming,
1361 ethhdr->h_source);
1362 if (hardif_neigh)
1363 hardif_neigh->last_seen = jiffies;
1364 }
1365
1366 router = batadv_orig_router_get(orig_node, if_outgoing);
1367 if (router) {
1368 router_router = batadv_orig_router_get(router->orig_node,
1369 if_outgoing);
1370 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing);
1371 }
1372
1373 if ((router_ifinfo && router_ifinfo->bat_iv.tq_avg != 0) &&
1374 (batadv_compare_eth(router->addr, ethhdr->h_source)))
1375 is_from_best_next_hop = true;
1376
1377 prev_sender = ogm_packet->prev_sender;
1378
1379 if (router && router_router &&
1380 (batadv_compare_eth(router->addr, prev_sender)) &&
1381 !(batadv_compare_eth(ogm_packet->orig, prev_sender)) &&
1382 (batadv_compare_eth(router->addr, router_router->addr))) {
1383 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1384 "Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",
1385 ethhdr->h_source);
1386 goto out;
1387 }
1388
1389 if (if_outgoing == BATADV_IF_DEFAULT)
1390 batadv_tvlv_ogm_receive(bat_priv, ogm_packet, orig_node);
1391
1392
1393
1394
1395 if (is_single_hop_neigh)
1396 orig_neigh_node = orig_node;
1397 else
1398 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv,
1399 ethhdr->h_source);
1400
1401 if (!orig_neigh_node)
1402 goto out;
1403
1404
1405 batadv_nc_update_nc_node(bat_priv, orig_node, orig_neigh_node,
1406 ogm_packet, is_single_hop_neigh);
1407
1408 orig_neigh_router = batadv_orig_router_get(orig_neigh_node,
1409 if_outgoing);
1410
1411
1412
1413
1414 if (!is_single_hop_neigh && !orig_neigh_router) {
1415 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1416 "Drop packet: OGM via unknown neighbor!\n");
1417 goto out_neigh;
1418 }
1419
1420 is_bidirect = batadv_iv_ogm_calc_tq(orig_node, orig_neigh_node,
1421 ogm_packet, if_incoming,
1422 if_outgoing);
1423
1424
1425
1426
1427 orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing);
1428 if (!orig_ifinfo)
1429 goto out_neigh;
1430
1431 sameseq = orig_ifinfo->last_real_seqno == ntohl(ogm_packet->seqno);
1432 similar_ttl = (orig_ifinfo->last_ttl - 3) <= ogm_packet->ttl;
1433
1434 if (is_bidirect && (dup_status == BATADV_NO_DUP ||
1435 (sameseq && similar_ttl))) {
1436 batadv_iv_ogm_orig_update(bat_priv, orig_node,
1437 orig_ifinfo, ethhdr,
1438 ogm_packet, if_incoming,
1439 if_outgoing, dup_status);
1440 }
1441 batadv_orig_ifinfo_put(orig_ifinfo);
1442
1443
1444 if (if_outgoing == BATADV_IF_DEFAULT)
1445 goto out_neigh;
1446
1447
1448 if (is_single_hop_neigh) {
1449
1450
1451
1452 if (ogm_packet->ttl <= 2 &&
1453 if_incoming != if_outgoing) {
1454 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1455 "Drop packet: OGM from secondary interface and wrong outgoing interface\n");
1456 goto out_neigh;
1457 }
1458
1459 batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet,
1460 is_single_hop_neigh,
1461 is_from_best_next_hop, if_incoming,
1462 if_outgoing);
1463
1464 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1465 "Forwarding packet: rebroadcast neighbor packet with direct link flag\n");
1466 goto out_neigh;
1467 }
1468
1469
1470 if (!is_bidirect) {
1471 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1472 "Drop packet: not received via bidirectional link\n");
1473 goto out_neigh;
1474 }
1475
1476 if (dup_status == BATADV_NEIGH_DUP) {
1477 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1478 "Drop packet: duplicate packet received\n");
1479 goto out_neigh;
1480 }
1481
1482 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1483 "Forwarding packet: rebroadcast originator packet\n");
1484 batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet,
1485 is_single_hop_neigh, is_from_best_next_hop,
1486 if_incoming, if_outgoing);
1487
1488out_neigh:
1489 if (orig_neigh_node && !is_single_hop_neigh)
1490 batadv_orig_node_put(orig_neigh_node);
1491out:
1492 if (router_ifinfo)
1493 batadv_neigh_ifinfo_put(router_ifinfo);
1494 if (router)
1495 batadv_neigh_node_put(router);
1496 if (router_router)
1497 batadv_neigh_node_put(router_router);
1498 if (orig_neigh_router)
1499 batadv_neigh_node_put(orig_neigh_router);
1500 if (hardif_neigh)
1501 batadv_hardif_neigh_put(hardif_neigh);
1502
1503 consume_skb(skb_priv);
1504}
1505
1506
1507
1508
1509
1510
1511
1512
1513static void batadv_iv_ogm_process_reply(struct batadv_ogm_packet *ogm_packet,
1514 struct batadv_hard_iface *if_incoming,
1515 struct batadv_orig_node *orig_node,
1516 u32 if_incoming_seqno)
1517{
1518 struct batadv_orig_ifinfo *orig_ifinfo;
1519 s32 bit_pos;
1520 u8 *weight;
1521
1522
1523
1524
1525 if (!(ogm_packet->flags & BATADV_DIRECTLINK))
1526 return;
1527
1528 if (!batadv_compare_eth(if_incoming->net_dev->dev_addr,
1529 ogm_packet->orig))
1530 return;
1531
1532 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, if_incoming);
1533 if (!orig_ifinfo)
1534 return;
1535
1536
1537 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1538 bit_pos = if_incoming_seqno - 2;
1539 bit_pos -= ntohl(ogm_packet->seqno);
1540 batadv_set_bit(orig_ifinfo->bat_iv.bcast_own, bit_pos);
1541 weight = &orig_ifinfo->bat_iv.bcast_own_sum;
1542 *weight = bitmap_weight(orig_ifinfo->bat_iv.bcast_own,
1543 BATADV_TQ_LOCAL_WINDOW_SIZE);
1544 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock);
1545
1546 batadv_orig_ifinfo_put(orig_ifinfo);
1547}
1548
1549
1550
1551
1552
1553
1554
1555static void batadv_iv_ogm_process(const struct sk_buff *skb, int ogm_offset,
1556 struct batadv_hard_iface *if_incoming)
1557{
1558 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1559 struct batadv_orig_node *orig_neigh_node, *orig_node;
1560 struct batadv_hard_iface *hard_iface;
1561 struct batadv_ogm_packet *ogm_packet;
1562 u32 if_incoming_seqno;
1563 bool has_directlink_flag;
1564 struct ethhdr *ethhdr;
1565 bool is_my_oldorig = false;
1566 bool is_my_addr = false;
1567 bool is_my_orig = false;
1568
1569 ogm_packet = (struct batadv_ogm_packet *)(skb->data + ogm_offset);
1570 ethhdr = eth_hdr(skb);
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584 if (ogm_packet->packet_type != BATADV_IV_OGM)
1585 return;
1586
1587
1588 if_incoming_seqno = atomic_read(&if_incoming->bat_iv.ogm_seqno);
1589
1590 if (ogm_packet->flags & BATADV_DIRECTLINK)
1591 has_directlink_flag = true;
1592 else
1593 has_directlink_flag = false;
1594
1595 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1596 "Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, tq %d, TTL %d, V %d, IDF %d)\n",
1597 ethhdr->h_source, if_incoming->net_dev->name,
1598 if_incoming->net_dev->dev_addr, ogm_packet->orig,
1599 ogm_packet->prev_sender, ntohl(ogm_packet->seqno),
1600 ogm_packet->tq, ogm_packet->ttl,
1601 ogm_packet->version, has_directlink_flag);
1602
1603 rcu_read_lock();
1604 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1605 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1606 continue;
1607
1608 if (hard_iface->soft_iface != if_incoming->soft_iface)
1609 continue;
1610
1611 if (batadv_compare_eth(ethhdr->h_source,
1612 hard_iface->net_dev->dev_addr))
1613 is_my_addr = true;
1614
1615 if (batadv_compare_eth(ogm_packet->orig,
1616 hard_iface->net_dev->dev_addr))
1617 is_my_orig = true;
1618
1619 if (batadv_compare_eth(ogm_packet->prev_sender,
1620 hard_iface->net_dev->dev_addr))
1621 is_my_oldorig = true;
1622 }
1623 rcu_read_unlock();
1624
1625 if (is_my_addr) {
1626 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1627 "Drop packet: received my own broadcast (sender: %pM)\n",
1628 ethhdr->h_source);
1629 return;
1630 }
1631
1632 if (is_my_orig) {
1633 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv,
1634 ethhdr->h_source);
1635 if (!orig_neigh_node)
1636 return;
1637
1638 batadv_iv_ogm_process_reply(ogm_packet, if_incoming,
1639 orig_neigh_node, if_incoming_seqno);
1640
1641 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1642 "Drop packet: originator packet from myself (via neighbor)\n");
1643 batadv_orig_node_put(orig_neigh_node);
1644 return;
1645 }
1646
1647 if (is_my_oldorig) {
1648 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1649 "Drop packet: ignoring all rebroadcast echos (sender: %pM)\n",
1650 ethhdr->h_source);
1651 return;
1652 }
1653
1654 if (ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP) {
1655 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1656 "Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
1657 ethhdr->h_source);
1658 return;
1659 }
1660
1661 orig_node = batadv_iv_ogm_orig_get(bat_priv, ogm_packet->orig);
1662 if (!orig_node)
1663 return;
1664
1665 batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node,
1666 if_incoming, BATADV_IF_DEFAULT);
1667
1668 rcu_read_lock();
1669 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
1670 if (hard_iface->if_status != BATADV_IF_ACTIVE)
1671 continue;
1672
1673 if (hard_iface->soft_iface != bat_priv->soft_iface)
1674 continue;
1675
1676 if (!kref_get_unless_zero(&hard_iface->refcount))
1677 continue;
1678
1679 batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node,
1680 if_incoming, hard_iface);
1681
1682 batadv_hardif_put(hard_iface);
1683 }
1684 rcu_read_unlock();
1685
1686 batadv_orig_node_put(orig_node);
1687}
1688
1689static void batadv_iv_send_outstanding_bat_ogm_packet(struct work_struct *work)
1690{
1691 struct delayed_work *delayed_work;
1692 struct batadv_forw_packet *forw_packet;
1693 struct batadv_priv *bat_priv;
1694 bool dropped = false;
1695
1696 delayed_work = to_delayed_work(work);
1697 forw_packet = container_of(delayed_work, struct batadv_forw_packet,
1698 delayed_work);
1699 bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface);
1700
1701 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) {
1702 dropped = true;
1703 goto out;
1704 }
1705
1706 batadv_iv_ogm_emit(forw_packet);
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716 if (forw_packet->own &&
1717 forw_packet->if_incoming == forw_packet->if_outgoing)
1718 batadv_iv_ogm_schedule(forw_packet->if_incoming);
1719
1720out:
1721
1722 if (batadv_forw_packet_steal(forw_packet,
1723 &bat_priv->forw_bat_list_lock))
1724 batadv_forw_packet_free(forw_packet, dropped);
1725}
1726
1727static int batadv_iv_ogm_receive(struct sk_buff *skb,
1728 struct batadv_hard_iface *if_incoming)
1729{
1730 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
1731 struct batadv_ogm_packet *ogm_packet;
1732 u8 *packet_pos;
1733 int ogm_offset;
1734 bool res;
1735 int ret = NET_RX_DROP;
1736
1737 res = batadv_check_management_packet(skb, if_incoming, BATADV_OGM_HLEN);
1738 if (!res)
1739 goto free_skb;
1740
1741
1742
1743
1744 if (bat_priv->algo_ops->iface.enable != batadv_iv_ogm_iface_enable)
1745 goto free_skb;
1746
1747 batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_RX);
1748 batadv_add_counter(bat_priv, BATADV_CNT_MGMT_RX_BYTES,
1749 skb->len + ETH_HLEN);
1750
1751 ogm_offset = 0;
1752 ogm_packet = (struct batadv_ogm_packet *)skb->data;
1753
1754
1755 while (batadv_iv_ogm_aggr_packet(ogm_offset, skb_headlen(skb),
1756 ogm_packet)) {
1757 batadv_iv_ogm_process(skb, ogm_offset, if_incoming);
1758
1759 ogm_offset += BATADV_OGM_HLEN;
1760 ogm_offset += ntohs(ogm_packet->tvlv_len);
1761
1762 packet_pos = skb->data + ogm_offset;
1763 ogm_packet = (struct batadv_ogm_packet *)packet_pos;
1764 }
1765
1766 ret = NET_RX_SUCCESS;
1767
1768free_skb:
1769 if (ret == NET_RX_SUCCESS)
1770 consume_skb(skb);
1771 else
1772 kfree_skb(skb);
1773
1774 return ret;
1775}
1776
1777#ifdef CONFIG_BATMAN_ADV_DEBUGFS
1778
1779
1780
1781
1782
1783
1784
1785
1786static void
1787batadv_iv_ogm_orig_print_neigh(struct batadv_orig_node *orig_node,
1788 struct batadv_hard_iface *if_outgoing,
1789 struct seq_file *seq)
1790{
1791 struct batadv_neigh_node *neigh_node;
1792 struct batadv_neigh_ifinfo *n_ifinfo;
1793
1794 hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
1795 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
1796 if (!n_ifinfo)
1797 continue;
1798
1799 seq_printf(seq, " %pM (%3i)",
1800 neigh_node->addr,
1801 n_ifinfo->bat_iv.tq_avg);
1802
1803 batadv_neigh_ifinfo_put(n_ifinfo);
1804 }
1805}
1806
1807
1808
1809
1810
1811
1812
1813static void batadv_iv_ogm_orig_print(struct batadv_priv *bat_priv,
1814 struct seq_file *seq,
1815 struct batadv_hard_iface *if_outgoing)
1816{
1817 struct batadv_neigh_node *neigh_node;
1818 struct batadv_hashtable *hash = bat_priv->orig_hash;
1819 int last_seen_msecs, last_seen_secs;
1820 struct batadv_orig_node *orig_node;
1821 struct batadv_neigh_ifinfo *n_ifinfo;
1822 unsigned long last_seen_jiffies;
1823 struct hlist_head *head;
1824 int batman_count = 0;
1825 u32 i;
1826
1827 seq_puts(seq,
1828 " Originator last-seen (#/255) Nexthop [outgoingIF]: Potential nexthops ...\n");
1829
1830 for (i = 0; i < hash->size; i++) {
1831 head = &hash->table[i];
1832
1833 rcu_read_lock();
1834 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
1835 neigh_node = batadv_orig_router_get(orig_node,
1836 if_outgoing);
1837 if (!neigh_node)
1838 continue;
1839
1840 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node,
1841 if_outgoing);
1842 if (!n_ifinfo)
1843 goto next;
1844
1845 if (n_ifinfo->bat_iv.tq_avg == 0)
1846 goto next;
1847
1848 last_seen_jiffies = jiffies - orig_node->last_seen;
1849 last_seen_msecs = jiffies_to_msecs(last_seen_jiffies);
1850 last_seen_secs = last_seen_msecs / 1000;
1851 last_seen_msecs = last_seen_msecs % 1000;
1852
1853 seq_printf(seq, "%pM %4i.%03is (%3i) %pM [%10s]:",
1854 orig_node->orig, last_seen_secs,
1855 last_seen_msecs, n_ifinfo->bat_iv.tq_avg,
1856 neigh_node->addr,
1857 neigh_node->if_incoming->net_dev->name);
1858
1859 batadv_iv_ogm_orig_print_neigh(orig_node, if_outgoing,
1860 seq);
1861 seq_putc(seq, '\n');
1862 batman_count++;
1863
1864next:
1865 batadv_neigh_node_put(neigh_node);
1866 if (n_ifinfo)
1867 batadv_neigh_ifinfo_put(n_ifinfo);
1868 }
1869 rcu_read_unlock();
1870 }
1871
1872 if (batman_count == 0)
1873 seq_puts(seq, "No batman nodes in range ...\n");
1874}
1875#endif
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886static bool
1887batadv_iv_ogm_neigh_get_tq_avg(struct batadv_neigh_node *neigh_node,
1888 struct batadv_hard_iface *if_outgoing,
1889 u8 *tq_avg)
1890{
1891 struct batadv_neigh_ifinfo *n_ifinfo;
1892
1893 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
1894 if (!n_ifinfo)
1895 return false;
1896
1897 *tq_avg = n_ifinfo->bat_iv.tq_avg;
1898 batadv_neigh_ifinfo_put(n_ifinfo);
1899
1900 return true;
1901}
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917static int
1918batadv_iv_ogm_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
1919 struct batadv_priv *bat_priv,
1920 struct batadv_hard_iface *if_outgoing,
1921 struct batadv_orig_node *orig_node,
1922 struct batadv_neigh_node *neigh_node,
1923 bool best)
1924{
1925 void *hdr;
1926 u8 tq_avg;
1927 unsigned int last_seen_msecs;
1928
1929 last_seen_msecs = jiffies_to_msecs(jiffies - orig_node->last_seen);
1930
1931 if (!batadv_iv_ogm_neigh_get_tq_avg(neigh_node, if_outgoing, &tq_avg))
1932 return 0;
1933
1934 if (if_outgoing != BATADV_IF_DEFAULT &&
1935 if_outgoing != neigh_node->if_incoming)
1936 return 0;
1937
1938 hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
1939 NLM_F_MULTI, BATADV_CMD_GET_ORIGINATORS);
1940 if (!hdr)
1941 return -ENOBUFS;
1942
1943 if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
1944 orig_node->orig) ||
1945 nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
1946 neigh_node->addr) ||
1947 nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
1948 neigh_node->if_incoming->net_dev->ifindex) ||
1949 nla_put_u8(msg, BATADV_ATTR_TQ, tq_avg) ||
1950 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
1951 last_seen_msecs))
1952 goto nla_put_failure;
1953
1954 if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
1955 goto nla_put_failure;
1956
1957 genlmsg_end(msg, hdr);
1958 return 0;
1959
1960 nla_put_failure:
1961 genlmsg_cancel(msg, hdr);
1962 return -EMSGSIZE;
1963}
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979static int
1980batadv_iv_ogm_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
1981 struct batadv_priv *bat_priv,
1982 struct batadv_hard_iface *if_outgoing,
1983 struct batadv_orig_node *orig_node, int *sub_s)
1984{
1985 struct batadv_neigh_node *neigh_node_best;
1986 struct batadv_neigh_node *neigh_node;
1987 int sub = 0;
1988 bool best;
1989 u8 tq_avg_best;
1990
1991 neigh_node_best = batadv_orig_router_get(orig_node, if_outgoing);
1992 if (!neigh_node_best)
1993 goto out;
1994
1995 if (!batadv_iv_ogm_neigh_get_tq_avg(neigh_node_best, if_outgoing,
1996 &tq_avg_best))
1997 goto out;
1998
1999 if (tq_avg_best == 0)
2000 goto out;
2001
2002 hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
2003 if (sub++ < *sub_s)
2004 continue;
2005
2006 best = (neigh_node == neigh_node_best);
2007
2008 if (batadv_iv_ogm_orig_dump_subentry(msg, portid, seq,
2009 bat_priv, if_outgoing,
2010 orig_node, neigh_node,
2011 best)) {
2012 batadv_neigh_node_put(neigh_node_best);
2013
2014 *sub_s = sub - 1;
2015 return -EMSGSIZE;
2016 }
2017 }
2018
2019 out:
2020 if (neigh_node_best)
2021 batadv_neigh_node_put(neigh_node_best);
2022
2023 *sub_s = 0;
2024 return 0;
2025}
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041static int
2042batadv_iv_ogm_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
2043 struct batadv_priv *bat_priv,
2044 struct batadv_hard_iface *if_outgoing,
2045 struct hlist_head *head, int *idx_s, int *sub)
2046{
2047 struct batadv_orig_node *orig_node;
2048 int idx = 0;
2049
2050 rcu_read_lock();
2051 hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
2052 if (idx++ < *idx_s)
2053 continue;
2054
2055 if (batadv_iv_ogm_orig_dump_entry(msg, portid, seq, bat_priv,
2056 if_outgoing, orig_node,
2057 sub)) {
2058 rcu_read_unlock();
2059 *idx_s = idx - 1;
2060 return -EMSGSIZE;
2061 }
2062 }
2063 rcu_read_unlock();
2064
2065 *idx_s = 0;
2066 *sub = 0;
2067 return 0;
2068}
2069
2070
2071
2072
2073
2074
2075
2076
2077static void
2078batadv_iv_ogm_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
2079 struct batadv_priv *bat_priv,
2080 struct batadv_hard_iface *if_outgoing)
2081{
2082 struct batadv_hashtable *hash = bat_priv->orig_hash;
2083 struct hlist_head *head;
2084 int bucket = cb->args[0];
2085 int idx = cb->args[1];
2086 int sub = cb->args[2];
2087 int portid = NETLINK_CB(cb->skb).portid;
2088
2089 while (bucket < hash->size) {
2090 head = &hash->table[bucket];
2091
2092 if (batadv_iv_ogm_orig_dump_bucket(msg, portid,
2093 cb->nlh->nlmsg_seq,
2094 bat_priv, if_outgoing, head,
2095 &idx, &sub))
2096 break;
2097
2098 bucket++;
2099 }
2100
2101 cb->args[0] = bucket;
2102 cb->args[1] = idx;
2103 cb->args[2] = sub;
2104}
2105
2106#ifdef CONFIG_BATMAN_ADV_DEBUGFS
2107
2108
2109
2110
2111
2112static void
2113batadv_iv_hardif_neigh_print(struct seq_file *seq,
2114 struct batadv_hardif_neigh_node *hardif_neigh)
2115{
2116 int last_secs, last_msecs;
2117
2118 last_secs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen) / 1000;
2119 last_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen) % 1000;
2120
2121 seq_printf(seq, " %10s %pM %4i.%03is\n",
2122 hardif_neigh->if_incoming->net_dev->name,
2123 hardif_neigh->addr, last_secs, last_msecs);
2124}
2125
2126
2127
2128
2129
2130
2131static void batadv_iv_neigh_print(struct batadv_priv *bat_priv,
2132 struct seq_file *seq)
2133{
2134 struct net_device *net_dev = (struct net_device *)seq->private;
2135 struct batadv_hardif_neigh_node *hardif_neigh;
2136 struct batadv_hard_iface *hard_iface;
2137 int batman_count = 0;
2138
2139 seq_puts(seq, " IF Neighbor last-seen\n");
2140
2141 rcu_read_lock();
2142 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
2143 if (hard_iface->soft_iface != net_dev)
2144 continue;
2145
2146 hlist_for_each_entry_rcu(hardif_neigh,
2147 &hard_iface->neigh_list, list) {
2148 batadv_iv_hardif_neigh_print(seq, hardif_neigh);
2149 batman_count++;
2150 }
2151 }
2152 rcu_read_unlock();
2153
2154 if (batman_count == 0)
2155 seq_puts(seq, "No batman nodes in range ...\n");
2156}
2157#endif
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173static bool batadv_iv_ogm_neigh_diff(struct batadv_neigh_node *neigh1,
2174 struct batadv_hard_iface *if_outgoing1,
2175 struct batadv_neigh_node *neigh2,
2176 struct batadv_hard_iface *if_outgoing2,
2177 int *diff)
2178{
2179 struct batadv_neigh_ifinfo *neigh1_ifinfo, *neigh2_ifinfo;
2180 u8 tq1, tq2;
2181 bool ret = true;
2182
2183 neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
2184 neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
2185
2186 if (!neigh1_ifinfo || !neigh2_ifinfo) {
2187 ret = false;
2188 goto out;
2189 }
2190
2191 tq1 = neigh1_ifinfo->bat_iv.tq_avg;
2192 tq2 = neigh2_ifinfo->bat_iv.tq_avg;
2193 *diff = (int)tq1 - (int)tq2;
2194
2195out:
2196 if (neigh1_ifinfo)
2197 batadv_neigh_ifinfo_put(neigh1_ifinfo);
2198 if (neigh2_ifinfo)
2199 batadv_neigh_ifinfo_put(neigh2_ifinfo);
2200
2201 return ret;
2202}
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213static int
2214batadv_iv_ogm_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
2215 struct batadv_hardif_neigh_node *hardif_neigh)
2216{
2217 void *hdr;
2218 unsigned int last_seen_msecs;
2219
2220 last_seen_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen);
2221
2222 hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
2223 NLM_F_MULTI, BATADV_CMD_GET_NEIGHBORS);
2224 if (!hdr)
2225 return -ENOBUFS;
2226
2227 if (nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
2228 hardif_neigh->addr) ||
2229 nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
2230 hardif_neigh->if_incoming->net_dev->ifindex) ||
2231 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
2232 last_seen_msecs))
2233 goto nla_put_failure;
2234
2235 genlmsg_end(msg, hdr);
2236 return 0;
2237
2238 nla_put_failure:
2239 genlmsg_cancel(msg, hdr);
2240 return -EMSGSIZE;
2241}
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257static int
2258batadv_iv_ogm_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
2259 struct batadv_priv *bat_priv,
2260 struct batadv_hard_iface *hard_iface,
2261 int *idx_s)
2262{
2263 struct batadv_hardif_neigh_node *hardif_neigh;
2264 int idx = 0;
2265
2266 hlist_for_each_entry_rcu(hardif_neigh,
2267 &hard_iface->neigh_list, list) {
2268 if (idx++ < *idx_s)
2269 continue;
2270
2271 if (batadv_iv_ogm_neigh_dump_neigh(msg, portid, seq,
2272 hardif_neigh)) {
2273 *idx_s = idx - 1;
2274 return -EMSGSIZE;
2275 }
2276 }
2277
2278 *idx_s = 0;
2279 return 0;
2280}
2281
2282
2283
2284
2285
2286
2287
2288
2289static void
2290batadv_iv_ogm_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
2291 struct batadv_priv *bat_priv,
2292 struct batadv_hard_iface *single_hardif)
2293{
2294 struct batadv_hard_iface *hard_iface;
2295 int i_hardif = 0;
2296 int i_hardif_s = cb->args[0];
2297 int idx = cb->args[1];
2298 int portid = NETLINK_CB(cb->skb).portid;
2299
2300 rcu_read_lock();
2301 if (single_hardif) {
2302 if (i_hardif_s == 0) {
2303 if (batadv_iv_ogm_neigh_dump_hardif(msg, portid,
2304 cb->nlh->nlmsg_seq,
2305 bat_priv,
2306 single_hardif,
2307 &idx) == 0)
2308 i_hardif++;
2309 }
2310 } else {
2311 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list,
2312 list) {
2313 if (hard_iface->soft_iface != bat_priv->soft_iface)
2314 continue;
2315
2316 if (i_hardif++ < i_hardif_s)
2317 continue;
2318
2319 if (batadv_iv_ogm_neigh_dump_hardif(msg, portid,
2320 cb->nlh->nlmsg_seq,
2321 bat_priv,
2322 hard_iface, &idx)) {
2323 i_hardif--;
2324 break;
2325 }
2326 }
2327 }
2328 rcu_read_unlock();
2329
2330 cb->args[0] = i_hardif;
2331 cb->args[1] = idx;
2332}
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344static int batadv_iv_ogm_neigh_cmp(struct batadv_neigh_node *neigh1,
2345 struct batadv_hard_iface *if_outgoing1,
2346 struct batadv_neigh_node *neigh2,
2347 struct batadv_hard_iface *if_outgoing2)
2348{
2349 bool ret;
2350 int diff;
2351
2352 ret = batadv_iv_ogm_neigh_diff(neigh1, if_outgoing1, neigh2,
2353 if_outgoing2, &diff);
2354 if (!ret)
2355 return 0;
2356
2357 return diff;
2358}
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371static bool
2372batadv_iv_ogm_neigh_is_sob(struct batadv_neigh_node *neigh1,
2373 struct batadv_hard_iface *if_outgoing1,
2374 struct batadv_neigh_node *neigh2,
2375 struct batadv_hard_iface *if_outgoing2)
2376{
2377 bool ret;
2378 int diff;
2379
2380 ret = batadv_iv_ogm_neigh_diff(neigh1, if_outgoing1, neigh2,
2381 if_outgoing2, &diff);
2382 if (!ret)
2383 return false;
2384
2385 ret = diff > -BATADV_TQ_SIMILARITY_THRESHOLD;
2386 return ret;
2387}
2388
2389static void batadv_iv_iface_enabled(struct batadv_hard_iface *hard_iface)
2390{
2391
2392 batadv_iv_ogm_schedule(hard_iface);
2393}
2394
2395
2396
2397
2398
2399static void batadv_iv_init_sel_class(struct batadv_priv *bat_priv)
2400{
2401
2402 atomic_set(&bat_priv->gw.sel_class, 20);
2403}
2404
2405static struct batadv_gw_node *
2406batadv_iv_gw_get_best_gw_node(struct batadv_priv *bat_priv)
2407{
2408 struct batadv_neigh_node *router;
2409 struct batadv_neigh_ifinfo *router_ifinfo;
2410 struct batadv_gw_node *gw_node, *curr_gw = NULL;
2411 u64 max_gw_factor = 0;
2412 u64 tmp_gw_factor = 0;
2413 u8 max_tq = 0;
2414 u8 tq_avg;
2415 struct batadv_orig_node *orig_node;
2416
2417 rcu_read_lock();
2418 hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) {
2419 orig_node = gw_node->orig_node;
2420 router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
2421 if (!router)
2422 continue;
2423
2424 router_ifinfo = batadv_neigh_ifinfo_get(router,
2425 BATADV_IF_DEFAULT);
2426 if (!router_ifinfo)
2427 goto next;
2428
2429 if (!kref_get_unless_zero(&gw_node->refcount))
2430 goto next;
2431
2432 tq_avg = router_ifinfo->bat_iv.tq_avg;
2433
2434 switch (atomic_read(&bat_priv->gw.sel_class)) {
2435 case 1:
2436 tmp_gw_factor = tq_avg * tq_avg;
2437 tmp_gw_factor *= gw_node->bandwidth_down;
2438 tmp_gw_factor *= 100 * 100;
2439 tmp_gw_factor >>= 18;
2440
2441 if (tmp_gw_factor > max_gw_factor ||
2442 (tmp_gw_factor == max_gw_factor &&
2443 tq_avg > max_tq)) {
2444 if (curr_gw)
2445 batadv_gw_node_put(curr_gw);
2446 curr_gw = gw_node;
2447 kref_get(&curr_gw->refcount);
2448 }
2449 break;
2450
2451 default:
2452
2453
2454
2455
2456
2457
2458 if (tq_avg > max_tq) {
2459 if (curr_gw)
2460 batadv_gw_node_put(curr_gw);
2461 curr_gw = gw_node;
2462 kref_get(&curr_gw->refcount);
2463 }
2464 break;
2465 }
2466
2467 if (tq_avg > max_tq)
2468 max_tq = tq_avg;
2469
2470 if (tmp_gw_factor > max_gw_factor)
2471 max_gw_factor = tmp_gw_factor;
2472
2473 batadv_gw_node_put(gw_node);
2474
2475next:
2476 batadv_neigh_node_put(router);
2477 if (router_ifinfo)
2478 batadv_neigh_ifinfo_put(router_ifinfo);
2479 }
2480 rcu_read_unlock();
2481
2482 return curr_gw;
2483}
2484
2485static bool batadv_iv_gw_is_eligible(struct batadv_priv *bat_priv,
2486 struct batadv_orig_node *curr_gw_orig,
2487 struct batadv_orig_node *orig_node)
2488{
2489 struct batadv_neigh_ifinfo *router_orig_ifinfo = NULL;
2490 struct batadv_neigh_ifinfo *router_gw_ifinfo = NULL;
2491 struct batadv_neigh_node *router_gw = NULL;
2492 struct batadv_neigh_node *router_orig = NULL;
2493 u8 gw_tq_avg, orig_tq_avg;
2494 bool ret = false;
2495
2496
2497 if (atomic_read(&bat_priv->gw.sel_class) <= 2)
2498 return false;
2499
2500 router_gw = batadv_orig_router_get(curr_gw_orig, BATADV_IF_DEFAULT);
2501 if (!router_gw) {
2502 ret = true;
2503 goto out;
2504 }
2505
2506 router_gw_ifinfo = batadv_neigh_ifinfo_get(router_gw,
2507 BATADV_IF_DEFAULT);
2508 if (!router_gw_ifinfo) {
2509 ret = true;
2510 goto out;
2511 }
2512
2513 router_orig = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
2514 if (!router_orig)
2515 goto out;
2516
2517 router_orig_ifinfo = batadv_neigh_ifinfo_get(router_orig,
2518 BATADV_IF_DEFAULT);
2519 if (!router_orig_ifinfo)
2520 goto out;
2521
2522 gw_tq_avg = router_gw_ifinfo->bat_iv.tq_avg;
2523 orig_tq_avg = router_orig_ifinfo->bat_iv.tq_avg;
2524
2525
2526 if (orig_tq_avg < gw_tq_avg)
2527 goto out;
2528
2529
2530
2531
2532 if ((atomic_read(&bat_priv->gw.sel_class) > 3) &&
2533 (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw.sel_class)))
2534 goto out;
2535
2536 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
2537 "Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n",
2538 gw_tq_avg, orig_tq_avg);
2539
2540 ret = true;
2541out:
2542 if (router_gw_ifinfo)
2543 batadv_neigh_ifinfo_put(router_gw_ifinfo);
2544 if (router_orig_ifinfo)
2545 batadv_neigh_ifinfo_put(router_orig_ifinfo);
2546 if (router_gw)
2547 batadv_neigh_node_put(router_gw);
2548 if (router_orig)
2549 batadv_neigh_node_put(router_orig);
2550
2551 return ret;
2552}
2553
2554#ifdef CONFIG_BATMAN_ADV_DEBUGFS
2555
2556static int batadv_iv_gw_write_buffer_text(struct batadv_priv *bat_priv,
2557 struct seq_file *seq,
2558 const struct batadv_gw_node *gw_node)
2559{
2560 struct batadv_gw_node *curr_gw;
2561 struct batadv_neigh_node *router;
2562 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
2563 int ret = -1;
2564
2565 router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
2566 if (!router)
2567 goto out;
2568
2569 router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
2570 if (!router_ifinfo)
2571 goto out;
2572
2573 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
2574
2575 seq_printf(seq, "%s %pM (%3i) %pM [%10s]: %u.%u/%u.%u MBit\n",
2576 (curr_gw == gw_node ? "=>" : " "),
2577 gw_node->orig_node->orig,
2578 router_ifinfo->bat_iv.tq_avg, router->addr,
2579 router->if_incoming->net_dev->name,
2580 gw_node->bandwidth_down / 10,
2581 gw_node->bandwidth_down % 10,
2582 gw_node->bandwidth_up / 10,
2583 gw_node->bandwidth_up % 10);
2584 ret = seq_has_overflowed(seq) ? -1 : 0;
2585
2586 if (curr_gw)
2587 batadv_gw_node_put(curr_gw);
2588out:
2589 if (router_ifinfo)
2590 batadv_neigh_ifinfo_put(router_ifinfo);
2591 if (router)
2592 batadv_neigh_node_put(router);
2593 return ret;
2594}
2595
2596static void batadv_iv_gw_print(struct batadv_priv *bat_priv,
2597 struct seq_file *seq)
2598{
2599 struct batadv_gw_node *gw_node;
2600 int gw_count = 0;
2601
2602 seq_puts(seq,
2603 " Gateway (#/255) Nexthop [outgoingIF]: advertised uplink bandwidth\n");
2604
2605 rcu_read_lock();
2606 hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) {
2607
2608 if (batadv_iv_gw_write_buffer_text(bat_priv, seq, gw_node) < 0)
2609 continue;
2610
2611 gw_count++;
2612 }
2613 rcu_read_unlock();
2614
2615 if (gw_count == 0)
2616 seq_puts(seq, "No gateways in range ...\n");
2617}
2618#endif
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630static int batadv_iv_gw_dump_entry(struct sk_buff *msg, u32 portid,
2631 struct netlink_callback *cb,
2632 struct batadv_priv *bat_priv,
2633 struct batadv_gw_node *gw_node)
2634{
2635 struct batadv_neigh_ifinfo *router_ifinfo = NULL;
2636 struct batadv_neigh_node *router;
2637 struct batadv_gw_node *curr_gw = NULL;
2638 int ret = 0;
2639 void *hdr;
2640
2641 router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
2642 if (!router)
2643 goto out;
2644
2645 router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
2646 if (!router_ifinfo)
2647 goto out;
2648
2649 curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
2650
2651 hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq,
2652 &batadv_netlink_family, NLM_F_MULTI,
2653 BATADV_CMD_GET_GATEWAYS);
2654 if (!hdr) {
2655 ret = -ENOBUFS;
2656 goto out;
2657 }
2658
2659 genl_dump_check_consistent(cb, hdr);
2660
2661 ret = -EMSGSIZE;
2662
2663 if (curr_gw == gw_node)
2664 if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) {
2665 genlmsg_cancel(msg, hdr);
2666 goto out;
2667 }
2668
2669 if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
2670 gw_node->orig_node->orig) ||
2671 nla_put_u8(msg, BATADV_ATTR_TQ, router_ifinfo->bat_iv.tq_avg) ||
2672 nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN,
2673 router->addr) ||
2674 nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
2675 router->if_incoming->net_dev->name) ||
2676 nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN,
2677 gw_node->bandwidth_down) ||
2678 nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP,
2679 gw_node->bandwidth_up)) {
2680 genlmsg_cancel(msg, hdr);
2681 goto out;
2682 }
2683
2684 genlmsg_end(msg, hdr);
2685 ret = 0;
2686
2687out:
2688 if (curr_gw)
2689 batadv_gw_node_put(curr_gw);
2690 if (router_ifinfo)
2691 batadv_neigh_ifinfo_put(router_ifinfo);
2692 if (router)
2693 batadv_neigh_node_put(router);
2694 return ret;
2695}
2696
2697
2698
2699
2700
2701
2702
2703static void batadv_iv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb,
2704 struct batadv_priv *bat_priv)
2705{
2706 int portid = NETLINK_CB(cb->skb).portid;
2707 struct batadv_gw_node *gw_node;
2708 int idx_skip = cb->args[0];
2709 int idx = 0;
2710
2711 spin_lock_bh(&bat_priv->gw.list_lock);
2712 cb->seq = bat_priv->gw.generation << 1 | 1;
2713
2714 hlist_for_each_entry(gw_node, &bat_priv->gw.gateway_list, list) {
2715 if (idx++ < idx_skip)
2716 continue;
2717
2718 if (batadv_iv_gw_dump_entry(msg, portid, cb, bat_priv,
2719 gw_node)) {
2720 idx_skip = idx - 1;
2721 goto unlock;
2722 }
2723 }
2724
2725 idx_skip = idx;
2726unlock:
2727 spin_unlock_bh(&bat_priv->gw.list_lock);
2728
2729 cb->args[0] = idx_skip;
2730}
2731
2732static struct batadv_algo_ops batadv_batman_iv __read_mostly = {
2733 .name = "BATMAN_IV",
2734 .iface = {
2735 .enable = batadv_iv_ogm_iface_enable,
2736 .enabled = batadv_iv_iface_enabled,
2737 .disable = batadv_iv_ogm_iface_disable,
2738 .update_mac = batadv_iv_ogm_iface_update_mac,
2739 .primary_set = batadv_iv_ogm_primary_iface_set,
2740 },
2741 .neigh = {
2742 .cmp = batadv_iv_ogm_neigh_cmp,
2743 .is_similar_or_better = batadv_iv_ogm_neigh_is_sob,
2744#ifdef CONFIG_BATMAN_ADV_DEBUGFS
2745 .print = batadv_iv_neigh_print,
2746#endif
2747 .dump = batadv_iv_ogm_neigh_dump,
2748 },
2749 .orig = {
2750#ifdef CONFIG_BATMAN_ADV_DEBUGFS
2751 .print = batadv_iv_ogm_orig_print,
2752#endif
2753 .dump = batadv_iv_ogm_orig_dump,
2754 },
2755 .gw = {
2756 .init_sel_class = batadv_iv_init_sel_class,
2757 .get_best_gw_node = batadv_iv_gw_get_best_gw_node,
2758 .is_eligible = batadv_iv_gw_is_eligible,
2759#ifdef CONFIG_BATMAN_ADV_DEBUGFS
2760 .print = batadv_iv_gw_print,
2761#endif
2762 .dump = batadv_iv_gw_dump,
2763 },
2764};
2765
2766
2767
2768
2769
2770
2771int __init batadv_iv_init(void)
2772{
2773 int ret;
2774
2775
2776 ret = batadv_recv_handler_register(BATADV_IV_OGM,
2777 batadv_iv_ogm_receive);
2778 if (ret < 0)
2779 goto out;
2780
2781 ret = batadv_algo_register(&batadv_batman_iv);
2782 if (ret < 0)
2783 goto handler_unregister;
2784
2785 goto out;
2786
2787handler_unregister:
2788 batadv_recv_handler_unregister(BATADV_IV_OGM);
2789out:
2790 return ret;
2791}
2792