2017-11-19 21:05:11 +07:00
// SPDX-License-Identifier: GPL-2.0
2019-01-01 05:59:59 +07:00
/* Copyright (C) 2007-2019 B.A.T.M.A.N. contributors:
2010-12-13 18:19:28 +07:00
*
* Marek Lindner , Simon Wunderlich
*/
# include "hard-interface.h"
2015-04-18 00:40:28 +07:00
# include "main.h"
2010-12-13 18:19:28 +07:00
2016-01-16 16:29:54 +07:00
# include <linux/atomic.h>
2015-04-18 00:40:28 +07:00
# include <linux/byteorder/generic.h>
# include <linux/errno.h>
2017-11-19 23:12:02 +07:00
# include <linux/gfp.h>
2016-05-15 16:07:42 +07:00
# include <linux/if.h>
2010-12-13 18:19:28 +07:00
# include <linux/if_arp.h>
2012-11-26 06:38:50 +07:00
# include <linux/if_ether.h>
2015-04-18 00:40:28 +07:00
# include <linux/kernel.h>
2016-01-16 16:29:54 +07:00
# include <linux/kref.h>
2019-05-24 21:28:50 +07:00
# include <linux/limits.h>
2015-04-18 00:40:28 +07:00
# include <linux/list.h>
2019-10-03 22:02:01 +07:00
# include <linux/mutex.h>
2015-04-18 00:40:28 +07:00
# include <linux/netdevice.h>
# include <linux/printk.h>
# include <linux/rculist.h>
# include <linux/rtnetlink.h>
# include <linux/slab.h>
2015-08-04 20:09:55 +07:00
# include <linux/spinlock.h>
2016-07-03 18:31:33 +07:00
# include <net/net_namespace.h>
# include <net/rtnetlink.h>
2017-12-21 16:17:41 +07:00
# include <uapi/linux/batadv_packet.h>
2015-04-18 00:40:28 +07:00
2016-05-15 16:07:46 +07:00
# include "bat_v.h"
2015-04-18 00:40:28 +07:00
# include "bridge_loop_avoidance.h"
# include "debugfs.h"
# include "distributed-arp-table.h"
# include "gateway_client.h"
2016-05-16 04:48:31 +07:00
# include "log.h"
2015-04-18 00:40:28 +07:00
# include "originator.h"
# include "send.h"
# include "soft-interface.h"
# include "sysfs.h"
# include "translation-table.h"
2010-12-13 18:19:28 +07:00
2016-01-05 18:06:26 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_hardif_release ( ) - release hard interface from lists and queue for
2016-01-05 18:06:26 +07:00
* free after rcu grace period
2016-01-16 16:29:54 +07:00
* @ ref : kref pointer of the hard interface
2016-01-05 18:06:26 +07:00
*/
2016-01-16 16:29:54 +07:00
void batadv_hardif_release ( struct kref * ref )
2010-12-13 18:19:28 +07:00
{
2016-01-16 16:29:54 +07:00
struct batadv_hard_iface * hard_iface ;
hard_iface = container_of ( ref , struct batadv_hard_iface , refcount ) ;
2011-02-18 19:33:20 +07:00
dev_put ( hard_iface - > net_dev ) ;
2016-01-05 18:06:26 +07:00
kfree_rcu ( hard_iface , rcu ) ;
2010-12-13 18:19:28 +07:00
}
2017-12-03 01:51:53 +07:00
/**
* batadv_hardif_get_by_netdev ( ) - Get hard interface object of a net_device
* @ net_dev : net_device to search for
*
* Return : batadv_hard_iface of net_dev ( with increased refcnt ) , NULL on errors
*/
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface *
batadv_hardif_get_by_netdev ( const struct net_device * net_dev )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface * hard_iface ;
2010-12-13 18:19:28 +07:00
rcu_read_lock ( ) ;
2012-05-12 07:09:42 +07:00
list_for_each_entry_rcu ( hard_iface , & batadv_hardif_list , list ) {
2011-02-18 19:33:20 +07:00
if ( hard_iface - > net_dev = = net_dev & &
2016-01-16 16:29:54 +07:00
kref_get_unless_zero ( & hard_iface - > refcount ) )
2010-12-13 18:19:28 +07:00
goto out ;
}
2011-02-18 19:33:20 +07:00
hard_iface = NULL ;
2010-12-13 18:19:28 +07:00
out :
rcu_read_unlock ( ) ;
2011-02-18 19:33:20 +07:00
return hard_iface ;
2010-12-13 18:19:28 +07:00
}
2016-07-03 18:31:33 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_getlink_net ( ) - return link net namespace ( of use fallback )
2016-07-03 18:31:33 +07:00
* @ netdev : net_device to check
* @ fallback_net : return in case get_link_net is not available for @ netdev
*
* Return : result of rtnl_link_ops - > get_link_net or @ fallback_net
*/
2016-09-30 20:21:00 +07:00
static struct net * batadv_getlink_net ( const struct net_device * netdev ,
struct net * fallback_net )
2016-07-03 18:31:33 +07:00
{
if ( ! netdev - > rtnl_link_ops )
return fallback_net ;
if ( ! netdev - > rtnl_link_ops - > get_link_net )
return fallback_net ;
return netdev - > rtnl_link_ops - > get_link_net ( netdev ) ;
}
2016-02-12 04:15:57 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_mutual_parents ( ) - check if two devices are each others parent
2016-07-03 18:31:33 +07:00
* @ dev1 : 1 st net dev
* @ net1 : 1 st devices netns
* @ dev2 : 2 nd net dev
* @ net2 : 2 nd devices netns
2016-02-12 04:15:57 +07:00
*
* veth devices come in pairs and each is the parent of the other !
*
* Return : true if the devices are each others parent , otherwise false
*/
static bool batadv_mutual_parents ( const struct net_device * dev1 ,
2016-09-30 20:21:00 +07:00
struct net * net1 ,
2016-07-03 18:31:33 +07:00
const struct net_device * dev2 ,
2016-09-30 20:21:00 +07:00
struct net * net2 )
2016-02-12 04:15:57 +07:00
{
int dev1_parent_iflink = dev_get_iflink ( dev1 ) ;
int dev2_parent_iflink = dev_get_iflink ( dev2 ) ;
2016-07-03 18:31:33 +07:00
const struct net * dev1_parent_net ;
const struct net * dev2_parent_net ;
dev1_parent_net = batadv_getlink_net ( dev1 , net1 ) ;
dev2_parent_net = batadv_getlink_net ( dev2 , net2 ) ;
2016-02-12 04:15:57 +07:00
if ( ! dev1_parent_iflink | | ! dev2_parent_iflink )
return false ;
return ( dev1_parent_iflink = = dev2 - > ifindex ) & &
2016-07-03 18:31:33 +07:00
( dev2_parent_iflink = = dev1 - > ifindex ) & &
net_eq ( dev1_parent_net , net2 ) & &
net_eq ( dev2_parent_net , net1 ) ;
2016-02-12 04:15:57 +07:00
}
2012-09-09 15:46:46 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_is_on_batman_iface ( ) - check if a device is a batman iface descendant
2012-09-09 15:46:46 +07:00
* @ net_dev : the device to check
*
* If the user creates any virtual device on top of a batman - adv interface , it
* is important to prevent this new interface to be used to create a new mesh
* network ( this behaviour would lead to a batman - over - batman configuration ) .
* This function recursively checks all the fathers of the device passed as
* argument looking for a batman - adv soft interface .
*
2015-09-16 00:00:48 +07:00
* Return : true if the device is descendant of a batman - adv mesh interface ( or
2012-09-09 15:46:46 +07:00
* if it is a batman - adv interface itself ) , false otherwise
*/
static bool batadv_is_on_batman_iface ( const struct net_device * net_dev )
{
2016-04-21 17:57:27 +07:00
struct net * net = dev_net ( net_dev ) ;
2016-07-03 18:31:33 +07:00
struct net_device * parent_dev ;
2016-09-30 20:21:00 +07:00
struct net * parent_net ;
2012-09-09 15:46:46 +07:00
bool ret ;
/* check if this is a batman-adv mesh interface */
if ( batadv_softif_is_valid ( net_dev ) )
return true ;
/* no more parents..stop recursion */
2015-04-02 22:07:00 +07:00
if ( dev_get_iflink ( net_dev ) = = 0 | |
dev_get_iflink ( net_dev ) = = net_dev - > ifindex )
2012-09-09 15:46:46 +07:00
return false ;
2016-07-03 18:31:33 +07:00
parent_net = batadv_getlink_net ( net_dev , net ) ;
2012-09-09 15:46:46 +07:00
/* recurse over the parent device */
2016-07-03 18:31:33 +07:00
parent_dev = __dev_get_by_index ( ( struct net * ) parent_net ,
dev_get_iflink ( net_dev ) ) ;
2012-09-09 15:46:46 +07:00
/* if we got a NULL parent_dev there is something broken.. */
2018-12-30 18:46:01 +07:00
if ( ! parent_dev ) {
pr_err ( " Cannot find parent device \n " ) ;
2012-09-09 15:46:46 +07:00
return false ;
2018-12-30 18:46:01 +07:00
}
2012-09-09 15:46:46 +07:00
2016-07-03 18:31:33 +07:00
if ( batadv_mutual_parents ( net_dev , net , parent_dev , parent_net ) )
2016-02-12 04:15:57 +07:00
return false ;
2012-09-09 15:46:46 +07:00
ret = batadv_is_on_batman_iface ( parent_dev ) ;
return ret ;
}
2016-02-23 03:02:39 +07:00
static bool batadv_is_valid_iface ( const struct net_device * net_dev )
2010-12-13 18:19:28 +07:00
{
if ( net_dev - > flags & IFF_LOOPBACK )
2016-02-23 03:02:39 +07:00
return false ;
2010-12-13 18:19:28 +07:00
if ( net_dev - > type ! = ARPHRD_ETHER )
2016-02-23 03:02:39 +07:00
return false ;
2010-12-13 18:19:28 +07:00
if ( net_dev - > addr_len ! = ETH_ALEN )
2016-02-23 03:02:39 +07:00
return false ;
2010-12-13 18:19:28 +07:00
/* no batman over batman */
2012-09-09 15:46:46 +07:00
if ( batadv_is_on_batman_iface ( net_dev ) )
2016-02-23 03:02:39 +07:00
return false ;
2010-12-13 18:19:28 +07:00
2016-02-23 03:02:39 +07:00
return true ;
2010-12-13 18:19:28 +07:00
}
2013-03-10 05:14:22 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_get_real_netdevice ( ) - check if the given netdev struct is a virtual
2016-09-30 20:21:04 +07:00
* interface on top of another ' real ' interface
* @ netdev : the device to check
*
2016-09-30 20:21:05 +07:00
* Callers must hold the rtnl semaphore . You may want batadv_get_real_netdev ( )
* instead of this .
*
2016-09-30 20:21:04 +07:00
* Return : the ' real ' net device or the original net device and NULL in case
* of an error .
*/
static struct net_device * batadv_get_real_netdevice ( struct net_device * netdev )
{
struct batadv_hard_iface * hard_iface = NULL ;
struct net_device * real_netdev = NULL ;
struct net * real_net ;
struct net * net ;
int ifindex ;
ASSERT_RTNL ( ) ;
if ( ! netdev )
return NULL ;
if ( netdev - > ifindex = = dev_get_iflink ( netdev ) ) {
dev_hold ( netdev ) ;
return netdev ;
}
hard_iface = batadv_hardif_get_by_netdev ( netdev ) ;
if ( ! hard_iface | | ! hard_iface - > soft_iface )
goto out ;
net = dev_net ( hard_iface - > soft_iface ) ;
ifindex = dev_get_iflink ( netdev ) ;
real_net = batadv_getlink_net ( netdev , net ) ;
real_netdev = dev_get_by_index ( real_net , ifindex ) ;
out :
if ( hard_iface )
batadv_hardif_put ( hard_iface ) ;
return real_netdev ;
}
2016-09-30 20:21:05 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_get_real_netdev ( ) - check if the given net_device struct is a virtual
2016-09-30 20:21:05 +07:00
* interface on top of another ' real ' interface
2013-03-10 05:14:22 +07:00
* @ net_device : the device to check
*
2016-09-30 20:21:05 +07:00
* Return : the ' real ' net device or the original net device and NULL in case
* of an error .
2013-03-10 05:14:22 +07:00
*/
2016-09-30 20:21:05 +07:00
struct net_device * batadv_get_real_netdev ( struct net_device * net_device )
{
struct net_device * real_netdev ;
rtnl_lock ( ) ;
real_netdev = batadv_get_real_netdevice ( net_device ) ;
rtnl_unlock ( ) ;
return real_netdev ;
}
2016-09-30 20:21:03 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_is_wext_netdev ( ) - check if the given net_device struct is a
2016-09-30 20:21:03 +07:00
* wext wifi interface
* @ net_device : the device to check
*
* Return : true if the net device is a wext wireless device , false
* otherwise .
*/
static bool batadv_is_wext_netdev ( struct net_device * net_device )
2013-03-10 05:14:22 +07:00
{
2013-10-13 07:50:18 +07:00
if ( ! net_device )
return false ;
2013-03-10 05:14:22 +07:00
# ifdef CONFIG_WIRELESS_EXT
/* pre-cfg80211 drivers have to implement WEXT, so it is possible to
* check for wireless_handlers ! = NULL
*/
if ( net_device - > wireless_handlers )
return true ;
# endif
2016-09-30 20:21:03 +07:00
return false ;
}
2016-09-30 20:21:02 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_is_cfg80211_netdev ( ) - check if the given net_device struct is a
2016-09-30 20:21:02 +07:00
* cfg80211 wifi interface
* @ net_device : the device to check
*
* Return : true if the net device is a cfg80211 wireless device , false
* otherwise .
*/
2016-09-30 20:21:03 +07:00
static bool batadv_is_cfg80211_netdev ( struct net_device * net_device )
2016-09-30 20:21:02 +07:00
{
if ( ! net_device )
return false ;
2013-03-10 05:14:22 +07:00
/* cfg80211 drivers have to set ieee80211_ptr */
if ( net_device - > ieee80211_ptr )
return true ;
return false ;
}
/**
2017-12-03 01:51:47 +07:00
* batadv_wifi_flags_evaluate ( ) - calculate wifi flags for net_device
2013-03-10 05:14:22 +07:00
* @ net_device : the device to check
*
2016-09-30 20:21:03 +07:00
* Return : batadv_hard_iface_wifi_flags flags of the device
*/
static u32 batadv_wifi_flags_evaluate ( struct net_device * net_device )
{
u32 wifi_flags = 0 ;
2016-09-30 20:21:04 +07:00
struct net_device * real_netdev ;
2016-09-30 20:21:03 +07:00
if ( batadv_is_wext_netdev ( net_device ) )
wifi_flags | = BATADV_HARDIF_WIFI_WEXT_DIRECT ;
if ( batadv_is_cfg80211_netdev ( net_device ) )
wifi_flags | = BATADV_HARDIF_WIFI_CFG80211_DIRECT ;
2016-09-30 20:21:04 +07:00
real_netdev = batadv_get_real_netdevice ( net_device ) ;
if ( ! real_netdev )
return wifi_flags ;
if ( real_netdev = = net_device )
goto out ;
if ( batadv_is_wext_netdev ( real_netdev ) )
wifi_flags | = BATADV_HARDIF_WIFI_WEXT_INDIRECT ;
if ( batadv_is_cfg80211_netdev ( real_netdev ) )
wifi_flags | = BATADV_HARDIF_WIFI_CFG80211_INDIRECT ;
out :
dev_put ( real_netdev ) ;
2016-09-30 20:21:03 +07:00
return wifi_flags ;
}
/**
2017-12-03 01:51:47 +07:00
* batadv_is_cfg80211_hardif ( ) - check if the given hardif is a cfg80211 wifi
2016-09-30 20:21:03 +07:00
* interface
* @ hard_iface : the device to check
*
* Return : true if the net device is a cfg80211 wireless device , false
* otherwise .
*/
bool batadv_is_cfg80211_hardif ( struct batadv_hard_iface * hard_iface )
{
u32 allowed_flags = 0 ;
allowed_flags | = BATADV_HARDIF_WIFI_CFG80211_DIRECT ;
2016-09-30 20:21:04 +07:00
allowed_flags | = BATADV_HARDIF_WIFI_CFG80211_INDIRECT ;
2016-09-30 20:21:03 +07:00
return ! ! ( hard_iface - > wifi_flags & allowed_flags ) ;
}
/**
2017-12-03 01:51:47 +07:00
* batadv_is_wifi_hardif ( ) - check if the given hardif is a wifi interface
2016-09-30 20:21:03 +07:00
* @ hard_iface : the device to check
*
2015-09-16 00:00:48 +07:00
* Return : true if the net device is a 802.11 wireless device , false otherwise .
2013-03-10 05:14:22 +07:00
*/
2016-09-30 20:21:03 +07:00
bool batadv_is_wifi_hardif ( struct batadv_hard_iface * hard_iface )
2013-03-10 05:14:22 +07:00
{
2016-09-30 20:21:03 +07:00
if ( ! hard_iface )
2013-10-13 07:50:18 +07:00
return false ;
2016-09-30 20:21:03 +07:00
return hard_iface - > wifi_flags ! = 0 ;
2013-03-10 05:14:22 +07:00
}
batman-adv: Simple (re)broadcast avoidance
With this patch, (re)broadcasting on a specific interfaces is avoided:
* No neighbor: There is no need to broadcast on an interface if there
is no node behind it.
* Single neighbor is source: If there is just one neighbor on an
interface and if this neighbor is the one we actually got this
broadcast packet from, then we do not need to echo it back.
* Single neighbor is originator: If there is just one neighbor on
an interface and if this neighbor is the originator of this
broadcast packet, then we do not need to echo it back.
Goodies for BATMAN V:
("Upgrade your BATMAN IV network to V now to get these for free!")
Thanks to the split of OGMv1 into two packet types, OGMv2 and ELP
that is, we can now apply the same optimizations stated above to OGMv2
packets, too.
Furthermore, with BATMAN V, rebroadcasts can be reduced in certain
multi interface cases, too, where BATMAN IV cannot. This is thanks to
the removal of the "secondary interface originator" concept in BATMAN V.
Signed-off-by: Linus Lüssing <linus.luessing@c0d3.blue>
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Signed-off-by: Simon Wunderlich <sw@simonwunderlich.de>
2016-08-07 17:34:19 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_hardif_no_broadcast ( ) - check whether ( re ) broadcast is necessary
batman-adv: Simple (re)broadcast avoidance
With this patch, (re)broadcasting on a specific interfaces is avoided:
* No neighbor: There is no need to broadcast on an interface if there
is no node behind it.
* Single neighbor is source: If there is just one neighbor on an
interface and if this neighbor is the one we actually got this
broadcast packet from, then we do not need to echo it back.
* Single neighbor is originator: If there is just one neighbor on
an interface and if this neighbor is the originator of this
broadcast packet, then we do not need to echo it back.
Goodies for BATMAN V:
("Upgrade your BATMAN IV network to V now to get these for free!")
Thanks to the split of OGMv1 into two packet types, OGMv2 and ELP
that is, we can now apply the same optimizations stated above to OGMv2
packets, too.
Furthermore, with BATMAN V, rebroadcasts can be reduced in certain
multi interface cases, too, where BATMAN IV cannot. This is thanks to
the removal of the "secondary interface originator" concept in BATMAN V.
Signed-off-by: Linus Lüssing <linus.luessing@c0d3.blue>
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Signed-off-by: Simon Wunderlich <sw@simonwunderlich.de>
2016-08-07 17:34:19 +07:00
* @ if_outgoing : the outgoing interface checked and considered for ( re ) broadcast
* @ orig_addr : the originator of this packet
* @ orig_neigh : originator address of the forwarder we just got the packet from
* ( NULL if we originated )
*
* Checks whether a packet needs to be ( re ) broadcasted on the given interface .
*
* Return :
* BATADV_HARDIF_BCAST_NORECIPIENT : No neighbor on interface
* BATADV_HARDIF_BCAST_DUPFWD : Just one neighbor , but it is the forwarder
* BATADV_HARDIF_BCAST_DUPORIG : Just one neighbor , but it is the originator
* BATADV_HARDIF_BCAST_OK : Several neighbors , must broadcast
*/
int batadv_hardif_no_broadcast ( struct batadv_hard_iface * if_outgoing ,
u8 * orig_addr , u8 * orig_neigh )
{
struct batadv_hardif_neigh_node * hardif_neigh ;
struct hlist_node * first ;
int ret = BATADV_HARDIF_BCAST_OK ;
rcu_read_lock ( ) ;
/* 0 neighbors -> no (re)broadcast */
first = rcu_dereference ( hlist_first_rcu ( & if_outgoing - > neigh_list ) ) ;
if ( ! first ) {
ret = BATADV_HARDIF_BCAST_NORECIPIENT ;
goto out ;
}
/* >1 neighbors -> (re)brodcast */
if ( rcu_dereference ( hlist_next_rcu ( first ) ) )
goto out ;
hardif_neigh = hlist_entry ( first , struct batadv_hardif_neigh_node ,
list ) ;
/* 1 neighbor, is the originator -> no rebroadcast */
if ( orig_addr & & batadv_compare_eth ( hardif_neigh - > orig , orig_addr ) ) {
ret = BATADV_HARDIF_BCAST_DUPORIG ;
/* 1 neighbor, is the one we received from -> no rebroadcast */
} else if ( orig_neigh & &
batadv_compare_eth ( hardif_neigh - > orig , orig_neigh ) ) {
ret = BATADV_HARDIF_BCAST_DUPFWD ;
}
out :
rcu_read_unlock ( ) ;
return ret ;
}
2012-06-06 03:31:31 +07:00
static struct batadv_hard_iface *
2012-05-12 23:33:57 +07:00
batadv_hardif_get_active ( const struct net_device * soft_iface )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface * hard_iface ;
2010-12-13 18:19:28 +07:00
rcu_read_lock ( ) ;
2012-05-12 07:09:42 +07:00
list_for_each_entry_rcu ( hard_iface , & batadv_hardif_list , list ) {
2011-02-18 19:33:20 +07:00
if ( hard_iface - > soft_iface ! = soft_iface )
2010-12-13 18:19:28 +07:00
continue ;
2012-06-04 03:19:19 +07:00
if ( hard_iface - > if_status = = BATADV_IF_ACTIVE & &
2016-01-16 16:29:54 +07:00
kref_get_unless_zero ( & hard_iface - > refcount ) )
2010-12-13 18:19:28 +07:00
goto out ;
}
2011-02-18 19:33:20 +07:00
hard_iface = NULL ;
2010-12-13 18:19:28 +07:00
out :
rcu_read_unlock ( ) ;
2011-02-18 19:33:20 +07:00
return hard_iface ;
2010-12-13 18:19:28 +07:00
}
2012-06-06 03:31:31 +07:00
static void batadv_primary_if_update_addr ( struct batadv_priv * bat_priv ,
struct batadv_hard_iface * oldif )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface * primary_if ;
2011-04-20 20:40:58 +07:00
2012-05-12 18:48:54 +07:00
primary_if = batadv_primary_if_get_selected ( bat_priv ) ;
2011-04-20 20:40:58 +07:00
if ( ! primary_if )
goto out ;
2010-12-13 18:19:28 +07:00
2011-11-23 17:35:44 +07:00
batadv_dat_init_own_addr ( bat_priv , primary_if ) ;
2012-05-12 18:38:47 +07:00
batadv_bla_update_orig_address ( bat_priv , primary_if , oldif ) ;
2011-04-20 20:40:58 +07:00
out :
if ( primary_if )
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( primary_if ) ;
2010-12-13 18:19:28 +07:00
}
2012-06-06 03:31:31 +07:00
static void batadv_primary_if_select ( struct batadv_priv * bat_priv ,
struct batadv_hard_iface * new_hard_iface )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface * curr_hard_iface ;
2010-12-13 18:19:28 +07:00
2011-05-03 16:51:38 +07:00
ASSERT_RTNL ( ) ;
2010-12-13 18:19:28 +07:00
2016-04-11 18:06:40 +07:00
if ( new_hard_iface )
kref_get ( & new_hard_iface - > refcount ) ;
2010-12-13 18:19:28 +07:00
2011-05-15 05:50:21 +07:00
curr_hard_iface = rcu_dereference_protected ( bat_priv - > primary_if , 1 ) ;
2011-04-20 20:40:58 +07:00
rcu_assign_pointer ( bat_priv - > primary_if , new_hard_iface ) ;
2010-12-13 18:19:28 +07:00
2011-04-20 20:40:58 +07:00
if ( ! new_hard_iface )
2012-01-23 02:00:19 +07:00
goto out ;
2011-04-20 20:40:58 +07:00
2016-05-25 22:27:31 +07:00
bat_priv - > algo_ops - > iface . primary_set ( new_hard_iface ) ;
2012-05-12 23:33:57 +07:00
batadv_primary_if_update_addr ( bat_priv , curr_hard_iface ) ;
2012-01-23 02:00:19 +07:00
out :
if ( curr_hard_iface )
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( curr_hard_iface ) ;
2010-12-13 18:19:28 +07:00
}
2012-06-06 03:31:31 +07:00
static bool
batadv_hardif_is_iface_up ( const struct batadv_hard_iface * hard_iface )
2010-12-13 18:19:28 +07:00
{
2011-02-18 19:33:20 +07:00
if ( hard_iface - > net_dev - > flags & IFF_UP )
2010-12-13 18:19:28 +07:00
return true ;
return false ;
}
2012-05-12 23:33:57 +07:00
static void batadv_check_known_mac_addr ( const struct net_device * net_dev )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
const struct batadv_hard_iface * hard_iface ;
2010-12-13 18:19:28 +07:00
rcu_read_lock ( ) ;
2012-05-12 07:09:42 +07:00
list_for_each_entry_rcu ( hard_iface , & batadv_hardif_list , list ) {
2017-08-24 02:52:13 +07:00
if ( hard_iface - > if_status ! = BATADV_IF_ACTIVE & &
hard_iface - > if_status ! = BATADV_IF_TO_BE_ACTIVATED )
2010-12-13 18:19:28 +07:00
continue ;
2011-02-18 19:33:20 +07:00
if ( hard_iface - > net_dev = = net_dev )
2010-12-13 18:19:28 +07:00
continue ;
2012-05-12 18:48:58 +07:00
if ( ! batadv_compare_eth ( hard_iface - > net_dev - > dev_addr ,
net_dev - > dev_addr ) )
2010-12-13 18:19:28 +07:00
continue ;
2012-03-26 21:22:45 +07:00
pr_warn ( " The newly added mac address (%pM) already exists on: %s \n " ,
net_dev - > dev_addr , hard_iface - > net_dev - > name ) ;
pr_warn ( " It is strongly recommended to keep mac addresses unique to avoid problems! \n " ) ;
2010-12-13 18:19:28 +07:00
}
rcu_read_unlock ( ) ;
}
2015-08-08 00:28:42 +07:00
/**
* batadv_hardif_recalc_extra_skbroom ( ) - Recalculate skbuff extra head / tailroom
* @ soft_iface : netdev struct of the mesh interface
*/
static void batadv_hardif_recalc_extra_skbroom ( struct net_device * soft_iface )
{
const struct batadv_hard_iface * hard_iface ;
unsigned short lower_header_len = ETH_HLEN ;
unsigned short lower_headroom = 0 ;
unsigned short lower_tailroom = 0 ;
unsigned short needed_headroom ;
rcu_read_lock ( ) ;
list_for_each_entry_rcu ( hard_iface , & batadv_hardif_list , list ) {
if ( hard_iface - > if_status = = BATADV_IF_NOT_IN_USE )
continue ;
if ( hard_iface - > soft_iface ! = soft_iface )
continue ;
lower_header_len = max_t ( unsigned short , lower_header_len ,
hard_iface - > net_dev - > hard_header_len ) ;
lower_headroom = max_t ( unsigned short , lower_headroom ,
hard_iface - > net_dev - > needed_headroom ) ;
lower_tailroom = max_t ( unsigned short , lower_tailroom ,
hard_iface - > net_dev - > needed_tailroom ) ;
}
rcu_read_unlock ( ) ;
needed_headroom = lower_headroom + ( lower_header_len - ETH_HLEN ) ;
needed_headroom + = batadv_max_header_len ( ) ;
soft_iface - > needed_headroom = needed_headroom ;
soft_iface - > needed_tailroom = lower_tailroom ;
}
2017-12-03 01:51:53 +07:00
/**
* batadv_hardif_min_mtu ( ) - Calculate maximum MTU for soft interface
* @ soft_iface : netdev struct of the soft interface
*
* Return : MTU for the soft - interface ( limited by the minimal MTU of all active
* slave interfaces )
*/
2012-05-12 07:09:31 +07:00
int batadv_hardif_min_mtu ( struct net_device * soft_iface )
2010-12-13 18:19:28 +07:00
{
2013-05-27 14:33:25 +07:00
struct batadv_priv * bat_priv = netdev_priv ( soft_iface ) ;
2012-06-06 03:31:31 +07:00
const struct batadv_hard_iface * hard_iface ;
2014-01-21 17:22:05 +07:00
int min_mtu = INT_MAX ;
2010-12-13 18:19:28 +07:00
rcu_read_lock ( ) ;
2012-05-12 07:09:42 +07:00
list_for_each_entry_rcu ( hard_iface , & batadv_hardif_list , list ) {
2017-08-24 02:52:13 +07:00
if ( hard_iface - > if_status ! = BATADV_IF_ACTIVE & &
hard_iface - > if_status ! = BATADV_IF_TO_BE_ACTIVATED )
2010-12-13 18:19:28 +07:00
continue ;
2011-02-18 19:33:20 +07:00
if ( hard_iface - > soft_iface ! = soft_iface )
2010-12-13 18:19:28 +07:00
continue ;
2013-05-27 14:33:25 +07:00
min_mtu = min_t ( int , hard_iface - > net_dev - > mtu , min_mtu ) ;
2010-12-13 18:19:28 +07:00
}
rcu_read_unlock ( ) ;
2013-05-27 14:33:25 +07:00
if ( atomic_read ( & bat_priv - > fragmentation ) = = 0 )
goto out ;
/* with fragmentation enabled the maximum size of internally generated
* packets such as translation table exchanges or tvlv containers , etc
* has to be calculated
*/
min_mtu = min_t ( int , min_mtu , BATADV_FRAG_MAX_FRAG_SIZE ) ;
min_mtu - = sizeof ( struct batadv_frag_packet ) ;
min_mtu * = BATADV_FRAG_MAX_FRAGMENTS ;
2010-12-13 18:19:28 +07:00
out :
2014-01-21 17:22:05 +07:00
/* report to the other components the maximum amount of bytes that
* batman - adv can send over the wire ( without considering the payload
* overhead ) . For example , this value is used by TT to compute the
* maximum local table table size
*/
atomic_set ( & bat_priv - > packet_size_max , min_mtu ) ;
/* the real soft-interface MTU is computed by removing the payload
* overhead from the maximum amount of bytes that was just computed .
*
* However batman - adv does not support MTUs bigger than ETH_DATA_LEN
*/
return min_t ( int , min_mtu - batadv_max_header_len ( ) , ETH_DATA_LEN ) ;
2010-12-13 18:19:28 +07:00
}
2017-12-03 01:51:53 +07:00
/**
* batadv_update_min_mtu ( ) - Adjusts the MTU if a new interface with a smaller
* MTU appeared
* @ soft_iface : netdev struct of the soft interface
*/
2012-05-12 07:09:31 +07:00
void batadv_update_min_mtu ( struct net_device * soft_iface )
2010-12-13 18:19:28 +07:00
{
2013-05-27 14:33:25 +07:00
soft_iface - > mtu = batadv_hardif_min_mtu ( soft_iface ) ;
2010-12-13 18:19:28 +07:00
2013-05-27 14:33:25 +07:00
/* Check if the local translate table should be cleaned up to match a
* new ( and smaller ) MTU .
*/
batadv_tt_local_resize_to_mtu ( soft_iface ) ;
2010-12-13 18:19:28 +07:00
}
2012-06-06 03:31:31 +07:00
static void
batadv_hardif_activate_interface ( struct batadv_hard_iface * hard_iface )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_priv * bat_priv ;
struct batadv_hard_iface * primary_if = NULL ;
2010-12-13 18:19:28 +07:00
2012-06-04 03:19:19 +07:00
if ( hard_iface - > if_status ! = BATADV_IF_INACTIVE )
2011-04-20 20:40:58 +07:00
goto out ;
2010-12-13 18:19:28 +07:00
2011-02-18 19:33:20 +07:00
bat_priv = netdev_priv ( hard_iface - > soft_iface ) ;
2010-12-13 18:19:28 +07:00
2016-05-25 22:27:31 +07:00
bat_priv - > algo_ops - > iface . update_mac ( hard_iface ) ;
2012-06-04 03:19:19 +07:00
hard_iface - > if_status = BATADV_IF_TO_BE_ACTIVATED ;
2010-12-13 18:19:28 +07:00
2012-05-12 07:09:43 +07:00
/* the first active interface becomes our primary interface or
2011-07-09 22:52:13 +07:00
* the next active interface after the old primary interface was removed
2010-12-13 18:19:28 +07:00
*/
2012-05-12 18:48:54 +07:00
primary_if = batadv_primary_if_get_selected ( bat_priv ) ;
2011-04-20 20:40:58 +07:00
if ( ! primary_if )
2012-05-12 23:33:57 +07:00
batadv_primary_if_select ( bat_priv , hard_iface ) ;
2010-12-13 18:19:28 +07:00
2012-05-17 01:23:22 +07:00
batadv_info ( hard_iface - > soft_iface , " Interface activated: %s \n " ,
hard_iface - > net_dev - > name ) ;
2010-12-13 18:19:28 +07:00
2012-05-12 07:09:31 +07:00
batadv_update_min_mtu ( hard_iface - > soft_iface ) ;
2011-04-20 20:40:58 +07:00
2016-05-25 22:27:31 +07:00
if ( bat_priv - > algo_ops - > iface . activate )
bat_priv - > algo_ops - > iface . activate ( hard_iface ) ;
2016-04-14 08:37:05 +07:00
2011-04-20 20:40:58 +07:00
out :
if ( primary_if )
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( primary_if ) ;
2010-12-13 18:19:28 +07:00
}
2012-06-06 03:31:31 +07:00
static void
batadv_hardif_deactivate_interface ( struct batadv_hard_iface * hard_iface )
2010-12-13 18:19:28 +07:00
{
2017-08-24 02:52:13 +07:00
if ( hard_iface - > if_status ! = BATADV_IF_ACTIVE & &
hard_iface - > if_status ! = BATADV_IF_TO_BE_ACTIVATED )
2010-12-13 18:19:28 +07:00
return ;
2012-06-04 03:19:19 +07:00
hard_iface - > if_status = BATADV_IF_INACTIVE ;
2010-12-13 18:19:28 +07:00
2012-05-17 01:23:22 +07:00
batadv_info ( hard_iface - > soft_iface , " Interface deactivated: %s \n " ,
hard_iface - > net_dev - > name ) ;
2010-12-13 18:19:28 +07:00
2012-05-12 07:09:31 +07:00
batadv_update_min_mtu ( hard_iface - > soft_iface ) ;
2010-12-13 18:19:28 +07:00
}
2013-02-16 20:42:39 +07:00
/**
2017-12-03 01:51:47 +07:00
* batadv_master_del_slave ( ) - remove hard_iface from the current master iface
2013-02-16 20:42:39 +07:00
* @ slave : the interface enslaved in another master
* @ master : the master from which slave has to be removed
*
* Invoke ndo_del_slave on master passing slave as argument . In this way slave
* is free ' d and master can correctly change its internal state .
2015-09-16 00:00:48 +07:00
*
* Return : 0 on success , a negative value representing the error otherwise
2013-02-16 20:42:39 +07:00
*/
static int batadv_master_del_slave ( struct batadv_hard_iface * slave ,
struct net_device * master )
{
int ret ;
if ( ! master )
return 0 ;
ret = - EBUSY ;
if ( master - > netdev_ops - > ndo_del_slave )
ret = master - > netdev_ops - > ndo_del_slave ( master , slave - > net_dev ) ;
return ret ;
}
2017-12-03 01:51:53 +07:00
/**
* batadv_hardif_enable_interface ( ) - Enslave hard interface to soft interface
* @ hard_iface : hard interface to add to soft interface
* @ net : the applicable net namespace
* @ iface_name : name of the soft interface
*
* Return : 0 on success or negative error number in case of failure
*/
2012-06-06 03:31:31 +07:00
int batadv_hardif_enable_interface ( struct batadv_hard_iface * hard_iface ,
2016-04-21 17:57:27 +07:00
struct net * net , const char * iface_name )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_priv * bat_priv ;
2013-02-16 20:42:39 +07:00
struct net_device * soft_iface , * master ;
2013-05-19 17:55:16 +07:00
__be16 ethertype = htons ( ETH_P_BATMAN ) ;
2013-05-08 12:31:59 +07:00
int max_header_len = batadv_max_header_len ( ) ;
2011-03-05 04:36:41 +07:00
int ret ;
2010-12-13 18:19:28 +07:00
2012-06-04 03:19:19 +07:00
if ( hard_iface - > if_status ! = BATADV_IF_NOT_IN_USE )
2010-12-13 18:19:28 +07:00
goto out ;
2016-04-11 18:06:40 +07:00
kref_get ( & hard_iface - > refcount ) ;
2011-02-10 21:33:51 +07:00
2016-04-21 17:57:27 +07:00
soft_iface = dev_get_by_name ( net , iface_name ) ;
2010-12-13 18:19:28 +07:00
2011-03-05 04:36:41 +07:00
if ( ! soft_iface ) {
2016-04-21 17:57:27 +07:00
soft_iface = batadv_softif_create ( net , iface_name ) ;
2010-12-13 18:19:28 +07:00
2011-03-05 04:36:41 +07:00
if ( ! soft_iface ) {
ret = - ENOMEM ;
2010-12-13 18:19:28 +07:00
goto err ;
2011-03-05 04:36:41 +07:00
}
2010-12-13 18:19:28 +07:00
/* dev_get_by_name() increases the reference counter for us */
2011-03-05 04:36:41 +07:00
dev_hold ( soft_iface ) ;
}
2012-05-12 07:09:38 +07:00
if ( ! batadv_softif_is_valid ( soft_iface ) ) {
2012-03-07 15:07:45 +07:00
pr_err ( " Can't create batman mesh interface %s: already exists as regular interface \n " ,
2011-03-05 04:36:41 +07:00
soft_iface - > name ) ;
ret = - EINVAL ;
2012-02-07 16:20:48 +07:00
goto err_dev ;
2010-12-13 18:19:28 +07:00
}
2013-02-16 20:42:39 +07:00
/* check if the interface is enslaved in another virtual one and
* in that case unlink it first
*/
master = netdev_master_upper_dev_get ( hard_iface - > net_dev ) ;
ret = batadv_master_del_slave ( hard_iface , master ) ;
if ( ret )
goto err_dev ;
2011-03-05 04:36:41 +07:00
hard_iface - > soft_iface = soft_iface ;
2011-02-18 19:33:20 +07:00
bat_priv = netdev_priv ( hard_iface - > soft_iface ) ;
2011-07-30 17:33:33 +07:00
2015-12-03 18:12:10 +07:00
ret = netdev_master_upper_dev_link ( hard_iface - > net_dev ,
2017-10-05 07:48:47 +07:00
soft_iface , NULL , NULL , NULL ) ;
2013-02-11 16:10:27 +07:00
if ( ret )
goto err_dev ;
2016-05-25 22:27:31 +07:00
ret = bat_priv - > algo_ops - > iface . enable ( hard_iface ) ;
2012-05-05 18:27:28 +07:00
if ( ret < 0 )
2013-02-11 16:10:27 +07:00
goto err_upper ;
2010-12-13 18:19:28 +07:00
2012-06-04 03:19:19 +07:00
hard_iface - > if_status = BATADV_IF_INACTIVE ;
2010-12-13 18:19:28 +07:00
2016-03-05 22:09:18 +07:00
kref_get ( & hard_iface - > refcount ) ;
2012-06-04 03:19:13 +07:00
hard_iface - > batman_adv_ptype . type = ethertype ;
2012-05-12 07:09:42 +07:00
hard_iface - > batman_adv_ptype . func = batadv_batman_skb_recv ;
2011-02-18 19:33:20 +07:00
hard_iface - > batman_adv_ptype . dev = hard_iface - > net_dev ;
dev_add_pack ( & hard_iface - > batman_adv_ptype ) ;
2010-12-13 18:19:28 +07:00
2012-05-17 01:23:22 +07:00
batadv_info ( hard_iface - > soft_iface , " Adding interface: %s \n " ,
hard_iface - > net_dev - > name ) ;
2010-12-13 18:19:28 +07:00
2012-06-20 01:26:30 +07:00
if ( atomic_read ( & bat_priv - > fragmentation ) & &
2013-05-08 12:31:59 +07:00
hard_iface - > net_dev - > mtu < ETH_DATA_LEN + max_header_len )
2012-05-17 01:23:22 +07:00
batadv_info ( hard_iface - > soft_iface ,
2013-05-08 12:31:59 +07:00
" 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 " ,
2012-05-17 01:23:22 +07:00
hard_iface - > net_dev - > name , hard_iface - > net_dev - > mtu ,
2013-05-08 12:31:59 +07:00
ETH_DATA_LEN + max_header_len ) ;
2010-12-13 18:19:28 +07:00
2012-06-20 01:26:30 +07:00
if ( ! atomic_read ( & bat_priv - > fragmentation ) & &
2013-05-08 12:31:59 +07:00
hard_iface - > net_dev - > mtu < ETH_DATA_LEN + max_header_len )
2012-05-17 01:23:22 +07:00
batadv_info ( hard_iface - > soft_iface ,
2013-05-08 12:31:59 +07:00
" 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 " ,
2012-05-17 01:23:22 +07:00
hard_iface - > net_dev - > name , hard_iface - > net_dev - > mtu ,
2013-05-08 12:31:59 +07:00
ETH_DATA_LEN + max_header_len ) ;
2010-12-13 18:19:28 +07:00
2012-05-12 23:33:57 +07:00
if ( batadv_hardif_is_iface_up ( hard_iface ) )
batadv_hardif_activate_interface ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
else
2012-05-17 01:23:22 +07:00
batadv_err ( hard_iface - > soft_iface ,
" Not using interface %s (retrying later): interface not active \n " ,
hard_iface - > net_dev - > name ) ;
2010-12-13 18:19:28 +07:00
2015-08-08 00:28:42 +07:00
batadv_hardif_recalc_extra_skbroom ( soft_iface ) ;
2019-06-02 15:57:31 +07:00
if ( bat_priv - > algo_ops - > iface . enabled )
bat_priv - > algo_ops - > iface . enabled ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
out :
return 0 ;
2013-02-11 16:10:27 +07:00
err_upper :
netdev_upper_dev_unlink ( hard_iface - > net_dev , soft_iface ) ;
2012-02-07 16:20:48 +07:00
err_dev :
2013-02-11 16:10:27 +07:00
hard_iface - > soft_iface = NULL ;
2012-02-07 16:20:48 +07:00
dev_put ( soft_iface ) ;
2010-12-13 18:19:28 +07:00
err :
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( hard_iface ) ;
2011-03-05 04:36:41 +07:00
return ret ;
2010-12-13 18:19:28 +07:00
}
2018-08-16 21:54:45 +07:00
/**
* batadv_hardif_cnt ( ) - get number of interfaces enslaved to soft interface
* @ soft_iface : soft interface to check
*
* This function is only using RCU for locking - the result can therefore be
* off when another functions is modifying the list at the same time . The
* caller can use the rtnl_lock to make sure that the count is accurate .
*
* Return : number of connected / enslaved hard interfaces
*/
static size_t batadv_hardif_cnt ( const struct net_device * soft_iface )
{
struct batadv_hard_iface * hard_iface ;
size_t count = 0 ;
rcu_read_lock ( ) ;
list_for_each_entry_rcu ( hard_iface , & batadv_hardif_list , list ) {
if ( hard_iface - > soft_iface ! = soft_iface )
continue ;
count + + ;
}
rcu_read_unlock ( ) ;
return count ;
}
2017-12-03 01:51:53 +07:00
/**
* batadv_hardif_disable_interface ( ) - Remove hard interface from soft interface
* @ hard_iface : hard interface to be removed
* @ autodel : whether to delete soft interface when it doesn ' t contain any other
* slave interfaces
*/
2013-02-11 16:10:24 +07:00
void batadv_hardif_disable_interface ( struct batadv_hard_iface * hard_iface ,
enum batadv_hard_if_cleanup autodel )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_priv * bat_priv = netdev_priv ( hard_iface - > soft_iface ) ;
struct batadv_hard_iface * primary_if = NULL ;
2010-12-13 18:19:28 +07:00
2016-03-19 19:55:21 +07:00
batadv_hardif_deactivate_interface ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
2012-06-04 03:19:19 +07:00
if ( hard_iface - > if_status ! = BATADV_IF_INACTIVE )
2011-04-20 20:40:58 +07:00
goto out ;
2010-12-13 18:19:28 +07:00
2012-05-17 01:23:22 +07:00
batadv_info ( hard_iface - > soft_iface , " Removing interface: %s \n " ,
hard_iface - > net_dev - > name ) ;
2011-02-18 19:33:20 +07:00
dev_remove_pack ( & hard_iface - > batman_adv_ptype ) ;
2016-03-05 22:09:18 +07:00
batadv_hardif_put ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
2012-05-12 18:48:54 +07:00
primary_if = batadv_primary_if_get_selected ( bat_priv ) ;
2011-04-20 20:40:58 +07:00
if ( hard_iface = = primary_if ) {
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface * new_if ;
2010-12-13 18:19:28 +07:00
2012-05-12 23:33:57 +07:00
new_if = batadv_hardif_get_active ( hard_iface - > soft_iface ) ;
batadv_primary_if_select ( bat_priv , new_if ) ;
2010-12-13 18:19:28 +07:00
if ( new_if )
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( new_if ) ;
2010-12-13 18:19:28 +07:00
}
2016-05-25 22:27:31 +07:00
bat_priv - > algo_ops - > iface . disable ( hard_iface ) ;
2012-06-04 03:19:19 +07:00
hard_iface - > if_status = BATADV_IF_NOT_IN_USE ;
2010-12-13 18:19:28 +07:00
2011-02-18 19:33:20 +07:00
/* delete all references to this hard_iface */
2012-05-12 07:09:34 +07:00
batadv_purge_orig_ref ( bat_priv ) ;
2012-05-12 07:09:37 +07:00
batadv_purge_outstanding_packets ( bat_priv , hard_iface ) ;
2011-02-18 19:33:20 +07:00
dev_put ( hard_iface - > soft_iface ) ;
2010-12-13 18:19:28 +07:00
2015-08-05 03:26:19 +07:00
netdev_upper_dev_unlink ( hard_iface - > net_dev , hard_iface - > soft_iface ) ;
2015-08-08 00:28:42 +07:00
batadv_hardif_recalc_extra_skbroom ( hard_iface - > soft_iface ) ;
2015-08-05 03:26:19 +07:00
2010-12-13 18:19:28 +07:00
/* nobody uses this interface anymore */
2018-08-16 21:54:45 +07:00
if ( batadv_hardif_cnt ( hard_iface - > soft_iface ) < = 1 ) {
2013-08-19 23:39:59 +07:00
batadv_gw_check_client_stop ( bat_priv ) ;
if ( autodel = = BATADV_IF_CLEANUP_AUTO )
batadv_softif_destroy_sysfs ( hard_iface - > soft_iface ) ;
}
2010-12-13 18:19:28 +07:00
2016-11-03 00:14:43 +07:00
hard_iface - > soft_iface = NULL ;
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( hard_iface ) ;
2011-04-20 20:40:58 +07:00
out :
if ( primary_if )
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( primary_if ) ;
2010-12-13 18:19:28 +07:00
}
2012-06-06 03:31:31 +07:00
static struct batadv_hard_iface *
2012-05-12 23:33:57 +07:00
batadv_hardif_add_interface ( struct net_device * net_dev )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface * hard_iface ;
2010-12-13 18:19:28 +07:00
int ret ;
2011-05-03 16:51:38 +07:00
ASSERT_RTNL ( ) ;
2016-02-23 03:02:39 +07:00
if ( ! batadv_is_valid_iface ( net_dev ) )
2010-12-13 18:19:28 +07:00
goto out ;
dev_hold ( net_dev ) ;
2013-04-02 17:16:53 +07:00
hard_iface = kzalloc ( sizeof ( * hard_iface ) , GFP_ATOMIC ) ;
2011-08-30 04:17:24 +07:00
if ( ! hard_iface )
2010-12-13 18:19:28 +07:00
goto release_dev ;
2012-05-12 07:09:24 +07:00
ret = batadv_sysfs_add_hardif ( & hard_iface - > hardif_obj , net_dev ) ;
2010-12-13 18:19:28 +07:00
if ( ret )
goto free_if ;
2011-02-18 19:33:20 +07:00
hard_iface - > net_dev = net_dev ;
hard_iface - > soft_iface = NULL ;
2012-06-04 03:19:19 +07:00
hard_iface - > if_status = BATADV_IF_NOT_IN_USE ;
2013-11-21 20:16:12 +07:00
2019-06-14 14:11:23 +07:00
batadv_debugfs_add_hardif ( hard_iface ) ;
2013-11-21 20:16:12 +07:00
2011-02-18 19:33:20 +07:00
INIT_LIST_HEAD ( & hard_iface - > list ) ;
2015-08-04 20:09:55 +07:00
INIT_HLIST_HEAD ( & hard_iface - > neigh_list ) ;
2013-01-11 16:19:51 +07:00
2019-10-03 22:02:01 +07:00
mutex_init ( & hard_iface - > bat_iv . ogm_buff_mutex ) ;
2015-08-04 20:09:55 +07:00
spin_lock_init ( & hard_iface - > neigh_list_lock ) ;
2016-07-15 22:39:28 +07:00
kref_init ( & hard_iface - > refcount ) ;
2015-08-04 20:09:55 +07:00
2013-03-10 05:14:23 +07:00
hard_iface - > num_bcasts = BATADV_NUM_BCASTS_DEFAULT ;
2016-09-30 20:21:03 +07:00
hard_iface - > wifi_flags = batadv_wifi_flags_evaluate ( net_dev ) ;
if ( batadv_is_wifi_hardif ( hard_iface ) )
2013-03-10 05:14:23 +07:00
hard_iface - > num_bcasts = BATADV_NUM_BCASTS_WIRELESS ;
2016-05-10 21:31:59 +07:00
batadv_v_hardif_init ( hard_iface ) ;
2012-05-12 23:33:57 +07:00
batadv_check_known_mac_addr ( hard_iface - > net_dev ) ;
2016-07-15 22:39:28 +07:00
kref_get ( & hard_iface - > refcount ) ;
2012-05-12 07:09:42 +07:00
list_add_tail_rcu ( & hard_iface - > list , & batadv_hardif_list ) ;
2018-10-31 04:01:24 +07:00
batadv_hardif_generation + + ;
2010-12-13 18:19:28 +07:00
2011-02-18 19:33:20 +07:00
return hard_iface ;
2010-12-13 18:19:28 +07:00
free_if :
2011-02-18 19:33:20 +07:00
kfree ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
release_dev :
dev_put ( net_dev ) ;
out :
return NULL ;
}
2012-06-06 03:31:31 +07:00
static void batadv_hardif_remove_interface ( struct batadv_hard_iface * hard_iface )
2010-12-13 18:19:28 +07:00
{
2011-05-03 16:51:38 +07:00
ASSERT_RTNL ( ) ;
2010-12-13 18:19:28 +07:00
/* first deactivate interface */
2012-06-04 03:19:19 +07:00
if ( hard_iface - > if_status ! = BATADV_IF_NOT_IN_USE )
2013-02-11 16:10:24 +07:00
batadv_hardif_disable_interface ( hard_iface ,
2016-07-10 20:47:57 +07:00
BATADV_IF_CLEANUP_KEEP ) ;
2010-12-13 18:19:28 +07:00
2012-06-04 03:19:19 +07:00
if ( hard_iface - > if_status ! = BATADV_IF_NOT_IN_USE )
2010-12-13 18:19:28 +07:00
return ;
2012-06-04 03:19:19 +07:00
hard_iface - > if_status = BATADV_IF_TO_BE_REMOVED ;
2016-06-13 12:41:31 +07:00
batadv_debugfs_del_hardif ( hard_iface ) ;
batadv_sysfs_del_hardif ( & hard_iface - > hardif_obj ) ;
batadv_hardif_put ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
}
2017-12-03 01:51:53 +07:00
/**
* batadv_hardif_remove_interfaces ( ) - Remove all hard interfaces
*/
2012-05-12 07:09:31 +07:00
void batadv_hardif_remove_interfaces ( void )
2010-12-13 18:19:28 +07:00
{
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface * hard_iface , * hard_iface_tmp ;
2010-12-13 18:19:28 +07:00
2011-05-03 16:51:38 +07:00
rtnl_lock ( ) ;
2011-02-18 19:33:20 +07:00
list_for_each_entry_safe ( hard_iface , hard_iface_tmp ,
2012-05-12 07:09:42 +07:00
& batadv_hardif_list , list ) {
2011-02-18 19:33:20 +07:00
list_del_rcu ( & hard_iface - > list ) ;
2018-10-31 04:01:24 +07:00
batadv_hardif_generation + + ;
2012-05-12 23:33:57 +07:00
batadv_hardif_remove_interface ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
}
rtnl_unlock ( ) ;
}
2018-06-02 00:24:24 +07:00
/**
* batadv_hard_if_event_softif ( ) - Handle events for soft interfaces
* @ event : NETDEV_ * event to handle
* @ net_dev : net_device which generated an event
*
* Return : NOTIFY_ * result
*/
static int batadv_hard_if_event_softif ( unsigned long event ,
struct net_device * net_dev )
{
struct batadv_priv * bat_priv ;
switch ( event ) {
case NETDEV_REGISTER :
batadv_sysfs_add_meshif ( net_dev ) ;
bat_priv = netdev_priv ( net_dev ) ;
batadv_softif_create_vlan ( bat_priv , BATADV_NO_FLAGS ) ;
break ;
case NETDEV_CHANGENAME :
batadv_debugfs_rename_meshif ( net_dev ) ;
break ;
}
return NOTIFY_DONE ;
}
2012-05-12 23:33:57 +07:00
static int batadv_hard_if_event ( struct notifier_block * this ,
unsigned long event , void * ptr )
2010-12-13 18:19:28 +07:00
{
2013-05-28 08:30:21 +07:00
struct net_device * net_dev = netdev_notifier_info_to_dev ( ptr ) ;
2012-06-06 03:31:31 +07:00
struct batadv_hard_iface * hard_iface ;
struct batadv_hard_iface * primary_if = NULL ;
struct batadv_priv * bat_priv ;
2010-12-13 18:19:28 +07:00
2018-06-02 00:24:24 +07:00
if ( batadv_softif_is_valid ( net_dev ) )
return batadv_hard_if_event_softif ( event , net_dev ) ;
2013-02-11 16:10:22 +07:00
2012-06-06 03:31:31 +07:00
hard_iface = batadv_hardif_get_by_netdev ( net_dev ) ;
2015-12-04 03:12:33 +07:00
if ( ! hard_iface & & ( event = = NETDEV_REGISTER | |
event = = NETDEV_POST_TYPE_CHANGE ) )
2012-05-12 23:33:57 +07:00
hard_iface = batadv_hardif_add_interface ( net_dev ) ;
2010-12-13 18:19:28 +07:00
2011-02-18 19:33:20 +07:00
if ( ! hard_iface )
2010-12-13 18:19:28 +07:00
goto out ;
switch ( event ) {
case NETDEV_UP :
2012-05-12 23:33:57 +07:00
batadv_hardif_activate_interface ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
break ;
case NETDEV_GOING_DOWN :
case NETDEV_DOWN :
2012-05-12 23:33:57 +07:00
batadv_hardif_deactivate_interface ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
break ;
case NETDEV_UNREGISTER :
2015-12-04 03:12:33 +07:00
case NETDEV_PRE_TYPE_CHANGE :
2011-02-18 19:33:20 +07:00
list_del_rcu ( & hard_iface - > list ) ;
2018-10-31 04:01:24 +07:00
batadv_hardif_generation + + ;
2010-12-13 18:19:28 +07:00
2012-05-12 23:33:57 +07:00
batadv_hardif_remove_interface ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
break ;
case NETDEV_CHANGEMTU :
2011-02-18 19:33:20 +07:00
if ( hard_iface - > soft_iface )
2012-05-12 07:09:31 +07:00
batadv_update_min_mtu ( hard_iface - > soft_iface ) ;
2010-12-13 18:19:28 +07:00
break ;
case NETDEV_CHANGEADDR :
2012-06-04 03:19:19 +07:00
if ( hard_iface - > if_status = = BATADV_IF_NOT_IN_USE )
2010-12-13 18:19:28 +07:00
goto hardif_put ;
2012-05-12 23:33:57 +07:00
batadv_check_known_mac_addr ( hard_iface - > net_dev ) ;
2010-12-13 18:19:28 +07:00
2011-02-18 19:33:20 +07:00
bat_priv = netdev_priv ( hard_iface - > soft_iface ) ;
2016-05-25 22:27:31 +07:00
bat_priv - > algo_ops - > iface . update_mac ( hard_iface ) ;
2011-11-28 20:31:55 +07:00
2012-05-12 18:48:54 +07:00
primary_if = batadv_primary_if_get_selected ( bat_priv ) ;
2011-04-20 20:40:58 +07:00
if ( ! primary_if )
goto hardif_put ;
if ( hard_iface = = primary_if )
2012-05-12 23:33:57 +07:00
batadv_primary_if_update_addr ( bat_priv , NULL ) ;
2010-12-13 18:19:28 +07:00
break ;
2016-09-30 20:21:06 +07:00
case NETDEV_CHANGEUPPER :
hard_iface - > wifi_flags = batadv_wifi_flags_evaluate ( net_dev ) ;
if ( batadv_is_wifi_hardif ( hard_iface ) )
hard_iface - > num_bcasts = BATADV_NUM_BCASTS_WIRELESS ;
break ;
2018-06-02 00:24:23 +07:00
case NETDEV_CHANGENAME :
batadv_debugfs_rename_hardif ( hard_iface ) ;
break ;
2010-12-13 18:19:28 +07:00
default :
break ;
2011-06-03 18:51:19 +07:00
}
2010-12-13 18:19:28 +07:00
hardif_put :
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( hard_iface ) ;
2010-12-13 18:19:28 +07:00
out :
2011-04-20 20:40:58 +07:00
if ( primary_if )
2016-01-17 17:01:10 +07:00
batadv_hardif_put ( primary_if ) ;
2010-12-13 18:19:28 +07:00
return NOTIFY_DONE ;
}
2012-05-12 07:09:31 +07:00
struct notifier_block batadv_hard_if_notifier = {
2012-05-12 23:33:57 +07:00
. notifier_call = batadv_hard_if_event ,
2010-12-13 18:19:28 +07:00
} ;