1
2
3
4
5
6
7#include "hard-interface.h"
8#include "main.h"
9
10#include <linux/atomic.h>
11#include <linux/byteorder/generic.h>
12#include <linux/errno.h>
13#include <linux/gfp.h>
14#include <linux/if.h>
15#include <linux/if_arp.h>
16#include <linux/if_ether.h>
17#include <linux/kernel.h>
18#include <linux/kref.h>
19#include <linux/limits.h>
20#include <linux/list.h>
21#include <linux/mutex.h>
22#include <linux/netdevice.h>
23#include <linux/printk.h>
24#include <linux/rculist.h>
25#include <linux/rtnetlink.h>
26#include <linux/slab.h>
27#include <linux/spinlock.h>
28#include <net/net_namespace.h>
29#include <net/rtnetlink.h>
30#include <uapi/linux/batadv_packet.h>
31
32#include "bat_v.h"
33#include "bridge_loop_avoidance.h"
34#include "debugfs.h"
35#include "distributed-arp-table.h"
36#include "gateway_client.h"
37#include "log.h"
38#include "originator.h"
39#include "send.h"
40#include "soft-interface.h"
41#include "sysfs.h"
42#include "translation-table.h"
43
44
45
46
47
48
49void batadv_hardif_release(struct kref *ref)
50{
51 struct batadv_hard_iface *hard_iface;
52
53 hard_iface = container_of(ref, struct batadv_hard_iface, refcount);
54 dev_put(hard_iface->net_dev);
55
56 kfree_rcu(hard_iface, rcu);
57}
58
59
60
61
62
63
64
65struct batadv_hard_iface *
66batadv_hardif_get_by_netdev(const struct net_device *net_dev)
67{
68 struct batadv_hard_iface *hard_iface;
69
70 rcu_read_lock();
71 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
72 if (hard_iface->net_dev == net_dev &&
73 kref_get_unless_zero(&hard_iface->refcount))
74 goto out;
75 }
76
77 hard_iface = NULL;
78
79out:
80 rcu_read_unlock();
81 return hard_iface;
82}
83
84
85
86
87
88
89
90
91static struct net *batadv_getlink_net(const struct net_device *netdev,
92 struct net *fallback_net)
93{
94 if (!netdev->rtnl_link_ops)
95 return fallback_net;
96
97 if (!netdev->rtnl_link_ops->get_link_net)
98 return fallback_net;
99
100 return netdev->rtnl_link_ops->get_link_net(netdev);
101}
102
103
104
105
106
107
108
109
110
111
112
113
114static bool batadv_mutual_parents(const struct net_device *dev1,
115 struct net *net1,
116 const struct net_device *dev2,
117 struct net *net2)
118{
119 int dev1_parent_iflink = dev_get_iflink(dev1);
120 int dev2_parent_iflink = dev_get_iflink(dev2);
121 const struct net *dev1_parent_net;
122 const struct net *dev2_parent_net;
123
124 dev1_parent_net = batadv_getlink_net(dev1, net1);
125 dev2_parent_net = batadv_getlink_net(dev2, net2);
126
127 if (!dev1_parent_iflink || !dev2_parent_iflink)
128 return false;
129
130 return (dev1_parent_iflink == dev2->ifindex) &&
131 (dev2_parent_iflink == dev1->ifindex) &&
132 net_eq(dev1_parent_net, net2) &&
133 net_eq(dev2_parent_net, net1);
134}
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149static bool batadv_is_on_batman_iface(const struct net_device *net_dev)
150{
151 struct net *net = dev_net(net_dev);
152 struct net_device *parent_dev;
153 struct net *parent_net;
154 bool ret;
155
156
157 if (batadv_softif_is_valid(net_dev))
158 return true;
159
160
161 if (dev_get_iflink(net_dev) == 0 ||
162 dev_get_iflink(net_dev) == net_dev->ifindex)
163 return false;
164
165 parent_net = batadv_getlink_net(net_dev, net);
166
167
168 parent_dev = __dev_get_by_index((struct net *)parent_net,
169 dev_get_iflink(net_dev));
170
171 if (!parent_dev) {
172 pr_err("Cannot find parent device\n");
173 return false;
174 }
175
176 if (batadv_mutual_parents(net_dev, net, parent_dev, parent_net))
177 return false;
178
179 ret = batadv_is_on_batman_iface(parent_dev);
180
181 return ret;
182}
183
184static bool batadv_is_valid_iface(const struct net_device *net_dev)
185{
186 if (net_dev->flags & IFF_LOOPBACK)
187 return false;
188
189 if (net_dev->type != ARPHRD_ETHER)
190 return false;
191
192 if (net_dev->addr_len != ETH_ALEN)
193 return false;
194
195
196 if (batadv_is_on_batman_iface(net_dev))
197 return false;
198
199 return true;
200}
201
202
203
204
205
206
207
208
209
210
211
212
213static struct net_device *batadv_get_real_netdevice(struct net_device *netdev)
214{
215 struct batadv_hard_iface *hard_iface = NULL;
216 struct net_device *real_netdev = NULL;
217 struct net *real_net;
218 struct net *net;
219 int ifindex;
220
221 ASSERT_RTNL();
222
223 if (!netdev)
224 return NULL;
225
226 if (netdev->ifindex == dev_get_iflink(netdev)) {
227 dev_hold(netdev);
228 return netdev;
229 }
230
231 hard_iface = batadv_hardif_get_by_netdev(netdev);
232 if (!hard_iface || !hard_iface->soft_iface)
233 goto out;
234
235 net = dev_net(hard_iface->soft_iface);
236 ifindex = dev_get_iflink(netdev);
237 real_net = batadv_getlink_net(netdev, net);
238 real_netdev = dev_get_by_index(real_net, ifindex);
239
240out:
241 if (hard_iface)
242 batadv_hardif_put(hard_iface);
243 return real_netdev;
244}
245
246
247
248
249
250
251
252
253
254struct net_device *batadv_get_real_netdev(struct net_device *net_device)
255{
256 struct net_device *real_netdev;
257
258 rtnl_lock();
259 real_netdev = batadv_get_real_netdevice(net_device);
260 rtnl_unlock();
261
262 return real_netdev;
263}
264
265
266
267
268
269
270
271
272
273static bool batadv_is_wext_netdev(struct net_device *net_device)
274{
275 if (!net_device)
276 return false;
277
278#ifdef CONFIG_WIRELESS_EXT
279
280
281
282 if (net_device->wireless_handlers)
283 return true;
284#endif
285
286 return false;
287}
288
289
290
291
292
293
294
295
296
297static bool batadv_is_cfg80211_netdev(struct net_device *net_device)
298{
299 if (!net_device)
300 return false;
301
302
303 if (net_device->ieee80211_ptr)
304 return true;
305
306 return false;
307}
308
309
310
311
312
313
314
315static u32 batadv_wifi_flags_evaluate(struct net_device *net_device)
316{
317 u32 wifi_flags = 0;
318 struct net_device *real_netdev;
319
320 if (batadv_is_wext_netdev(net_device))
321 wifi_flags |= BATADV_HARDIF_WIFI_WEXT_DIRECT;
322
323 if (batadv_is_cfg80211_netdev(net_device))
324 wifi_flags |= BATADV_HARDIF_WIFI_CFG80211_DIRECT;
325
326 real_netdev = batadv_get_real_netdevice(net_device);
327 if (!real_netdev)
328 return wifi_flags;
329
330 if (real_netdev == net_device)
331 goto out;
332
333 if (batadv_is_wext_netdev(real_netdev))
334 wifi_flags |= BATADV_HARDIF_WIFI_WEXT_INDIRECT;
335
336 if (batadv_is_cfg80211_netdev(real_netdev))
337 wifi_flags |= BATADV_HARDIF_WIFI_CFG80211_INDIRECT;
338
339out:
340 dev_put(real_netdev);
341 return wifi_flags;
342}
343
344
345
346
347
348
349
350
351
352bool batadv_is_cfg80211_hardif(struct batadv_hard_iface *hard_iface)
353{
354 u32 allowed_flags = 0;
355
356 allowed_flags |= BATADV_HARDIF_WIFI_CFG80211_DIRECT;
357 allowed_flags |= BATADV_HARDIF_WIFI_CFG80211_INDIRECT;
358
359 return !!(hard_iface->wifi_flags & allowed_flags);
360}
361
362
363
364
365
366
367
368bool batadv_is_wifi_hardif(struct batadv_hard_iface *hard_iface)
369{
370 if (!hard_iface)
371 return false;
372
373 return hard_iface->wifi_flags != 0;
374}
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391int batadv_hardif_no_broadcast(struct batadv_hard_iface *if_outgoing,
392 u8 *orig_addr, u8 *orig_neigh)
393{
394 struct batadv_hardif_neigh_node *hardif_neigh;
395 struct hlist_node *first;
396 int ret = BATADV_HARDIF_BCAST_OK;
397
398 rcu_read_lock();
399
400
401 first = rcu_dereference(hlist_first_rcu(&if_outgoing->neigh_list));
402 if (!first) {
403 ret = BATADV_HARDIF_BCAST_NORECIPIENT;
404 goto out;
405 }
406
407
408 if (rcu_dereference(hlist_next_rcu(first)))
409 goto out;
410
411 hardif_neigh = hlist_entry(first, struct batadv_hardif_neigh_node,
412 list);
413
414
415 if (orig_addr && batadv_compare_eth(hardif_neigh->orig, orig_addr)) {
416 ret = BATADV_HARDIF_BCAST_DUPORIG;
417
418 } else if (orig_neigh &&
419 batadv_compare_eth(hardif_neigh->orig, orig_neigh)) {
420 ret = BATADV_HARDIF_BCAST_DUPFWD;
421 }
422
423out:
424 rcu_read_unlock();
425 return ret;
426}
427
428static struct batadv_hard_iface *
429batadv_hardif_get_active(const struct net_device *soft_iface)
430{
431 struct batadv_hard_iface *hard_iface;
432
433 rcu_read_lock();
434 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
435 if (hard_iface->soft_iface != soft_iface)
436 continue;
437
438 if (hard_iface->if_status == BATADV_IF_ACTIVE &&
439 kref_get_unless_zero(&hard_iface->refcount))
440 goto out;
441 }
442
443 hard_iface = NULL;
444
445out:
446 rcu_read_unlock();
447 return hard_iface;
448}
449
450static void batadv_primary_if_update_addr(struct batadv_priv *bat_priv,
451 struct batadv_hard_iface *oldif)
452{
453 struct batadv_hard_iface *primary_if;
454
455 primary_if = batadv_primary_if_get_selected(bat_priv);
456 if (!primary_if)
457 goto out;
458
459 batadv_dat_init_own_addr(bat_priv, primary_if);
460 batadv_bla_update_orig_address(bat_priv, primary_if, oldif);
461out:
462 if (primary_if)
463 batadv_hardif_put(primary_if);
464}
465
466static void batadv_primary_if_select(struct batadv_priv *bat_priv,
467 struct batadv_hard_iface *new_hard_iface)
468{
469 struct batadv_hard_iface *curr_hard_iface;
470
471 ASSERT_RTNL();
472
473 if (new_hard_iface)
474 kref_get(&new_hard_iface->refcount);
475
476 curr_hard_iface = rcu_replace_pointer(bat_priv->primary_if,
477 new_hard_iface, 1);
478
479 if (!new_hard_iface)
480 goto out;
481
482 bat_priv->algo_ops->iface.primary_set(new_hard_iface);
483 batadv_primary_if_update_addr(bat_priv, curr_hard_iface);
484
485out:
486 if (curr_hard_iface)
487 batadv_hardif_put(curr_hard_iface);
488}
489
490static bool
491batadv_hardif_is_iface_up(const struct batadv_hard_iface *hard_iface)
492{
493 if (hard_iface->net_dev->flags & IFF_UP)
494 return true;
495
496 return false;
497}
498
499static void batadv_check_known_mac_addr(const struct net_device *net_dev)
500{
501 const struct batadv_hard_iface *hard_iface;
502
503 rcu_read_lock();
504 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
505 if (hard_iface->if_status != BATADV_IF_ACTIVE &&
506 hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)
507 continue;
508
509 if (hard_iface->net_dev == net_dev)
510 continue;
511
512 if (!batadv_compare_eth(hard_iface->net_dev->dev_addr,
513 net_dev->dev_addr))
514 continue;
515
516 pr_warn("The newly added mac address (%pM) already exists on: %s\n",
517 net_dev->dev_addr, hard_iface->net_dev->name);
518 pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n");
519 }
520 rcu_read_unlock();
521}
522
523
524
525
526
527static void batadv_hardif_recalc_extra_skbroom(struct net_device *soft_iface)
528{
529 const struct batadv_hard_iface *hard_iface;
530 unsigned short lower_header_len = ETH_HLEN;
531 unsigned short lower_headroom = 0;
532 unsigned short lower_tailroom = 0;
533 unsigned short needed_headroom;
534
535 rcu_read_lock();
536 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
537 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
538 continue;
539
540 if (hard_iface->soft_iface != soft_iface)
541 continue;
542
543 lower_header_len = max_t(unsigned short, lower_header_len,
544 hard_iface->net_dev->hard_header_len);
545
546 lower_headroom = max_t(unsigned short, lower_headroom,
547 hard_iface->net_dev->needed_headroom);
548
549 lower_tailroom = max_t(unsigned short, lower_tailroom,
550 hard_iface->net_dev->needed_tailroom);
551 }
552 rcu_read_unlock();
553
554 needed_headroom = lower_headroom + (lower_header_len - ETH_HLEN);
555 needed_headroom += batadv_max_header_len();
556
557 soft_iface->needed_headroom = needed_headroom;
558 soft_iface->needed_tailroom = lower_tailroom;
559}
560
561
562
563
564
565
566
567
568int batadv_hardif_min_mtu(struct net_device *soft_iface)
569{
570 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
571 const struct batadv_hard_iface *hard_iface;
572 int min_mtu = INT_MAX;
573
574 rcu_read_lock();
575 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
576 if (hard_iface->if_status != BATADV_IF_ACTIVE &&
577 hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)
578 continue;
579
580 if (hard_iface->soft_iface != soft_iface)
581 continue;
582
583 min_mtu = min_t(int, hard_iface->net_dev->mtu, min_mtu);
584 }
585 rcu_read_unlock();
586
587 if (atomic_read(&bat_priv->fragmentation) == 0)
588 goto out;
589
590
591
592
593
594 min_mtu = min_t(int, min_mtu, BATADV_FRAG_MAX_FRAG_SIZE);
595 min_mtu -= sizeof(struct batadv_frag_packet);
596 min_mtu *= BATADV_FRAG_MAX_FRAGMENTS;
597
598out:
599
600
601
602
603
604 atomic_set(&bat_priv->packet_size_max, min_mtu);
605
606
607
608
609
610
611 return min_t(int, min_mtu - batadv_max_header_len(), ETH_DATA_LEN);
612}
613
614
615
616
617
618
619void batadv_update_min_mtu(struct net_device *soft_iface)
620{
621 soft_iface->mtu = batadv_hardif_min_mtu(soft_iface);
622
623
624
625
626 batadv_tt_local_resize_to_mtu(soft_iface);
627}
628
629static void
630batadv_hardif_activate_interface(struct batadv_hard_iface *hard_iface)
631{
632 struct batadv_priv *bat_priv;
633 struct batadv_hard_iface *primary_if = NULL;
634
635 if (hard_iface->if_status != BATADV_IF_INACTIVE)
636 goto out;
637
638 bat_priv = netdev_priv(hard_iface->soft_iface);
639
640 bat_priv->algo_ops->iface.update_mac(hard_iface);
641 hard_iface->if_status = BATADV_IF_TO_BE_ACTIVATED;
642
643
644
645
646 primary_if = batadv_primary_if_get_selected(bat_priv);
647 if (!primary_if)
648 batadv_primary_if_select(bat_priv, hard_iface);
649
650 batadv_info(hard_iface->soft_iface, "Interface activated: %s\n",
651 hard_iface->net_dev->name);
652
653 batadv_update_min_mtu(hard_iface->soft_iface);
654
655 if (bat_priv->algo_ops->iface.activate)
656 bat_priv->algo_ops->iface.activate(hard_iface);
657
658out:
659 if (primary_if)
660 batadv_hardif_put(primary_if);
661}
662
663static void
664batadv_hardif_deactivate_interface(struct batadv_hard_iface *hard_iface)
665{
666 if (hard_iface->if_status != BATADV_IF_ACTIVE &&
667 hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)
668 return;
669
670 hard_iface->if_status = BATADV_IF_INACTIVE;
671
672 batadv_info(hard_iface->soft_iface, "Interface deactivated: %s\n",
673 hard_iface->net_dev->name);
674
675 batadv_update_min_mtu(hard_iface->soft_iface);
676}
677
678
679
680
681
682
683
684
685
686
687
688static int batadv_master_del_slave(struct batadv_hard_iface *slave,
689 struct net_device *master)
690{
691 int ret;
692
693 if (!master)
694 return 0;
695
696 ret = -EBUSY;
697 if (master->netdev_ops->ndo_del_slave)
698 ret = master->netdev_ops->ndo_del_slave(master, slave->net_dev);
699
700 return ret;
701}
702
703
704
705
706
707
708
709
710
711int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface,
712 struct net *net, const char *iface_name)
713{
714 struct batadv_priv *bat_priv;
715 struct net_device *soft_iface, *master;
716 __be16 ethertype = htons(ETH_P_BATMAN);
717 int max_header_len = batadv_max_header_len();
718 int ret;
719
720 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
721 goto out;
722
723 kref_get(&hard_iface->refcount);
724
725 soft_iface = dev_get_by_name(net, iface_name);
726
727 if (!soft_iface) {
728 soft_iface = batadv_softif_create(net, iface_name);
729
730 if (!soft_iface) {
731 ret = -ENOMEM;
732 goto err;
733 }
734
735
736 dev_hold(soft_iface);
737 }
738
739 if (!batadv_softif_is_valid(soft_iface)) {
740 pr_err("Can't create batman mesh interface %s: already exists as regular interface\n",
741 soft_iface->name);
742 ret = -EINVAL;
743 goto err_dev;
744 }
745
746
747
748
749 master = netdev_master_upper_dev_get(hard_iface->net_dev);
750 ret = batadv_master_del_slave(hard_iface, master);
751 if (ret)
752 goto err_dev;
753
754 hard_iface->soft_iface = soft_iface;
755 bat_priv = netdev_priv(hard_iface->soft_iface);
756
757 ret = netdev_master_upper_dev_link(hard_iface->net_dev,
758 soft_iface, NULL, NULL, NULL);
759 if (ret)
760 goto err_dev;
761
762 ret = bat_priv->algo_ops->iface.enable(hard_iface);
763 if (ret < 0)
764 goto err_upper;
765
766 hard_iface->if_status = BATADV_IF_INACTIVE;
767
768 kref_get(&hard_iface->refcount);
769 hard_iface->batman_adv_ptype.type = ethertype;
770 hard_iface->batman_adv_ptype.func = batadv_batman_skb_recv;
771 hard_iface->batman_adv_ptype.dev = hard_iface->net_dev;
772 dev_add_pack(&hard_iface->batman_adv_ptype);
773
774 batadv_info(hard_iface->soft_iface, "Adding interface: %s\n",
775 hard_iface->net_dev->name);
776
777 if (atomic_read(&bat_priv->fragmentation) &&
778 hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len)
779 batadv_info(hard_iface->soft_iface,
780 "The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. Packets going over this interface will be fragmented on layer2 which could impact the performance. Setting the MTU to %i would solve the problem.\n",
781 hard_iface->net_dev->name, hard_iface->net_dev->mtu,
782 ETH_DATA_LEN + max_header_len);
783
784 if (!atomic_read(&bat_priv->fragmentation) &&
785 hard_iface->net_dev->mtu < ETH_DATA_LEN + max_header_len)
786 batadv_info(hard_iface->soft_iface,
787 "The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. If you experience problems getting traffic through try increasing the MTU to %i.\n",
788 hard_iface->net_dev->name, hard_iface->net_dev->mtu,
789 ETH_DATA_LEN + max_header_len);
790
791 if (batadv_hardif_is_iface_up(hard_iface))
792 batadv_hardif_activate_interface(hard_iface);
793 else
794 batadv_err(hard_iface->soft_iface,
795 "Not using interface %s (retrying later): interface not active\n",
796 hard_iface->net_dev->name);
797
798 batadv_hardif_recalc_extra_skbroom(soft_iface);
799
800 if (bat_priv->algo_ops->iface.enabled)
801 bat_priv->algo_ops->iface.enabled(hard_iface);
802
803out:
804 return 0;
805
806err_upper:
807 netdev_upper_dev_unlink(hard_iface->net_dev, soft_iface);
808err_dev:
809 hard_iface->soft_iface = NULL;
810 dev_put(soft_iface);
811err:
812 batadv_hardif_put(hard_iface);
813 return ret;
814}
815
816
817
818
819
820
821
822
823
824
825
826static size_t batadv_hardif_cnt(const struct net_device *soft_iface)
827{
828 struct batadv_hard_iface *hard_iface;
829 size_t count = 0;
830
831 rcu_read_lock();
832 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
833 if (hard_iface->soft_iface != soft_iface)
834 continue;
835
836 count++;
837 }
838 rcu_read_unlock();
839
840 return count;
841}
842
843
844
845
846
847
848
849void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface,
850 enum batadv_hard_if_cleanup autodel)
851{
852 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
853 struct batadv_hard_iface *primary_if = NULL;
854
855 batadv_hardif_deactivate_interface(hard_iface);
856
857 if (hard_iface->if_status != BATADV_IF_INACTIVE)
858 goto out;
859
860 batadv_info(hard_iface->soft_iface, "Removing interface: %s\n",
861 hard_iface->net_dev->name);
862 dev_remove_pack(&hard_iface->batman_adv_ptype);
863 batadv_hardif_put(hard_iface);
864
865 primary_if = batadv_primary_if_get_selected(bat_priv);
866 if (hard_iface == primary_if) {
867 struct batadv_hard_iface *new_if;
868
869 new_if = batadv_hardif_get_active(hard_iface->soft_iface);
870 batadv_primary_if_select(bat_priv, new_if);
871
872 if (new_if)
873 batadv_hardif_put(new_if);
874 }
875
876 bat_priv->algo_ops->iface.disable(hard_iface);
877 hard_iface->if_status = BATADV_IF_NOT_IN_USE;
878
879
880 batadv_purge_orig_ref(bat_priv);
881 batadv_purge_outstanding_packets(bat_priv, hard_iface);
882 dev_put(hard_iface->soft_iface);
883
884 netdev_upper_dev_unlink(hard_iface->net_dev, hard_iface->soft_iface);
885 batadv_hardif_recalc_extra_skbroom(hard_iface->soft_iface);
886
887
888 if (batadv_hardif_cnt(hard_iface->soft_iface) <= 1) {
889 batadv_gw_check_client_stop(bat_priv);
890
891 if (autodel == BATADV_IF_CLEANUP_AUTO)
892 batadv_softif_destroy_sysfs(hard_iface->soft_iface);
893 }
894
895 hard_iface->soft_iface = NULL;
896 batadv_hardif_put(hard_iface);
897
898out:
899 if (primary_if)
900 batadv_hardif_put(primary_if);
901}
902
903static struct batadv_hard_iface *
904batadv_hardif_add_interface(struct net_device *net_dev)
905{
906 struct batadv_hard_iface *hard_iface;
907 int ret;
908
909 ASSERT_RTNL();
910
911 if (!batadv_is_valid_iface(net_dev))
912 goto out;
913
914 dev_hold(net_dev);
915
916 hard_iface = kzalloc(sizeof(*hard_iface), GFP_ATOMIC);
917 if (!hard_iface)
918 goto release_dev;
919
920 ret = batadv_sysfs_add_hardif(&hard_iface->hardif_obj, net_dev);
921 if (ret)
922 goto free_if;
923
924 hard_iface->net_dev = net_dev;
925 hard_iface->soft_iface = NULL;
926 hard_iface->if_status = BATADV_IF_NOT_IN_USE;
927
928 batadv_debugfs_add_hardif(hard_iface);
929
930 INIT_LIST_HEAD(&hard_iface->list);
931 INIT_HLIST_HEAD(&hard_iface->neigh_list);
932
933 mutex_init(&hard_iface->bat_iv.ogm_buff_mutex);
934 spin_lock_init(&hard_iface->neigh_list_lock);
935 kref_init(&hard_iface->refcount);
936
937 hard_iface->num_bcasts = BATADV_NUM_BCASTS_DEFAULT;
938 hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_dev);
939 if (batadv_is_wifi_hardif(hard_iface))
940 hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS;
941
942 atomic_set(&hard_iface->hop_penalty, 0);
943
944 batadv_v_hardif_init(hard_iface);
945
946 batadv_check_known_mac_addr(hard_iface->net_dev);
947 kref_get(&hard_iface->refcount);
948 list_add_tail_rcu(&hard_iface->list, &batadv_hardif_list);
949 batadv_hardif_generation++;
950
951 return hard_iface;
952
953free_if:
954 kfree(hard_iface);
955release_dev:
956 dev_put(net_dev);
957out:
958 return NULL;
959}
960
961static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface)
962{
963 ASSERT_RTNL();
964
965
966 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
967 batadv_hardif_disable_interface(hard_iface,
968 BATADV_IF_CLEANUP_KEEP);
969
970 if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
971 return;
972
973 hard_iface->if_status = BATADV_IF_TO_BE_REMOVED;
974 batadv_debugfs_del_hardif(hard_iface);
975 batadv_sysfs_del_hardif(&hard_iface->hardif_obj);
976 batadv_hardif_put(hard_iface);
977}
978
979
980
981
982void batadv_hardif_remove_interfaces(void)
983{
984 struct batadv_hard_iface *hard_iface, *hard_iface_tmp;
985
986 rtnl_lock();
987 list_for_each_entry_safe(hard_iface, hard_iface_tmp,
988 &batadv_hardif_list, list) {
989 list_del_rcu(&hard_iface->list);
990 batadv_hardif_generation++;
991 batadv_hardif_remove_interface(hard_iface);
992 }
993 rtnl_unlock();
994}
995
996
997
998
999
1000
1001
1002
1003static int batadv_hard_if_event_softif(unsigned long event,
1004 struct net_device *net_dev)
1005{
1006 struct batadv_priv *bat_priv;
1007
1008 switch (event) {
1009 case NETDEV_REGISTER:
1010 batadv_sysfs_add_meshif(net_dev);
1011 bat_priv = netdev_priv(net_dev);
1012 batadv_softif_create_vlan(bat_priv, BATADV_NO_FLAGS);
1013 break;
1014 case NETDEV_CHANGENAME:
1015 batadv_debugfs_rename_meshif(net_dev);
1016 break;
1017 }
1018
1019 return NOTIFY_DONE;
1020}
1021
1022static int batadv_hard_if_event(struct notifier_block *this,
1023 unsigned long event, void *ptr)
1024{
1025 struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
1026 struct batadv_hard_iface *hard_iface;
1027 struct batadv_hard_iface *primary_if = NULL;
1028 struct batadv_priv *bat_priv;
1029
1030 if (batadv_softif_is_valid(net_dev))
1031 return batadv_hard_if_event_softif(event, net_dev);
1032
1033 hard_iface = batadv_hardif_get_by_netdev(net_dev);
1034 if (!hard_iface && (event == NETDEV_REGISTER ||
1035 event == NETDEV_POST_TYPE_CHANGE))
1036 hard_iface = batadv_hardif_add_interface(net_dev);
1037
1038 if (!hard_iface)
1039 goto out;
1040
1041 switch (event) {
1042 case NETDEV_UP:
1043 batadv_hardif_activate_interface(hard_iface);
1044 break;
1045 case NETDEV_GOING_DOWN:
1046 case NETDEV_DOWN:
1047 batadv_hardif_deactivate_interface(hard_iface);
1048 break;
1049 case NETDEV_UNREGISTER:
1050 case NETDEV_PRE_TYPE_CHANGE:
1051 list_del_rcu(&hard_iface->list);
1052 batadv_hardif_generation++;
1053
1054 batadv_hardif_remove_interface(hard_iface);
1055 break;
1056 case NETDEV_CHANGEMTU:
1057 if (hard_iface->soft_iface)
1058 batadv_update_min_mtu(hard_iface->soft_iface);
1059 break;
1060 case NETDEV_CHANGEADDR:
1061 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
1062 goto hardif_put;
1063
1064 batadv_check_known_mac_addr(hard_iface->net_dev);
1065
1066 bat_priv = netdev_priv(hard_iface->soft_iface);
1067 bat_priv->algo_ops->iface.update_mac(hard_iface);
1068
1069 primary_if = batadv_primary_if_get_selected(bat_priv);
1070 if (!primary_if)
1071 goto hardif_put;
1072
1073 if (hard_iface == primary_if)
1074 batadv_primary_if_update_addr(bat_priv, NULL);
1075 break;
1076 case NETDEV_CHANGEUPPER:
1077 hard_iface->wifi_flags = batadv_wifi_flags_evaluate(net_dev);
1078 if (batadv_is_wifi_hardif(hard_iface))
1079 hard_iface->num_bcasts = BATADV_NUM_BCASTS_WIRELESS;
1080 break;
1081 case NETDEV_CHANGENAME:
1082 batadv_debugfs_rename_hardif(hard_iface);
1083 break;
1084 default:
1085 break;
1086 }
1087
1088hardif_put:
1089 batadv_hardif_put(hard_iface);
1090out:
1091 if (primary_if)
1092 batadv_hardif_put(primary_if);
1093 return NOTIFY_DONE;
1094}
1095
1096struct notifier_block batadv_hard_if_notifier = {
1097 .notifier_call = batadv_hard_if_event,
1098};
1099