2 * Copyright (C) 2007-2011 B.A.T.M.A.N. contributors:
4 * Marek Lindner, Simon Wunderlich
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of version 2 of the GNU General Public
8 * License as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 #include "hard-interface.h"
24 #include "soft-interface.h"
26 #include "translation-table.h"
28 #include "bat_sysfs.h"
29 #include "originator.h"
32 #include <linux/if_arp.h>
34 /* protect update critical side of hardif_list - but not the content */
35 static DEFINE_SPINLOCK(hardif_list_lock);
38 static int batman_skb_recv(struct sk_buff *skb,
39 struct net_device *dev,
40 struct packet_type *ptype,
41 struct net_device *orig_dev);
43 void hardif_free_rcu(struct rcu_head *rcu)
45 struct hard_iface *hard_iface;
47 hard_iface = container_of(rcu, struct hard_iface, rcu);
48 dev_put(hard_iface->net_dev);
52 struct hard_iface *hardif_get_by_netdev(struct net_device *net_dev)
54 struct hard_iface *hard_iface;
57 list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
58 if (hard_iface->net_dev == net_dev &&
59 atomic_inc_not_zero(&hard_iface->refcount))
70 static int is_valid_iface(struct net_device *net_dev)
72 if (net_dev->flags & IFF_LOOPBACK)
75 if (net_dev->type != ARPHRD_ETHER)
78 if (net_dev->addr_len != ETH_ALEN)
81 /* no batman over batman */
82 if (softif_is_valid(net_dev))
85 /* Device is being bridged */
86 /* if (net_dev->priv_flags & IFF_BRIDGE_PORT)
92 static struct hard_iface *hardif_get_active(struct net_device *soft_iface)
94 struct hard_iface *hard_iface;
97 list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
98 if (hard_iface->soft_iface != soft_iface)
101 if (hard_iface->if_status == IF_ACTIVE &&
102 atomic_inc_not_zero(&hard_iface->refcount))
113 static void primary_if_update_addr(struct bat_priv *bat_priv)
115 struct vis_packet *vis_packet;
116 struct hard_iface *primary_if;
118 primary_if = primary_if_get_selected(bat_priv);
122 vis_packet = (struct vis_packet *)
123 bat_priv->my_vis_info->skb_packet->data;
124 memcpy(vis_packet->vis_orig, primary_if->net_dev->dev_addr, ETH_ALEN);
125 memcpy(vis_packet->sender_orig,
126 primary_if->net_dev->dev_addr, ETH_ALEN);
130 hardif_free_ref(primary_if);
133 static void primary_if_select(struct bat_priv *bat_priv,
134 struct hard_iface *new_hard_iface)
136 struct hard_iface *curr_hard_iface;
137 struct batman_packet *batman_packet;
139 spin_lock_bh(&hardif_list_lock);
141 if (new_hard_iface && !atomic_inc_not_zero(&new_hard_iface->refcount))
142 new_hard_iface = NULL;
144 curr_hard_iface = bat_priv->primary_if;
145 rcu_assign_pointer(bat_priv->primary_if, new_hard_iface);
148 hardif_free_ref(curr_hard_iface);
153 batman_packet = (struct batman_packet *)(new_hard_iface->packet_buff);
154 batman_packet->flags = PRIMARIES_FIRST_HOP;
155 batman_packet->ttl = TTL;
157 primary_if_update_addr(bat_priv);
160 * hacky trick to make sure that we send the HNA information via
161 * our new primary interface
163 atomic_set(&bat_priv->hna_local_changed, 1);
166 spin_unlock_bh(&hardif_list_lock);
169 static bool hardif_is_iface_up(struct hard_iface *hard_iface)
171 if (hard_iface->net_dev->flags & IFF_UP)
177 static void update_mac_addresses(struct hard_iface *hard_iface)
179 memcpy(((struct batman_packet *)(hard_iface->packet_buff))->orig,
180 hard_iface->net_dev->dev_addr, ETH_ALEN);
181 memcpy(((struct batman_packet *)(hard_iface->packet_buff))->prev_sender,
182 hard_iface->net_dev->dev_addr, ETH_ALEN);
185 static void check_known_mac_addr(struct net_device *net_dev)
187 struct hard_iface *hard_iface;
190 list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
191 if ((hard_iface->if_status != IF_ACTIVE) &&
192 (hard_iface->if_status != IF_TO_BE_ACTIVATED))
195 if (hard_iface->net_dev == net_dev)
198 if (!compare_eth(hard_iface->net_dev->dev_addr,
202 pr_warning("The newly added mac address (%pM) already exists "
203 "on: %s\n", net_dev->dev_addr,
204 hard_iface->net_dev->name);
205 pr_warning("It is strongly recommended to keep mac addresses "
206 "unique to avoid problems!\n");
211 int hardif_min_mtu(struct net_device *soft_iface)
213 struct bat_priv *bat_priv = netdev_priv(soft_iface);
214 struct hard_iface *hard_iface;
215 /* allow big frames if all devices are capable to do so
216 * (have MTU > 1500 + BAT_HEADER_LEN) */
217 int min_mtu = ETH_DATA_LEN;
219 if (atomic_read(&bat_priv->fragmentation))
223 list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
224 if ((hard_iface->if_status != IF_ACTIVE) &&
225 (hard_iface->if_status != IF_TO_BE_ACTIVATED))
228 if (hard_iface->soft_iface != soft_iface)
231 min_mtu = min_t(int, hard_iface->net_dev->mtu - BAT_HEADER_LEN,
239 /* adjusts the MTU if a new interface with a smaller MTU appeared. */
240 void update_min_mtu(struct net_device *soft_iface)
244 min_mtu = hardif_min_mtu(soft_iface);
245 if (soft_iface->mtu != min_mtu)
246 soft_iface->mtu = min_mtu;
249 static void hardif_activate_interface(struct hard_iface *hard_iface)
251 struct bat_priv *bat_priv;
252 struct hard_iface *primary_if = NULL;
254 if (hard_iface->if_status != IF_INACTIVE)
257 bat_priv = netdev_priv(hard_iface->soft_iface);
259 update_mac_addresses(hard_iface);
260 hard_iface->if_status = IF_TO_BE_ACTIVATED;
263 * the first active interface becomes our primary interface or
264 * the next active interface after the old primay interface was removed
266 primary_if = primary_if_get_selected(bat_priv);
268 primary_if_select(bat_priv, hard_iface);
270 bat_info(hard_iface->soft_iface, "Interface activated: %s\n",
271 hard_iface->net_dev->name);
273 update_min_mtu(hard_iface->soft_iface);
277 hardif_free_ref(primary_if);
280 static void hardif_deactivate_interface(struct hard_iface *hard_iface)
282 if ((hard_iface->if_status != IF_ACTIVE) &&
283 (hard_iface->if_status != IF_TO_BE_ACTIVATED))
286 hard_iface->if_status = IF_INACTIVE;
288 bat_info(hard_iface->soft_iface, "Interface deactivated: %s\n",
289 hard_iface->net_dev->name);
291 update_min_mtu(hard_iface->soft_iface);
294 int hardif_enable_interface(struct hard_iface *hard_iface, char *iface_name)
296 struct bat_priv *bat_priv;
297 struct batman_packet *batman_packet;
298 struct net_device *soft_iface;
301 if (hard_iface->if_status != IF_NOT_IN_USE)
304 if (!atomic_inc_not_zero(&hard_iface->refcount))
307 soft_iface = dev_get_by_name(&init_net, iface_name);
310 soft_iface = softif_create(iface_name);
317 /* dev_get_by_name() increases the reference counter for us */
318 dev_hold(soft_iface);
321 if (!softif_is_valid(soft_iface)) {
322 pr_err("Can't create batman mesh interface %s: "
323 "already exists as regular interface\n",
330 hard_iface->soft_iface = soft_iface;
331 bat_priv = netdev_priv(hard_iface->soft_iface);
332 hard_iface->packet_len = BAT_PACKET_LEN;
333 hard_iface->packet_buff = kmalloc(hard_iface->packet_len, GFP_ATOMIC);
335 if (!hard_iface->packet_buff) {
336 bat_err(hard_iface->soft_iface, "Can't add interface packet "
337 "(%s): out of memory\n", hard_iface->net_dev->name);
342 batman_packet = (struct batman_packet *)(hard_iface->packet_buff);
343 batman_packet->packet_type = BAT_PACKET;
344 batman_packet->version = COMPAT_VERSION;
345 batman_packet->flags = 0;
346 batman_packet->ttl = 2;
347 batman_packet->tq = TQ_MAX_VALUE;
348 batman_packet->num_hna = 0;
350 hard_iface->if_num = bat_priv->num_ifaces;
351 bat_priv->num_ifaces++;
352 hard_iface->if_status = IF_INACTIVE;
353 orig_hash_add_if(hard_iface, bat_priv->num_ifaces);
355 hard_iface->batman_adv_ptype.type = __constant_htons(ETH_P_BATMAN);
356 hard_iface->batman_adv_ptype.func = batman_skb_recv;
357 hard_iface->batman_adv_ptype.dev = hard_iface->net_dev;
358 dev_add_pack(&hard_iface->batman_adv_ptype);
360 atomic_set(&hard_iface->seqno, 1);
361 atomic_set(&hard_iface->frag_seqno, 1);
362 bat_info(hard_iface->soft_iface, "Adding interface: %s\n",
363 hard_iface->net_dev->name);
365 if (atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu <
366 ETH_DATA_LEN + BAT_HEADER_LEN)
367 bat_info(hard_iface->soft_iface,
368 "The MTU of interface %s is too small (%i) to handle "
369 "the transport of batman-adv packets. Packets going "
370 "over this interface will be fragmented on layer2 "
371 "which could impact the performance. Setting the MTU "
372 "to %zi would solve the problem.\n",
373 hard_iface->net_dev->name, hard_iface->net_dev->mtu,
374 ETH_DATA_LEN + BAT_HEADER_LEN);
376 if (!atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu <
377 ETH_DATA_LEN + BAT_HEADER_LEN)
378 bat_info(hard_iface->soft_iface,
379 "The MTU of interface %s is too small (%i) to handle "
380 "the transport of batman-adv packets. If you experience"
381 " problems getting traffic through try increasing the "
383 hard_iface->net_dev->name, hard_iface->net_dev->mtu,
384 ETH_DATA_LEN + BAT_HEADER_LEN);
386 if (hardif_is_iface_up(hard_iface))
387 hardif_activate_interface(hard_iface);
389 bat_err(hard_iface->soft_iface, "Not using interface %s "
390 "(retrying later): interface not active\n",
391 hard_iface->net_dev->name);
393 /* begin scheduling originator messages on that interface */
394 schedule_own_packet(hard_iface);
400 hardif_free_ref(hard_iface);
404 void hardif_disable_interface(struct hard_iface *hard_iface)
406 struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
407 struct hard_iface *primary_if = NULL;
409 if (hard_iface->if_status == IF_ACTIVE)
410 hardif_deactivate_interface(hard_iface);
412 if (hard_iface->if_status != IF_INACTIVE)
415 bat_info(hard_iface->soft_iface, "Removing interface: %s\n",
416 hard_iface->net_dev->name);
417 dev_remove_pack(&hard_iface->batman_adv_ptype);
419 bat_priv->num_ifaces--;
420 orig_hash_del_if(hard_iface, bat_priv->num_ifaces);
422 primary_if = primary_if_get_selected(bat_priv);
423 if (hard_iface == primary_if) {
424 struct hard_iface *new_if;
426 new_if = hardif_get_active(hard_iface->soft_iface);
427 primary_if_select(bat_priv, new_if);
430 hardif_free_ref(new_if);
433 kfree(hard_iface->packet_buff);
434 hard_iface->packet_buff = NULL;
435 hard_iface->if_status = IF_NOT_IN_USE;
437 /* delete all references to this hard_iface */
438 purge_orig_ref(bat_priv);
439 purge_outstanding_packets(bat_priv, hard_iface);
440 dev_put(hard_iface->soft_iface);
442 /* nobody uses this interface anymore */
443 if (!bat_priv->num_ifaces)
444 softif_destroy(hard_iface->soft_iface);
446 hard_iface->soft_iface = NULL;
447 hardif_free_ref(hard_iface);
451 hardif_free_ref(primary_if);
454 static struct hard_iface *hardif_add_interface(struct net_device *net_dev)
456 struct hard_iface *hard_iface;
459 ret = is_valid_iface(net_dev);
465 hard_iface = kmalloc(sizeof(struct hard_iface), GFP_ATOMIC);
467 pr_err("Can't add interface (%s): out of memory\n",
472 ret = sysfs_add_hardif(&hard_iface->hardif_obj, net_dev);
476 hard_iface->if_num = -1;
477 hard_iface->net_dev = net_dev;
478 hard_iface->soft_iface = NULL;
479 hard_iface->if_status = IF_NOT_IN_USE;
480 INIT_LIST_HEAD(&hard_iface->list);
481 /* extra reference for return */
482 atomic_set(&hard_iface->refcount, 2);
484 check_known_mac_addr(hard_iface->net_dev);
486 spin_lock(&hardif_list_lock);
487 list_add_tail_rcu(&hard_iface->list, &hardif_list);
488 spin_unlock(&hardif_list_lock);
500 static void hardif_remove_interface(struct hard_iface *hard_iface)
502 /* first deactivate interface */
503 if (hard_iface->if_status != IF_NOT_IN_USE)
504 hardif_disable_interface(hard_iface);
506 if (hard_iface->if_status != IF_NOT_IN_USE)
509 hard_iface->if_status = IF_TO_BE_REMOVED;
510 sysfs_del_hardif(&hard_iface->hardif_obj);
511 hardif_free_ref(hard_iface);
514 void hardif_remove_interfaces(void)
516 struct hard_iface *hard_iface, *hard_iface_tmp;
517 struct list_head if_queue;
519 INIT_LIST_HEAD(&if_queue);
521 spin_lock(&hardif_list_lock);
522 list_for_each_entry_safe(hard_iface, hard_iface_tmp,
523 &hardif_list, list) {
524 list_del_rcu(&hard_iface->list);
525 list_add_tail(&hard_iface->list, &if_queue);
527 spin_unlock(&hardif_list_lock);
530 list_for_each_entry_safe(hard_iface, hard_iface_tmp, &if_queue, list) {
531 hardif_remove_interface(hard_iface);
536 static int hard_if_event(struct notifier_block *this,
537 unsigned long event, void *ptr)
539 struct net_device *net_dev = (struct net_device *)ptr;
540 struct hard_iface *hard_iface = hardif_get_by_netdev(net_dev);
541 struct hard_iface *primary_if = NULL;
542 struct bat_priv *bat_priv;
544 if (!hard_iface && event == NETDEV_REGISTER)
545 hard_iface = hardif_add_interface(net_dev);
552 hardif_activate_interface(hard_iface);
554 case NETDEV_GOING_DOWN:
556 hardif_deactivate_interface(hard_iface);
558 case NETDEV_UNREGISTER:
559 spin_lock(&hardif_list_lock);
560 list_del_rcu(&hard_iface->list);
561 spin_unlock(&hardif_list_lock);
563 hardif_remove_interface(hard_iface);
565 case NETDEV_CHANGEMTU:
566 if (hard_iface->soft_iface)
567 update_min_mtu(hard_iface->soft_iface);
569 case NETDEV_CHANGEADDR:
570 if (hard_iface->if_status == IF_NOT_IN_USE)
573 check_known_mac_addr(hard_iface->net_dev);
574 update_mac_addresses(hard_iface);
576 bat_priv = netdev_priv(hard_iface->soft_iface);
577 primary_if = primary_if_get_selected(bat_priv);
581 if (hard_iface == primary_if)
582 primary_if_update_addr(bat_priv);
589 hardif_free_ref(hard_iface);
592 hardif_free_ref(primary_if);
596 /* receive a packet with the batman ethertype coming on a hard
598 static int batman_skb_recv(struct sk_buff *skb, struct net_device *dev,
599 struct packet_type *ptype,
600 struct net_device *orig_dev)
602 struct bat_priv *bat_priv;
603 struct batman_packet *batman_packet;
604 struct hard_iface *hard_iface;
607 hard_iface = container_of(ptype, struct hard_iface, batman_adv_ptype);
608 skb = skb_share_check(skb, GFP_ATOMIC);
610 /* skb was released by skb_share_check() */
614 /* packet should hold at least type and version */
615 if (unlikely(!pskb_may_pull(skb, 2)))
618 /* expect a valid ethernet header here. */
619 if (unlikely(skb->mac_len != sizeof(struct ethhdr)
620 || !skb_mac_header(skb)))
623 if (!hard_iface->soft_iface)
626 bat_priv = netdev_priv(hard_iface->soft_iface);
628 if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE)
631 /* discard frames on not active interfaces */
632 if (hard_iface->if_status != IF_ACTIVE)
635 batman_packet = (struct batman_packet *)skb->data;
637 if (batman_packet->version != COMPAT_VERSION) {
638 bat_dbg(DBG_BATMAN, bat_priv,
639 "Drop packet: incompatible batman version (%i)\n",
640 batman_packet->version);
644 /* all receive handlers return whether they received or reused
645 * the supplied skb. if not, we have to free the skb. */
647 switch (batman_packet->packet_type) {
648 /* batman originator packet */
650 ret = recv_bat_packet(skb, hard_iface);
653 /* batman icmp packet */
655 ret = recv_icmp_packet(skb, hard_iface);
660 ret = recv_unicast_packet(skb, hard_iface);
663 /* fragmented unicast packet */
664 case BAT_UNICAST_FRAG:
665 ret = recv_ucast_frag_packet(skb, hard_iface);
668 /* broadcast packet */
670 ret = recv_bcast_packet(skb, hard_iface);
675 ret = recv_vis_packet(skb, hard_iface);
681 if (ret == NET_RX_DROP)
684 /* return NET_RX_SUCCESS in any case as we
685 * most probably dropped the packet for
686 * routing-logical reasons. */
688 return NET_RX_SUCCESS;
696 struct notifier_block hard_if_notifier = {
697 .notifier_call = hard_if_event,