1
2
3
4
5
6
7#include "soft-interface.h"
8#include "main.h"
9
10#include <linux/atomic.h>
11#include <linux/byteorder/generic.h>
12#include <linux/cache.h>
13#include <linux/compiler.h>
14#include <linux/cpumask.h>
15#include <linux/errno.h>
16#include <linux/etherdevice.h>
17#include <linux/ethtool.h>
18#include <linux/gfp.h>
19#include <linux/if_ether.h>
20#include <linux/if_vlan.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/netdevice.h>
27#include <linux/netlink.h>
28#include <linux/percpu.h>
29#include <linux/random.h>
30#include <linux/rculist.h>
31#include <linux/rcupdate.h>
32#include <linux/skbuff.h>
33#include <linux/slab.h>
34#include <linux/socket.h>
35#include <linux/spinlock.h>
36#include <linux/stddef.h>
37#include <linux/string.h>
38#include <linux/types.h>
39#include <net/net_namespace.h>
40#include <net/netlink.h>
41#include <uapi/linux/batadv_packet.h>
42#include <uapi/linux/batman_adv.h>
43
44#include "bat_algo.h"
45#include "bridge_loop_avoidance.h"
46#include "distributed-arp-table.h"
47#include "gateway_client.h"
48#include "hard-interface.h"
49#include "multicast.h"
50#include "network-coding.h"
51#include "originator.h"
52#include "send.h"
53#include "translation-table.h"
54
55
56
57
58
59
60
61
62int batadv_skb_head_push(struct sk_buff *skb, unsigned int len)
63{
64 int result;
65
66
67
68
69
70
71
72
73 result = skb_cow_head(skb, len);
74 if (result < 0)
75 return result;
76
77 skb_push(skb, len);
78 return 0;
79}
80
81static int batadv_interface_open(struct net_device *dev)
82{
83 netif_start_queue(dev);
84 return 0;
85}
86
87static int batadv_interface_release(struct net_device *dev)
88{
89 netif_stop_queue(dev);
90 return 0;
91}
92
93
94
95
96
97
98
99
100static u64 batadv_sum_counter(struct batadv_priv *bat_priv, size_t idx)
101{
102 u64 *counters, sum = 0;
103 int cpu;
104
105 for_each_possible_cpu(cpu) {
106 counters = per_cpu_ptr(bat_priv->bat_counters, cpu);
107 sum += counters[idx];
108 }
109
110 return sum;
111}
112
113static struct net_device_stats *batadv_interface_stats(struct net_device *dev)
114{
115 struct batadv_priv *bat_priv = netdev_priv(dev);
116 struct net_device_stats *stats = &dev->stats;
117
118 stats->tx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_TX);
119 stats->tx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_TX_BYTES);
120 stats->tx_dropped = batadv_sum_counter(bat_priv, BATADV_CNT_TX_DROPPED);
121 stats->rx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_RX);
122 stats->rx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_RX_BYTES);
123 return stats;
124}
125
126static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)
127{
128 struct batadv_priv *bat_priv = netdev_priv(dev);
129 struct batadv_softif_vlan *vlan;
130 struct sockaddr *addr = p;
131 u8 old_addr[ETH_ALEN];
132
133 if (!is_valid_ether_addr(addr->sa_data))
134 return -EADDRNOTAVAIL;
135
136 ether_addr_copy(old_addr, dev->dev_addr);
137 ether_addr_copy(dev->dev_addr, addr->sa_data);
138
139
140 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
141 return 0;
142
143 rcu_read_lock();
144 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
145 batadv_tt_local_remove(bat_priv, old_addr, vlan->vid,
146 "mac address changed", false);
147 batadv_tt_local_add(dev, addr->sa_data, vlan->vid,
148 BATADV_NULL_IFINDEX, BATADV_NO_MARK);
149 }
150 rcu_read_unlock();
151
152 return 0;
153}
154
155static int batadv_interface_change_mtu(struct net_device *dev, int new_mtu)
156{
157
158 if (new_mtu < 68 || new_mtu > batadv_hardif_min_mtu(dev))
159 return -EINVAL;
160
161 dev->mtu = new_mtu;
162
163 return 0;
164}
165
166
167
168
169
170
171
172
173
174static void batadv_interface_set_rx_mode(struct net_device *dev)
175{
176}
177
178static netdev_tx_t batadv_interface_tx(struct sk_buff *skb,
179 struct net_device *soft_iface)
180{
181 struct ethhdr *ethhdr;
182 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
183 struct batadv_hard_iface *primary_if = NULL;
184 struct batadv_bcast_packet *bcast_packet;
185 static const u8 stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00,
186 0x00, 0x00};
187 static const u8 ectp_addr[ETH_ALEN] = {0xCF, 0x00, 0x00, 0x00,
188 0x00, 0x00};
189 enum batadv_dhcp_recipient dhcp_rcp = BATADV_DHCP_NO;
190 u8 *dst_hint = NULL, chaddr[ETH_ALEN];
191 struct vlan_ethhdr *vhdr;
192 unsigned int header_len = 0;
193 int data_len = skb->len, ret;
194 unsigned long brd_delay = 0;
195 bool do_bcast = false, client_added;
196 unsigned short vid;
197 u32 seqno;
198 int gw_mode;
199 enum batadv_forw_mode forw_mode = BATADV_FORW_SINGLE;
200 struct batadv_orig_node *mcast_single_orig = NULL;
201 int network_offset = ETH_HLEN;
202 __be16 proto;
203
204 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
205 goto dropped;
206
207
208 memset(skb->cb, 0, sizeof(struct batadv_skb_cb));
209
210 netif_trans_update(soft_iface);
211 vid = batadv_get_vid(skb, 0);
212
213 skb_reset_mac_header(skb);
214 ethhdr = eth_hdr(skb);
215
216 proto = ethhdr->h_proto;
217
218 switch (ntohs(proto)) {
219 case ETH_P_8021Q:
220 if (!pskb_may_pull(skb, sizeof(*vhdr)))
221 goto dropped;
222 vhdr = vlan_eth_hdr(skb);
223 proto = vhdr->h_vlan_encapsulated_proto;
224
225
226 if (proto != htons(ETH_P_BATMAN)) {
227 network_offset += VLAN_HLEN;
228 break;
229 }
230
231 fallthrough;
232 case ETH_P_BATMAN:
233 goto dropped;
234 }
235
236 skb_set_network_header(skb, network_offset);
237
238 if (batadv_bla_tx(bat_priv, skb, vid))
239 goto dropped;
240
241
242 ethhdr = eth_hdr(skb);
243
244
245 if (!is_multicast_ether_addr(ethhdr->h_source) &&
246 !batadv_bla_is_loopdetect_mac(ethhdr->h_source)) {
247 client_added = batadv_tt_local_add(soft_iface, ethhdr->h_source,
248 vid, skb->skb_iif,
249 skb->mark);
250 if (!client_added)
251 goto dropped;
252 }
253
254
255 batadv_dat_snoop_outgoing_dhcp_ack(bat_priv, skb, proto, vid);
256
257
258
259
260
261
262
263 if (batadv_compare_eth(ethhdr->h_dest, stp_addr))
264 goto dropped;
265
266 if (batadv_compare_eth(ethhdr->h_dest, ectp_addr))
267 goto dropped;
268
269 gw_mode = atomic_read(&bat_priv->gw.mode);
270 if (is_multicast_ether_addr(ethhdr->h_dest)) {
271
272 if (gw_mode == BATADV_GW_MODE_OFF) {
273 do_bcast = true;
274 goto send;
275 }
276
277 dhcp_rcp = batadv_gw_dhcp_recipient_get(skb, &header_len,
278 chaddr);
279
280
281
282 ethhdr = eth_hdr(skb);
283
284
285
286 if (dhcp_rcp == BATADV_DHCP_NO) {
287 do_bcast = true;
288 goto send;
289 }
290
291 if (dhcp_rcp == BATADV_DHCP_TO_CLIENT)
292 dst_hint = chaddr;
293 else if ((gw_mode == BATADV_GW_MODE_SERVER) &&
294 (dhcp_rcp == BATADV_DHCP_TO_SERVER))
295
296
297
298 goto dropped;
299
300send:
301 if (do_bcast && !is_broadcast_ether_addr(ethhdr->h_dest)) {
302 forw_mode = batadv_mcast_forw_mode(bat_priv, skb,
303 &mcast_single_orig);
304 if (forw_mode == BATADV_FORW_NONE)
305 goto dropped;
306
307 if (forw_mode == BATADV_FORW_SINGLE ||
308 forw_mode == BATADV_FORW_SOME)
309 do_bcast = false;
310 }
311 }
312
313 batadv_skb_set_priority(skb, 0);
314
315
316 if (do_bcast) {
317 primary_if = batadv_primary_if_get_selected(bat_priv);
318 if (!primary_if)
319 goto dropped;
320
321
322
323
324
325 if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
326 brd_delay = msecs_to_jiffies(ARP_REQ_DELAY);
327
328 if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
329 goto dropped;
330
331 bcast_packet = (struct batadv_bcast_packet *)skb->data;
332 bcast_packet->version = BATADV_COMPAT_VERSION;
333 bcast_packet->ttl = BATADV_TTL - 1;
334
335
336 bcast_packet->packet_type = BATADV_BCAST;
337 bcast_packet->reserved = 0;
338
339
340
341
342 ether_addr_copy(bcast_packet->orig,
343 primary_if->net_dev->dev_addr);
344
345
346 seqno = atomic_inc_return(&bat_priv->bcast_seqno);
347 bcast_packet->seqno = htonl(seqno);
348
349 batadv_send_bcast_packet(bat_priv, skb, brd_delay, true);
350
351 } else {
352
353 if (dhcp_rcp == BATADV_DHCP_TO_SERVER) {
354 ret = batadv_gw_out_of_range(bat_priv, skb);
355 if (ret)
356 goto dropped;
357 ret = batadv_send_skb_via_gw(bat_priv, skb, vid);
358 } else if (mcast_single_orig) {
359 ret = batadv_mcast_forw_send_orig(bat_priv, skb, vid,
360 mcast_single_orig);
361 } else if (forw_mode == BATADV_FORW_SOME) {
362 ret = batadv_mcast_forw_send(bat_priv, skb, vid);
363 } else {
364 if (batadv_dat_snoop_outgoing_arp_request(bat_priv,
365 skb))
366 goto dropped;
367
368 batadv_dat_snoop_outgoing_arp_reply(bat_priv, skb);
369
370 ret = batadv_send_skb_via_tt(bat_priv, skb, dst_hint,
371 vid);
372 }
373 if (ret != NET_XMIT_SUCCESS)
374 goto dropped_freed;
375 }
376
377 batadv_inc_counter(bat_priv, BATADV_CNT_TX);
378 batadv_add_counter(bat_priv, BATADV_CNT_TX_BYTES, data_len);
379 goto end;
380
381dropped:
382 kfree_skb(skb);
383dropped_freed:
384 batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED);
385end:
386 batadv_orig_node_put(mcast_single_orig);
387 batadv_hardif_put(primary_if);
388 return NETDEV_TX_OK;
389}
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408void batadv_interface_rx(struct net_device *soft_iface,
409 struct sk_buff *skb, int hdr_size,
410 struct batadv_orig_node *orig_node)
411{
412 struct batadv_bcast_packet *batadv_bcast_packet;
413 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
414 struct vlan_ethhdr *vhdr;
415 struct ethhdr *ethhdr;
416 unsigned short vid;
417 int packet_type;
418
419 batadv_bcast_packet = (struct batadv_bcast_packet *)skb->data;
420 packet_type = batadv_bcast_packet->packet_type;
421
422 skb_pull_rcsum(skb, hdr_size);
423 skb_reset_mac_header(skb);
424
425
426
427
428 nf_reset_ct(skb);
429
430 if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
431 goto dropped;
432
433 vid = batadv_get_vid(skb, 0);
434 ethhdr = eth_hdr(skb);
435
436 switch (ntohs(ethhdr->h_proto)) {
437 case ETH_P_8021Q:
438 if (!pskb_may_pull(skb, VLAN_ETH_HLEN))
439 goto dropped;
440
441 vhdr = (struct vlan_ethhdr *)skb->data;
442
443
444 if (vhdr->h_vlan_encapsulated_proto != htons(ETH_P_BATMAN))
445 break;
446
447 fallthrough;
448 case ETH_P_BATMAN:
449 goto dropped;
450 }
451
452
453 skb->protocol = eth_type_trans(skb, soft_iface);
454 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
455
456 batadv_inc_counter(bat_priv, BATADV_CNT_RX);
457 batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
458 skb->len + ETH_HLEN);
459
460
461
462
463 if (batadv_bla_rx(bat_priv, skb, vid, packet_type))
464 goto out;
465
466 if (orig_node)
467 batadv_tt_add_temporary_global_entry(bat_priv, orig_node,
468 ethhdr->h_source, vid);
469
470 if (is_multicast_ether_addr(ethhdr->h_dest)) {
471
472
473
474 if (batadv_vlan_ap_isola_get(bat_priv, vid) &&
475 batadv_tt_global_is_isolated(bat_priv, ethhdr->h_source,
476 vid)) {
477
478
479
480 skb->mark &= ~bat_priv->isolation_mark_mask;
481 skb->mark |= bat_priv->isolation_mark;
482 }
483 } else if (batadv_is_ap_isolated(bat_priv, ethhdr->h_source,
484 ethhdr->h_dest, vid)) {
485 goto dropped;
486 }
487
488 netif_rx(skb);
489 goto out;
490
491dropped:
492 kfree_skb(skb);
493out:
494 return;
495}
496
497
498
499
500
501
502void batadv_softif_vlan_release(struct kref *ref)
503{
504 struct batadv_softif_vlan *vlan;
505
506 vlan = container_of(ref, struct batadv_softif_vlan, refcount);
507
508 spin_lock_bh(&vlan->bat_priv->softif_vlan_list_lock);
509 hlist_del_rcu(&vlan->list);
510 spin_unlock_bh(&vlan->bat_priv->softif_vlan_list_lock);
511
512 kfree_rcu(vlan, rcu);
513}
514
515
516
517
518
519
520
521
522
523struct batadv_softif_vlan *batadv_softif_vlan_get(struct batadv_priv *bat_priv,
524 unsigned short vid)
525{
526 struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
527
528 rcu_read_lock();
529 hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
530 if (vlan_tmp->vid != vid)
531 continue;
532
533 if (!kref_get_unless_zero(&vlan_tmp->refcount))
534 continue;
535
536 vlan = vlan_tmp;
537 break;
538 }
539 rcu_read_unlock();
540
541 return vlan;
542}
543
544
545
546
547
548
549
550
551int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid)
552{
553 struct batadv_softif_vlan *vlan;
554
555 spin_lock_bh(&bat_priv->softif_vlan_list_lock);
556
557 vlan = batadv_softif_vlan_get(bat_priv, vid);
558 if (vlan) {
559 batadv_softif_vlan_put(vlan);
560 spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
561 return -EEXIST;
562 }
563
564 vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC);
565 if (!vlan) {
566 spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
567 return -ENOMEM;
568 }
569
570 vlan->bat_priv = bat_priv;
571 vlan->vid = vid;
572 kref_init(&vlan->refcount);
573
574 atomic_set(&vlan->ap_isolation, 0);
575
576 kref_get(&vlan->refcount);
577 hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list);
578 spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
579
580
581
582
583 batadv_tt_local_add(bat_priv->soft_iface,
584 bat_priv->soft_iface->dev_addr, vid,
585 BATADV_NULL_IFINDEX, BATADV_NO_MARK);
586
587
588 batadv_softif_vlan_put(vlan);
589
590 return 0;
591}
592
593
594
595
596
597
598static void batadv_softif_destroy_vlan(struct batadv_priv *bat_priv,
599 struct batadv_softif_vlan *vlan)
600{
601
602
603
604 batadv_tt_local_remove(bat_priv, bat_priv->soft_iface->dev_addr,
605 vlan->vid, "vlan interface destroyed", false);
606
607 batadv_softif_vlan_put(vlan);
608}
609
610
611
612
613
614
615
616
617
618
619
620
621static int batadv_interface_add_vid(struct net_device *dev, __be16 proto,
622 unsigned short vid)
623{
624 struct batadv_priv *bat_priv = netdev_priv(dev);
625 struct batadv_softif_vlan *vlan;
626
627
628
629
630 if (proto != htons(ETH_P_8021Q))
631 return -EINVAL;
632
633 vid |= BATADV_VLAN_HAS_TAG;
634
635
636
637
638
639
640
641 vlan = batadv_softif_vlan_get(bat_priv, vid);
642 if (!vlan)
643 return batadv_softif_create_vlan(bat_priv, vid);
644
645
646
647
648
649 batadv_tt_local_add(bat_priv->soft_iface,
650 bat_priv->soft_iface->dev_addr, vid,
651 BATADV_NULL_IFINDEX, BATADV_NO_MARK);
652
653 return 0;
654}
655
656
657
658
659
660
661
662
663
664
665
666
667
668static int batadv_interface_kill_vid(struct net_device *dev, __be16 proto,
669 unsigned short vid)
670{
671 struct batadv_priv *bat_priv = netdev_priv(dev);
672 struct batadv_softif_vlan *vlan;
673
674
675
676
677 if (proto != htons(ETH_P_8021Q))
678 return -EINVAL;
679
680 vlan = batadv_softif_vlan_get(bat_priv, vid | BATADV_VLAN_HAS_TAG);
681 if (!vlan)
682 return -ENOENT;
683
684 batadv_softif_destroy_vlan(bat_priv, vlan);
685
686
687 batadv_softif_vlan_put(vlan);
688
689 return 0;
690}
691
692
693
694
695
696static struct lock_class_key batadv_netdev_xmit_lock_key;
697static struct lock_class_key batadv_netdev_addr_lock_key;
698
699
700
701
702
703
704
705static void batadv_set_lockdep_class_one(struct net_device *dev,
706 struct netdev_queue *txq,
707 void *_unused)
708{
709 lockdep_set_class(&txq->_xmit_lock, &batadv_netdev_xmit_lock_key);
710}
711
712
713
714
715
716static void batadv_set_lockdep_class(struct net_device *dev)
717{
718 lockdep_set_class(&dev->addr_list_lock, &batadv_netdev_addr_lock_key);
719 netdev_for_each_tx_queue(dev, batadv_set_lockdep_class_one, NULL);
720}
721
722
723
724
725
726
727
728static int batadv_softif_init_late(struct net_device *dev)
729{
730 struct batadv_priv *bat_priv;
731 u32 random_seqno;
732 int ret;
733 size_t cnt_len = sizeof(u64) * BATADV_CNT_NUM;
734
735 batadv_set_lockdep_class(dev);
736
737 bat_priv = netdev_priv(dev);
738 bat_priv->soft_iface = dev;
739
740
741
742
743 bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(u64));
744 if (!bat_priv->bat_counters)
745 return -ENOMEM;
746
747 atomic_set(&bat_priv->aggregated_ogms, 1);
748 atomic_set(&bat_priv->bonding, 0);
749#ifdef CONFIG_BATMAN_ADV_BLA
750 atomic_set(&bat_priv->bridge_loop_avoidance, 1);
751#endif
752#ifdef CONFIG_BATMAN_ADV_DAT
753 atomic_set(&bat_priv->distributed_arp_table, 1);
754#endif
755#ifdef CONFIG_BATMAN_ADV_MCAST
756 atomic_set(&bat_priv->multicast_mode, 1);
757 atomic_set(&bat_priv->multicast_fanout, 16);
758 atomic_set(&bat_priv->mcast.num_want_all_unsnoopables, 0);
759 atomic_set(&bat_priv->mcast.num_want_all_ipv4, 0);
760 atomic_set(&bat_priv->mcast.num_want_all_ipv6, 0);
761#endif
762 atomic_set(&bat_priv->gw.mode, BATADV_GW_MODE_OFF);
763 atomic_set(&bat_priv->gw.bandwidth_down, 100);
764 atomic_set(&bat_priv->gw.bandwidth_up, 20);
765 atomic_set(&bat_priv->orig_interval, 1000);
766 atomic_set(&bat_priv->hop_penalty, 30);
767#ifdef CONFIG_BATMAN_ADV_DEBUG
768 atomic_set(&bat_priv->log_level, 0);
769#endif
770 atomic_set(&bat_priv->fragmentation, 1);
771 atomic_set(&bat_priv->packet_size_max, ETH_DATA_LEN);
772 atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN);
773 atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN);
774
775 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
776 atomic_set(&bat_priv->bcast_seqno, 1);
777 atomic_set(&bat_priv->tt.vn, 0);
778 atomic_set(&bat_priv->tt.local_changes, 0);
779 atomic_set(&bat_priv->tt.ogm_append_cnt, 0);
780#ifdef CONFIG_BATMAN_ADV_BLA
781 atomic_set(&bat_priv->bla.num_requests, 0);
782#endif
783 atomic_set(&bat_priv->tp_num, 0);
784
785 bat_priv->tt.last_changeset = NULL;
786 bat_priv->tt.last_changeset_len = 0;
787 bat_priv->isolation_mark = 0;
788 bat_priv->isolation_mark_mask = 0;
789
790
791 get_random_bytes(&random_seqno, sizeof(random_seqno));
792 atomic_set(&bat_priv->frag_seqno, random_seqno);
793
794 bat_priv->primary_if = NULL;
795
796 batadv_nc_init_bat_priv(bat_priv);
797
798 if (!bat_priv->algo_ops) {
799 ret = batadv_algo_select(bat_priv, batadv_routing_algo);
800 if (ret < 0)
801 goto free_bat_counters;
802 }
803
804 ret = batadv_mesh_init(dev);
805 if (ret < 0)
806 goto free_bat_counters;
807
808 return 0;
809
810free_bat_counters:
811 free_percpu(bat_priv->bat_counters);
812 bat_priv->bat_counters = NULL;
813
814 return ret;
815}
816
817
818
819
820
821
822
823
824
825static int batadv_softif_slave_add(struct net_device *dev,
826 struct net_device *slave_dev,
827 struct netlink_ext_ack *extack)
828{
829 struct batadv_hard_iface *hard_iface;
830 int ret = -EINVAL;
831
832 hard_iface = batadv_hardif_get_by_netdev(slave_dev);
833 if (!hard_iface || hard_iface->soft_iface)
834 goto out;
835
836 ret = batadv_hardif_enable_interface(hard_iface, dev);
837
838out:
839 batadv_hardif_put(hard_iface);
840 return ret;
841}
842
843
844
845
846
847
848
849
850static int batadv_softif_slave_del(struct net_device *dev,
851 struct net_device *slave_dev)
852{
853 struct batadv_hard_iface *hard_iface;
854 int ret = -EINVAL;
855
856 hard_iface = batadv_hardif_get_by_netdev(slave_dev);
857
858 if (!hard_iface || hard_iface->soft_iface != dev)
859 goto out;
860
861 batadv_hardif_disable_interface(hard_iface);
862 ret = 0;
863
864out:
865 batadv_hardif_put(hard_iface);
866 return ret;
867}
868
869static const struct net_device_ops batadv_netdev_ops = {
870 .ndo_init = batadv_softif_init_late,
871 .ndo_open = batadv_interface_open,
872 .ndo_stop = batadv_interface_release,
873 .ndo_get_stats = batadv_interface_stats,
874 .ndo_vlan_rx_add_vid = batadv_interface_add_vid,
875 .ndo_vlan_rx_kill_vid = batadv_interface_kill_vid,
876 .ndo_set_mac_address = batadv_interface_set_mac_addr,
877 .ndo_change_mtu = batadv_interface_change_mtu,
878 .ndo_set_rx_mode = batadv_interface_set_rx_mode,
879 .ndo_start_xmit = batadv_interface_tx,
880 .ndo_validate_addr = eth_validate_addr,
881 .ndo_add_slave = batadv_softif_slave_add,
882 .ndo_del_slave = batadv_softif_slave_del,
883};
884
885static void batadv_get_drvinfo(struct net_device *dev,
886 struct ethtool_drvinfo *info)
887{
888 strscpy(info->driver, "B.A.T.M.A.N. advanced", sizeof(info->driver));
889 strscpy(info->version, BATADV_SOURCE_VERSION, sizeof(info->version));
890 strscpy(info->fw_version, "N/A", sizeof(info->fw_version));
891 strscpy(info->bus_info, "batman", sizeof(info->bus_info));
892}
893
894
895
896
897
898static const struct {
899 const char name[ETH_GSTRING_LEN];
900} batadv_counters_strings[] = {
901 { "tx" },
902 { "tx_bytes" },
903 { "tx_dropped" },
904 { "rx" },
905 { "rx_bytes" },
906 { "forward" },
907 { "forward_bytes" },
908 { "mgmt_tx" },
909 { "mgmt_tx_bytes" },
910 { "mgmt_rx" },
911 { "mgmt_rx_bytes" },
912 { "frag_tx" },
913 { "frag_tx_bytes" },
914 { "frag_rx" },
915 { "frag_rx_bytes" },
916 { "frag_fwd" },
917 { "frag_fwd_bytes" },
918 { "tt_request_tx" },
919 { "tt_request_rx" },
920 { "tt_response_tx" },
921 { "tt_response_rx" },
922 { "tt_roam_adv_tx" },
923 { "tt_roam_adv_rx" },
924#ifdef CONFIG_BATMAN_ADV_DAT
925 { "dat_get_tx" },
926 { "dat_get_rx" },
927 { "dat_put_tx" },
928 { "dat_put_rx" },
929 { "dat_cached_reply_tx" },
930#endif
931#ifdef CONFIG_BATMAN_ADV_NC
932 { "nc_code" },
933 { "nc_code_bytes" },
934 { "nc_recode" },
935 { "nc_recode_bytes" },
936 { "nc_buffer" },
937 { "nc_decode" },
938 { "nc_decode_bytes" },
939 { "nc_decode_failed" },
940 { "nc_sniffed" },
941#endif
942};
943
944static void batadv_get_strings(struct net_device *dev, u32 stringset, u8 *data)
945{
946 if (stringset == ETH_SS_STATS)
947 memcpy(data, batadv_counters_strings,
948 sizeof(batadv_counters_strings));
949}
950
951static void batadv_get_ethtool_stats(struct net_device *dev,
952 struct ethtool_stats *stats, u64 *data)
953{
954 struct batadv_priv *bat_priv = netdev_priv(dev);
955 int i;
956
957 for (i = 0; i < BATADV_CNT_NUM; i++)
958 data[i] = batadv_sum_counter(bat_priv, i);
959}
960
961static int batadv_get_sset_count(struct net_device *dev, int stringset)
962{
963 if (stringset == ETH_SS_STATS)
964 return BATADV_CNT_NUM;
965
966 return -EOPNOTSUPP;
967}
968
969static const struct ethtool_ops batadv_ethtool_ops = {
970 .get_drvinfo = batadv_get_drvinfo,
971 .get_link = ethtool_op_get_link,
972 .get_strings = batadv_get_strings,
973 .get_ethtool_stats = batadv_get_ethtool_stats,
974 .get_sset_count = batadv_get_sset_count,
975};
976
977
978
979
980
981static void batadv_softif_free(struct net_device *dev)
982{
983 batadv_mesh_free(dev);
984
985
986
987
988
989 rcu_barrier();
990}
991
992
993
994
995
996static void batadv_softif_init_early(struct net_device *dev)
997{
998 ether_setup(dev);
999
1000 dev->netdev_ops = &batadv_netdev_ops;
1001 dev->needs_free_netdev = true;
1002 dev->priv_destructor = batadv_softif_free;
1003 dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_NETNS_LOCAL;
1004 dev->features |= NETIF_F_LLTX;
1005 dev->priv_flags |= IFF_NO_QUEUE;
1006
1007
1008
1009
1010 dev->mtu = ETH_DATA_LEN;
1011
1012
1013 eth_hw_addr_random(dev);
1014
1015 dev->ethtool_ops = &batadv_ethtool_ops;
1016}
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026static int batadv_softif_validate(struct nlattr *tb[], struct nlattr *data[],
1027 struct netlink_ext_ack *extack)
1028{
1029 struct batadv_algo_ops *algo_ops;
1030
1031 if (!data)
1032 return 0;
1033
1034 if (data[IFLA_BATADV_ALGO_NAME]) {
1035 algo_ops = batadv_algo_get(nla_data(data[IFLA_BATADV_ALGO_NAME]));
1036 if (!algo_ops)
1037 return -EINVAL;
1038 }
1039
1040 return 0;
1041}
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053static int batadv_softif_newlink(struct net *src_net, struct net_device *dev,
1054 struct nlattr *tb[], struct nlattr *data[],
1055 struct netlink_ext_ack *extack)
1056{
1057 struct batadv_priv *bat_priv = netdev_priv(dev);
1058 const char *algo_name;
1059 int err;
1060
1061 if (data && data[IFLA_BATADV_ALGO_NAME]) {
1062 algo_name = nla_data(data[IFLA_BATADV_ALGO_NAME]);
1063 err = batadv_algo_select(bat_priv, algo_name);
1064 if (err)
1065 return -EINVAL;
1066 }
1067
1068 return register_netdevice(dev);
1069}
1070
1071
1072
1073
1074
1075
1076
1077static void batadv_softif_destroy_netlink(struct net_device *soft_iface,
1078 struct list_head *head)
1079{
1080 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
1081 struct batadv_hard_iface *hard_iface;
1082 struct batadv_softif_vlan *vlan;
1083
1084 list_for_each_entry(hard_iface, &batadv_hardif_list, list) {
1085 if (hard_iface->soft_iface == soft_iface)
1086 batadv_hardif_disable_interface(hard_iface);
1087 }
1088
1089
1090 vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
1091 if (vlan) {
1092 batadv_softif_destroy_vlan(bat_priv, vlan);
1093 batadv_softif_vlan_put(vlan);
1094 }
1095
1096 unregister_netdevice_queue(soft_iface, head);
1097}
1098
1099
1100
1101
1102
1103
1104
1105bool batadv_softif_is_valid(const struct net_device *net_dev)
1106{
1107 if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)
1108 return true;
1109
1110 return false;
1111}
1112
1113static const struct nla_policy batadv_ifla_policy[IFLA_BATADV_MAX + 1] = {
1114 [IFLA_BATADV_ALGO_NAME] = { .type = NLA_NUL_STRING },
1115};
1116
1117struct rtnl_link_ops batadv_link_ops __read_mostly = {
1118 .kind = "batadv",
1119 .priv_size = sizeof(struct batadv_priv),
1120 .setup = batadv_softif_init_early,
1121 .maxtype = IFLA_BATADV_MAX,
1122 .policy = batadv_ifla_policy,
1123 .validate = batadv_softif_validate,
1124 .newlink = batadv_softif_newlink,
1125 .dellink = batadv_softif_destroy_netlink,
1126};
1127