Eric Lee / smarc-fsl-linux-kernel

Commit e2d0d35b5b0ce420505e88255fd5922ed035bb8d

Authored by Sven Eckelmann 2018-11-23 20:15:00 +0800

Committed by Simon Wunderlich 2019-02-09 21:28:14 +0800

batman-adv: Add gateway mesh genl configuration

The mesh/soft-interface can optimize the handling of DHCP packets. Instead
of flooding them through the whole mesh, it can be forwarded as unicast to
a specific gateway server. The originator which injects the packets in the
mesh has to select (based on sel_class thresholds) a responsible gateway
server. This is done by switching this originator to the gw_mode client.
The servers announce their forwarding bandwidth (download/upload) when the
gw_mode server was selected.

The BATADV_CMD_SET_MESH/BATADV_CMD_GET_MESH commands allow to set/get the
configuration of this feature using the attributes:

* u8 BATADV_ATTR_GW_MODE (0 == off, 1 == client, 2 == server)
* u32 BATADV_ATTR_GW_BANDWIDTH_DOWN (in 100 kbit/s steps)
* u32 BATADV_ATTR_GW_BANDWIDTH_UP (in 100 kbit/s steps)
* u32 BATADV_ATTR_GW_SEL_CLASS

Signed-off-by: Sven Eckelmann <sven@narfation.org>
Signed-off-by: Simon Wunderlich <sw@simonwunderlich.de>

Showing 7 changed files with 135 additions and 8 deletions Inline Diff

include/uapi/linux/batman_adv.h
net/batman-adv/gateway_client.c
net/batman-adv/gateway_common.c
net/batman-adv/gateway_common.h
net/batman-adv/netlink.c
net/batman-adv/soft-interface.c
net/batman-adv/sysfs.c

include/uapi/linux/batman_adv.h

Diff comments View file @ e2d0d35

 /* SPDX-License-Identifier: MIT */
 /* Copyright (C) 2016-2019  B.A.T.M.A.N. contributors:
  *
  * Matthias Schiffer
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
  */
 #ifndef _UAPI_LINUX_BATMAN_ADV_H_
 #define _UAPI_LINUX_BATMAN_ADV_H_
 #define BATADV_NL_NAME "batadv"
 #define BATADV_NL_MCAST_GROUP_CONFIG	"config"
 #define BATADV_NL_MCAST_GROUP_TPMETER	"tpmeter"
 /**
  * enum batadv_tt_client_flags - TT client specific flags
  *
  * Bits from 0 to 7 are called _remote flags_ because they are sent on the wire.
  * Bits from 8 to 15 are called _local flags_ because they are used for local
  * computations only.
  *
  * Bits from 4 to 7 - a subset of remote flags - are ensured to be in sync with
  * the other nodes in the network. To achieve this goal these flags are included
  * in the TT CRC computation.
  */
 enum batadv_tt_client_flags {
 	/**
 	 * @BATADV_TT_CLIENT_DEL: the client has to be deleted from the table
 	 */
 	BATADV_TT_CLIENT_DEL     = (1 << 0),
 	/**
 	 * @BATADV_TT_CLIENT_ROAM: the client roamed to/from another node and
 	 * the new update telling its new real location has not been
 	 * received/sent yet
 	 */
 	BATADV_TT_CLIENT_ROAM    = (1 << 1),
 	/**
 	 * @BATADV_TT_CLIENT_WIFI: this client is connected through a wifi
 	 * interface. This information is used by the "AP Isolation" feature
 	 */
 	BATADV_TT_CLIENT_WIFI    = (1 << 4),
 	/**
 	 * @BATADV_TT_CLIENT_ISOLA: this client is considered "isolated". This
 	 * information is used by the Extended Isolation feature
 	 */
 	BATADV_TT_CLIENT_ISOLA	 = (1 << 5),
 	/**
 	 * @BATADV_TT_CLIENT_NOPURGE: this client should never be removed from
 	 * the table
 	 */
 	BATADV_TT_CLIENT_NOPURGE = (1 << 8),
 	/**
 	 * @BATADV_TT_CLIENT_NEW: this client has been added to the local table
 	 * but has not been announced yet
 	 */
 	BATADV_TT_CLIENT_NEW     = (1 << 9),
 	/**
 	 * @BATADV_TT_CLIENT_PENDING: this client is marked for removal but it
 	 * is kept in the table for one more originator interval for consistency
 	 * purposes
 	 */
 	BATADV_TT_CLIENT_PENDING = (1 << 10),
 	/**
 	 * @BATADV_TT_CLIENT_TEMP: this global client has been detected to be
 	 * part of the network but no nnode has already announced it
 	 */
 	BATADV_TT_CLIENT_TEMP	 = (1 << 11),
 };
 /**
  * enum batadv_mcast_flags_priv - Private, own multicast flags
  *
  * These are internal, multicast related flags. Currently they describe certain
  * multicast related attributes of the segment this originator bridges into the
  * mesh.
  *
  * Those attributes are used to determine the public multicast flags this
  * originator is going to announce via TT.
  *
  * For netlink, if BATADV_MCAST_FLAGS_BRIDGED is unset then all querier
  * related flags are undefined.
  */
 enum batadv_mcast_flags_priv {
 	/**
 	 * @BATADV_MCAST_FLAGS_BRIDGED: There is a bridge on top of the mesh
 	 * interface.
 	 */
 	BATADV_MCAST_FLAGS_BRIDGED			= (1 << 0),
 	/**
 	 * @BATADV_MCAST_FLAGS_QUERIER_IPV4_EXISTS: Whether an IGMP querier
 	 * exists in the mesh
 	 */
 	BATADV_MCAST_FLAGS_QUERIER_IPV4_EXISTS		= (1 << 1),
 	/**
 	 * @BATADV_MCAST_FLAGS_QUERIER_IPV6_EXISTS: Whether an MLD querier
 	 * exists in the mesh
 	 */
 	BATADV_MCAST_FLAGS_QUERIER_IPV6_EXISTS		= (1 << 2),
 	/**
 	 * @BATADV_MCAST_FLAGS_QUERIER_IPV4_SHADOWING: If an IGMP querier
 	 * exists, whether it is potentially shadowing multicast listeners
 	 * (i.e. querier is behind our own bridge segment)
 	 */
 	BATADV_MCAST_FLAGS_QUERIER_IPV4_SHADOWING	= (1 << 3),
 	/**
 	 * @BATADV_MCAST_FLAGS_QUERIER_IPV6_SHADOWING: If an MLD querier
 	 * exists, whether it is potentially shadowing multicast listeners
 	 * (i.e. querier is behind our own bridge segment)
 	 */
 	BATADV_MCAST_FLAGS_QUERIER_IPV6_SHADOWING	= (1 << 4),
 };
 /**
+ * enum batadv_gw_modes - gateway mode of node
+ */
+enum batadv_gw_modes {
+	/** @BATADV_GW_MODE_OFF: gw mode disabled */
+	BATADV_GW_MODE_OFF,
+	/** @BATADV_GW_MODE_CLIENT: send DHCP requests to gw servers */
+	BATADV_GW_MODE_CLIENT,
+	/** @BATADV_GW_MODE_SERVER: announce itself as gatway server */
+	BATADV_GW_MODE_SERVER,
+};
+/**
  * enum batadv_nl_attrs - batman-adv netlink attributes
  */
 enum batadv_nl_attrs {
 	/**
 	 * @BATADV_ATTR_UNSPEC: unspecified attribute to catch errors
 	 */
 	BATADV_ATTR_UNSPEC,
 	/**
 	 * @BATADV_ATTR_VERSION: batman-adv version string
 	 */
 	BATADV_ATTR_VERSION,
 	/**
 	 * @BATADV_ATTR_ALGO_NAME: name of routing algorithm
 	 */
 	BATADV_ATTR_ALGO_NAME,
 	/**
 	 * @BATADV_ATTR_MESH_IFINDEX: index of the batman-adv interface
 	 */
 	BATADV_ATTR_MESH_IFINDEX,
 	/**
 	 * @BATADV_ATTR_MESH_IFNAME: name of the batman-adv interface
 	 */
 	BATADV_ATTR_MESH_IFNAME,
 	/**
 	 * @BATADV_ATTR_MESH_ADDRESS: mac address of the batman-adv interface
 	 */
 	BATADV_ATTR_MESH_ADDRESS,
 	/**
 	 * @BATADV_ATTR_HARD_IFINDEX: index of the non-batman-adv interface
 	 */
 	BATADV_ATTR_HARD_IFINDEX,
 	/**
 	 * @BATADV_ATTR_HARD_IFNAME: name of the non-batman-adv interface
 	 */
 	BATADV_ATTR_HARD_IFNAME,
 	/**
 	 * @BATADV_ATTR_HARD_ADDRESS: mac address of the non-batman-adv
 	 * interface
 	 */
 	BATADV_ATTR_HARD_ADDRESS,
 	/**
 	 * @BATADV_ATTR_ORIG_ADDRESS: originator mac address
 	 */
 	BATADV_ATTR_ORIG_ADDRESS,
 	/**
 	 * @BATADV_ATTR_TPMETER_RESULT: result of run (see
 	 * batadv_tp_meter_status)
 	 */
 	BATADV_ATTR_TPMETER_RESULT,
 	/**
 	 * @BATADV_ATTR_TPMETER_TEST_TIME: time (msec) the run took
 	 */
 	BATADV_ATTR_TPMETER_TEST_TIME,
 	/**
 	 * @BATADV_ATTR_TPMETER_BYTES: amount of acked bytes during run
 	 */
 	BATADV_ATTR_TPMETER_BYTES,
 	/**
 	 * @BATADV_ATTR_TPMETER_COOKIE: session cookie to match tp_meter session
 	 */
 	BATADV_ATTR_TPMETER_COOKIE,
 	/**
 	 * @BATADV_ATTR_PAD: attribute used for padding for 64-bit alignment
 	 */
 	BATADV_ATTR_PAD,
 	/**
 	 * @BATADV_ATTR_ACTIVE: Flag indicating if the hard interface is active
 	 */
 	BATADV_ATTR_ACTIVE,
 	/**
 	 * @BATADV_ATTR_TT_ADDRESS: Client MAC address
 	 */
 	BATADV_ATTR_TT_ADDRESS,
 	/**
 	 * @BATADV_ATTR_TT_TTVN: Translation table version
 	 */
 	BATADV_ATTR_TT_TTVN,
 	/**
 	 * @BATADV_ATTR_TT_LAST_TTVN: Previous translation table version
 	 */
 	BATADV_ATTR_TT_LAST_TTVN,
 	/**
 	 * @BATADV_ATTR_TT_CRC32: CRC32 over translation table
 	 */
 	BATADV_ATTR_TT_CRC32,
 	/**
 	 * @BATADV_ATTR_TT_VID: VLAN ID
 	 */
 	BATADV_ATTR_TT_VID,
 	/**
 	 * @BATADV_ATTR_TT_FLAGS: Translation table client flags
 	 */
 	BATADV_ATTR_TT_FLAGS,
 	/**
 	 * @BATADV_ATTR_FLAG_BEST: Flags indicating entry is the best
 	 */
 	BATADV_ATTR_FLAG_BEST,
 	/**
 	 * @BATADV_ATTR_LAST_SEEN_MSECS: Time in milliseconds since last seen
 	 */
 	BATADV_ATTR_LAST_SEEN_MSECS,
 	/**
 	 * @BATADV_ATTR_NEIGH_ADDRESS: Neighbour MAC address
 	 */
 	BATADV_ATTR_NEIGH_ADDRESS,
 	/**
 	 * @BATADV_ATTR_TQ: TQ to neighbour
 	 */
 	BATADV_ATTR_TQ,
 	/**
 	 * @BATADV_ATTR_THROUGHPUT: Estimated throughput to Neighbour
 	 */
 	BATADV_ATTR_THROUGHPUT,
 	/**
 	 * @BATADV_ATTR_BANDWIDTH_UP: Reported uplink bandwidth
 	 */
 	BATADV_ATTR_BANDWIDTH_UP,
 	/**
 	 * @BATADV_ATTR_BANDWIDTH_DOWN: Reported downlink bandwidth
 	 */
 	BATADV_ATTR_BANDWIDTH_DOWN,
 	/**
 	 * @BATADV_ATTR_ROUTER: Gateway router MAC address
 	 */
 	BATADV_ATTR_ROUTER,
 	/**
 	 * @BATADV_ATTR_BLA_OWN: Flag indicating own originator
 	 */
 	BATADV_ATTR_BLA_OWN,
 	/**
 	 * @BATADV_ATTR_BLA_ADDRESS: Bridge loop avoidance claim MAC address
 	 */
 	BATADV_ATTR_BLA_ADDRESS,
 	/**
 	 * @BATADV_ATTR_BLA_VID: BLA VLAN ID
 	 */
 	BATADV_ATTR_BLA_VID,
 	/**
 	 * @BATADV_ATTR_BLA_BACKBONE: BLA gateway originator MAC address
 	 */
 	BATADV_ATTR_BLA_BACKBONE,
 	/**
 	 * @BATADV_ATTR_BLA_CRC: BLA CRC
 	 */
 	BATADV_ATTR_BLA_CRC,
 	/**
 	 * @BATADV_ATTR_DAT_CACHE_IP4ADDRESS: Client IPv4 address
 	 */
 	BATADV_ATTR_DAT_CACHE_IP4ADDRESS,
 	/**
 	 * @BATADV_ATTR_DAT_CACHE_HWADDRESS: Client MAC address
 	 */
 	BATADV_ATTR_DAT_CACHE_HWADDRESS,
 	/**
 	 * @BATADV_ATTR_DAT_CACHE_VID: VLAN ID
 	 */
 	BATADV_ATTR_DAT_CACHE_VID,
 	/**
 	 * @BATADV_ATTR_MCAST_FLAGS: Per originator multicast flags
 	 */
 	BATADV_ATTR_MCAST_FLAGS,
 	/**
 	 * @BATADV_ATTR_MCAST_FLAGS_PRIV: Private, own multicast flags
 	 */
 	BATADV_ATTR_MCAST_FLAGS_PRIV,
 	/**
 	 * @BATADV_ATTR_VLANID: VLAN id on top of soft interface
 	 */
 	BATADV_ATTR_VLANID,
 	/**
 	 * @BATADV_ATTR_AGGREGATED_OGMS_ENABLED: whether the batman protocol
 	 *  messages of the mesh interface shall be aggregated or not.
 	 */
 	BATADV_ATTR_AGGREGATED_OGMS_ENABLED,
 	/**
 	 * @BATADV_ATTR_AP_ISOLATION_ENABLED: whether the data traffic going
 	 *  from a wireless client to another wireless client will be silently
 	 *  dropped.
 	 */
 	BATADV_ATTR_AP_ISOLATION_ENABLED,
 	/**
 	 * @BATADV_ATTR_ISOLATION_MARK: the isolation mark which is used to
 	 *  classify clients as "isolated" by the Extended Isolation feature.
 	 */
 	BATADV_ATTR_ISOLATION_MARK,
 	/**
 	 * @BATADV_ATTR_ISOLATION_MASK: the isolation (bit)mask which is used to
 	 *  classify clients as "isolated" by the Extended Isolation feature.
 	 */
 	BATADV_ATTR_ISOLATION_MASK,
 	/**
 	 * @BATADV_ATTR_BONDING_ENABLED: whether the data traffic going through
 	 *  the mesh will be sent using multiple interfaces at the same time.
 	 */
 	BATADV_ATTR_BONDING_ENABLED,
 	/**
 	 * @BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED: whether the bridge loop
 	 *  avoidance feature is enabled. This feature detects and avoids loops
 	 *  between the mesh and devices bridged with the soft interface
 	 */
 	BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED,
 	/**
 	 * @BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED: whether the distributed
 	 *  arp table feature is enabled. This feature uses a distributed hash
 	 *  table to answer ARP requests without flooding the request through
 	 *  the whole mesh.
 	 */
 	BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED,
 	/**
 	 * @BATADV_ATTR_FRAGMENTATION_ENABLED: whether the data traffic going
 	 *  through the mesh will be fragmented or silently discarded if the
 	 *  packet size exceeds the outgoing interface MTU.
 	 */
 	BATADV_ATTR_FRAGMENTATION_ENABLED,
+	/**
+	 * @BATADV_ATTR_GW_BANDWIDTH_DOWN: defines the download bandwidth which
+	 *  is propagated by this node if %BATADV_ATTR_GW_BANDWIDTH_MODE was set
+	 *  to 'server'.
+	 */
+	BATADV_ATTR_GW_BANDWIDTH_DOWN,
+	/**
+	 * @BATADV_ATTR_GW_BANDWIDTH_UP: defines the upload bandwidth which
+	 *  is propagated by this node if %BATADV_ATTR_GW_BANDWIDTH_MODE was set
+	 *  to 'server'.
+	 */
+	BATADV_ATTR_GW_BANDWIDTH_UP,
+	/**
+	 * @BATADV_ATTR_GW_MODE: defines the state of the gateway features.
+	 * Possible values are specified in enum batadv_gw_modes
+	 */
+	BATADV_ATTR_GW_MODE,
+	/**
+	 * @BATADV_ATTR_GW_SEL_CLASS: defines the selection criteria this node
+	 *  will use to choose a gateway if gw_mode was set to 'client'.
+	 */
+	BATADV_ATTR_GW_SEL_CLASS,
 	/* add attributes above here, update the policy in netlink.c */
 	/**
 	 * @__BATADV_ATTR_AFTER_LAST: internal use
 	 */
 	__BATADV_ATTR_AFTER_LAST,
 	/**
 	 * @NUM_BATADV_ATTR: total number of batadv_nl_attrs available
 	 */
 	NUM_BATADV_ATTR = __BATADV_ATTR_AFTER_LAST,
 	/**
 	 * @BATADV_ATTR_MAX: highest attribute number currently defined
 	 */
 	BATADV_ATTR_MAX = __BATADV_ATTR_AFTER_LAST - 1
 };
 /**
  * enum batadv_nl_commands - supported batman-adv netlink commands
  */
 enum batadv_nl_commands {
 	/**
 	 * @BATADV_CMD_UNSPEC: unspecified command to catch errors
 	 */
 	BATADV_CMD_UNSPEC,
 	/**
 	 * @BATADV_CMD_GET_MESH: Get attributes from softif/mesh
 	 */
 	BATADV_CMD_GET_MESH,
 	/**
 	 * @BATADV_CMD_GET_MESH_INFO: Alias for @BATADV_CMD_GET_MESH
 	 */
 	BATADV_CMD_GET_MESH_INFO = BATADV_CMD_GET_MESH,
 	/**
 	 * @BATADV_CMD_TP_METER: Start a tp meter session
 	 */
 	BATADV_CMD_TP_METER,
 	/**
 	 * @BATADV_CMD_TP_METER_CANCEL: Cancel a tp meter session
 	 */
 	BATADV_CMD_TP_METER_CANCEL,
 	/**
 	 * @BATADV_CMD_GET_ROUTING_ALGOS: Query the list of routing algorithms.
 	 */
 	BATADV_CMD_GET_ROUTING_ALGOS,
 	/**
 	 * @BATADV_CMD_GET_HARDIF: Get attributes from a hardif of the
 	 *  current softif
 	 */
 	BATADV_CMD_GET_HARDIF,
 	/**
 	 * @BATADV_CMD_GET_HARDIFS: Alias for @BATADV_CMD_GET_HARDIF
 	 */
 	BATADV_CMD_GET_HARDIFS = BATADV_CMD_GET_HARDIF,
 	/**
 	 * @BATADV_CMD_GET_TRANSTABLE_LOCAL: Query list of local translations
 	 */
 	BATADV_CMD_GET_TRANSTABLE_LOCAL,
 	/**
 	 * @BATADV_CMD_GET_TRANSTABLE_GLOBAL: Query list of global translations
 	 */
 	BATADV_CMD_GET_TRANSTABLE_GLOBAL,
 	/**
 	 * @BATADV_CMD_GET_ORIGINATORS: Query list of originators
 	 */
 	BATADV_CMD_GET_ORIGINATORS,
 	/**
 	 * @BATADV_CMD_GET_NEIGHBORS: Query list of neighbours
 	 */
 	BATADV_CMD_GET_NEIGHBORS,
 	/**
 	 * @BATADV_CMD_GET_GATEWAYS: Query list of gateways
 	 */
 	BATADV_CMD_GET_GATEWAYS,
 	/**
 	 * @BATADV_CMD_GET_BLA_CLAIM: Query list of bridge loop avoidance claims
 	 */
 	BATADV_CMD_GET_BLA_CLAIM,
 	/**
 	 * @BATADV_CMD_GET_BLA_BACKBONE: Query list of bridge loop avoidance
 	 * backbones
 	 */
 	BATADV_CMD_GET_BLA_BACKBONE,
 	/**
 	 * @BATADV_CMD_GET_DAT_CACHE: Query list of DAT cache entries
 	 */
 	BATADV_CMD_GET_DAT_CACHE,
 	/**
 	 * @BATADV_CMD_GET_MCAST_FLAGS: Query list of multicast flags
 	 */
 	BATADV_CMD_GET_MCAST_FLAGS,
 	/**
 	 * @BATADV_CMD_SET_MESH: Set attributes for softif/mesh
 	 */
 	BATADV_CMD_SET_MESH,
 	/**
 	 * @BATADV_CMD_SET_HARDIF: Set attributes for hardif of the
 	 *  current softif
 	 */
 	BATADV_CMD_SET_HARDIF,
 	/**
 	 * @BATADV_CMD_GET_VLAN: Get attributes from a VLAN of the
 	 *  current softif
 	 */
 	BATADV_CMD_GET_VLAN,
 	/**
 	 * @BATADV_CMD_SET_VLAN: Set attributes for VLAN of the
 	 *  current softif
 	 */
 	BATADV_CMD_SET_VLAN,
 	/* add new commands above here */
 	/**
 	 * @__BATADV_CMD_AFTER_LAST: internal use
 	 */
 	__BATADV_CMD_AFTER_LAST,
 	/**
 	 * @BATADV_CMD_MAX: highest used command number
 	 */
 	BATADV_CMD_MAX = __BATADV_CMD_AFTER_LAST - 1
 };
 /**
  * enum batadv_tp_meter_reason - reason of a tp meter test run stop
  */
 enum batadv_tp_meter_reason {
 	/**
 	 * @BATADV_TP_REASON_COMPLETE: sender finished tp run
 	 */
 	BATADV_TP_REASON_COMPLETE		= 3,
 	/**
 	 * @BATADV_TP_REASON_CANCEL: sender was stopped during run
 	 */
 	BATADV_TP_REASON_CANCEL			= 4,
 	/* error status >= 128 */
 	/**
 	 * @BATADV_TP_REASON_DST_UNREACHABLE: receiver could not be reached or
 	 * didn't answer
 	 */
 	BATADV_TP_REASON_DST_UNREACHABLE	= 128,
 	/**
 	 * @BATADV_TP_REASON_RESEND_LIMIT: (unused) sender retry reached limit
 	 */
 	BATADV_TP_REASON_RESEND_LIMIT		= 129,
 	/**
 	 * @BATADV_TP_REASON_ALREADY_ONGOING: test to or from the same node
 	 * already ongoing
 	 */
 	BATADV_TP_REASON_ALREADY_ONGOING	= 130,
 	/**
 	 * @BATADV_TP_REASON_MEMORY_ERROR: test was stopped due to low memory
 	 */
 	BATADV_TP_REASON_MEMORY_ERROR		= 131,
 	/**
 	 * @BATADV_TP_REASON_CANT_SEND: failed to send via outgoing interface
 	 */
 	BATADV_TP_REASON_CANT_SEND		= 132,
 	/**
 	 * @BATADV_TP_REASON_TOO_MANY: too many ongoing sessions
 	 */
 	BATADV_TP_REASON_TOO_MANY		= 133,
 };
 #endif /* _UAPI_LINUX_BATMAN_ADV_H_ */

net/batman-adv/gateway_client.c

Diff comments View file @ e2d0d35

 // SPDX-License-Identifier: GPL-2.0
 /* Copyright (C) 2009-2019  B.A.T.M.A.N. contributors:
  *
  * Marek Lindner
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "gateway_client.h"
 #include "main.h"
 #include <linux/atomic.h>
 #include <linux/byteorder/generic.h>
 #include <linux/errno.h>
 #include <linux/etherdevice.h>
 #include <linux/gfp.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/in.h>
 #include <linux/ip.h>
 #include <linux/ipv6.h>
 #include <linux/kernel.h>
 #include <linux/kref.h>
 #include <linux/list.h>
 #include <linux/lockdep.h>
 #include <linux/netdevice.h>
 #include <linux/netlink.h>
 #include <linux/rculist.h>
 #include <linux/rcupdate.h>
 #include <linux/seq_file.h>
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/stddef.h>
 #include <linux/udp.h>
 #include <net/sock.h>
 #include <uapi/linux/batadv_packet.h>
 #include <uapi/linux/batman_adv.h>
-#include "gateway_common.h"
 #include "hard-interface.h"
 #include "log.h"
 #include "netlink.h"
 #include "originator.h"
 #include "routing.h"
 #include "soft-interface.h"
 #include "sysfs.h"
 #include "translation-table.h"
 /* These are the offsets of the "hw type" and "hw address length" in the dhcp
  * packet starting at the beginning of the dhcp header
  */
 #define BATADV_DHCP_HTYPE_OFFSET	1
 #define BATADV_DHCP_HLEN_OFFSET		2
 /* Value of htype representing Ethernet */
 #define BATADV_DHCP_HTYPE_ETHERNET	0x01
 /* This is the offset of the "chaddr" field in the dhcp packet starting at the
  * beginning of the dhcp header
  */
 #define BATADV_DHCP_CHADDR_OFFSET	28
 /**
  * batadv_gw_node_release() - release gw_node from lists and queue for free
  *  after rcu grace period
  * @ref: kref pointer of the gw_node
  */
 static void batadv_gw_node_release(struct kref *ref)
 {
 	struct batadv_gw_node *gw_node;
 	gw_node = container_of(ref, struct batadv_gw_node, refcount);
 	batadv_orig_node_put(gw_node->orig_node);
 	kfree_rcu(gw_node, rcu);
 }
 /**
  * batadv_gw_node_put() - decrement the gw_node refcounter and possibly release
  *  it
  * @gw_node: gateway node to free
  */
 void batadv_gw_node_put(struct batadv_gw_node *gw_node)
 {
 	kref_put(&gw_node->refcount, batadv_gw_node_release);
 }
 /**
  * batadv_gw_get_selected_gw_node() - Get currently selected gateway
  * @bat_priv: the bat priv with all the soft interface information
  *
  * Return: selected gateway (with increased refcnt), NULL on errors
  */
 struct batadv_gw_node *
 batadv_gw_get_selected_gw_node(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *gw_node;
 	rcu_read_lock();
 	gw_node = rcu_dereference(bat_priv->gw.curr_gw);
 	if (!gw_node)
 		goto out;
 	if (!kref_get_unless_zero(&gw_node->refcount))
 		gw_node = NULL;
 out:
 	rcu_read_unlock();
 	return gw_node;
 }
 /**
  * batadv_gw_get_selected_orig() - Get originator of currently selected gateway
  * @bat_priv: the bat priv with all the soft interface information
  *
  * Return: orig_node of selected gateway (with increased refcnt), NULL on errors
  */
 struct batadv_orig_node *
 batadv_gw_get_selected_orig(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *gw_node;
 	struct batadv_orig_node *orig_node = NULL;
 	gw_node = batadv_gw_get_selected_gw_node(bat_priv);
 	if (!gw_node)
 		goto out;
 	rcu_read_lock();
 	orig_node = gw_node->orig_node;
 	if (!orig_node)
 		goto unlock;
 	if (!kref_get_unless_zero(&orig_node->refcount))
 		orig_node = NULL;
 unlock:
 	rcu_read_unlock();
 out:
 	if (gw_node)
 		batadv_gw_node_put(gw_node);
 	return orig_node;
 }
 static void batadv_gw_select(struct batadv_priv *bat_priv,
 			     struct batadv_gw_node *new_gw_node)
 {
 	struct batadv_gw_node *curr_gw_node;
 	spin_lock_bh(&bat_priv->gw.list_lock);
 	if (new_gw_node)
 		kref_get(&new_gw_node->refcount);
 	curr_gw_node = rcu_dereference_protected(bat_priv->gw.curr_gw, 1);
 	rcu_assign_pointer(bat_priv->gw.curr_gw, new_gw_node);
 	if (curr_gw_node)
 		batadv_gw_node_put(curr_gw_node);
 	spin_unlock_bh(&bat_priv->gw.list_lock);
 }
 /**
  * batadv_gw_reselect() - force a gateway reselection
  * @bat_priv: the bat priv with all the soft interface information
  *
  * Set a flag to remind the GW component to perform a new gateway reselection.
  * However this function does not ensure that the current gateway is going to be
  * deselected. The reselection mechanism may elect the same gateway once again.
  *
  * This means that invoking batadv_gw_reselect() does not guarantee a gateway
  * change and therefore a uevent is not necessarily expected.
  */
 void batadv_gw_reselect(struct batadv_priv *bat_priv)
 {
 	atomic_set(&bat_priv->gw.reselect, 1);
 }
 /**
  * batadv_gw_check_client_stop() - check if client mode has been switched off
  * @bat_priv: the bat priv with all the soft interface information
  *
  * This function assumes the caller has checked that the gw state *is actually
  * changing*. This function is not supposed to be called when there is no state
  * change.
  */
 void batadv_gw_check_client_stop(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *curr_gw;
 	if (atomic_read(&bat_priv->gw.mode) != BATADV_GW_MODE_CLIENT)
 		return;
 	curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 	if (!curr_gw)
 		return;
 	/* deselect the current gateway so that next time that client mode is
 	 * enabled a proper GW_ADD event can be sent
 	 */
 	batadv_gw_select(bat_priv, NULL);
 	/* if batman-adv is switching the gw client mode off and a gateway was
 	 * already selected, send a DEL uevent
 	 */
 	batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL, NULL);
 	batadv_gw_node_put(curr_gw);
 }
 /**
  * batadv_gw_election() - Elect the best gateway
  * @bat_priv: the bat priv with all the soft interface information
  */
 void batadv_gw_election(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *curr_gw = NULL;
 	struct batadv_gw_node *next_gw = NULL;
 	struct batadv_neigh_node *router = NULL;
 	struct batadv_neigh_ifinfo *router_ifinfo = NULL;
 	char gw_addr[18] = { '\0' };
 	if (atomic_read(&bat_priv->gw.mode) != BATADV_GW_MODE_CLIENT)
 		goto out;
 	if (!bat_priv->algo_ops->gw.get_best_gw_node)
 		goto out;
 	curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 	if (!batadv_atomic_dec_not_zero(&bat_priv->gw.reselect) && curr_gw)
 		goto out;
 	/* if gw.reselect is set to 1 it means that a previous call to
 	 * gw.is_eligible() said that we have a new best GW, therefore it can
 	 * now be picked from the list and selected
 	 */
 	next_gw = bat_priv->algo_ops->gw.get_best_gw_node(bat_priv);
 	if (curr_gw == next_gw)
 		goto out;
 	if (next_gw) {
 		sprintf(gw_addr, "%pM", next_gw->orig_node->orig);
 		router = batadv_orig_router_get(next_gw->orig_node,
 						BATADV_IF_DEFAULT);
 		if (!router) {
 			batadv_gw_reselect(bat_priv);
 			goto out;
 		}
 		router_ifinfo = batadv_neigh_ifinfo_get(router,
 							BATADV_IF_DEFAULT);
 		if (!router_ifinfo) {
 			batadv_gw_reselect(bat_priv);
 			goto out;
 		}
 	}
 	if (curr_gw && !next_gw) {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Removing selected gateway - no gateway in range\n");
 		batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL,
 				    NULL);
 	} else if (!curr_gw && next_gw) {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Adding route to gateway %pM (bandwidth: %u.%u/%u.%u MBit, tq: %i)\n",
 			   next_gw->orig_node->orig,
 			   next_gw->bandwidth_down / 10,
 			   next_gw->bandwidth_down % 10,
 			   next_gw->bandwidth_up / 10,
 			   next_gw->bandwidth_up % 10,
 			   router_ifinfo->bat_iv.tq_avg);
 		batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_ADD,
 				    gw_addr);
 	} else {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Changing route to gateway %pM (bandwidth: %u.%u/%u.%u MBit, tq: %i)\n",
 			   next_gw->orig_node->orig,
 			   next_gw->bandwidth_down / 10,
 			   next_gw->bandwidth_down % 10,
 			   next_gw->bandwidth_up / 10,
 			   next_gw->bandwidth_up % 10,
 			   router_ifinfo->bat_iv.tq_avg);
 		batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_CHANGE,
 				    gw_addr);
 	}
 	batadv_gw_select(bat_priv, next_gw);
 out:
 	if (curr_gw)
 		batadv_gw_node_put(curr_gw);
 	if (next_gw)
 		batadv_gw_node_put(next_gw);
 	if (router)
 		batadv_neigh_node_put(router);
 	if (router_ifinfo)
 		batadv_neigh_ifinfo_put(router_ifinfo);
 }
 /**
  * batadv_gw_check_election() - Elect orig node as best gateway when eligible
  * @bat_priv: the bat priv with all the soft interface information
  * @orig_node: orig node which is to be checked
  */
 void batadv_gw_check_election(struct batadv_priv *bat_priv,
 			      struct batadv_orig_node *orig_node)
 {
 	struct batadv_orig_node *curr_gw_orig;
 	/* abort immediately if the routing algorithm does not support gateway
 	 * election
 	 */
 	if (!bat_priv->algo_ops->gw.is_eligible)
 		return;
 	curr_gw_orig = batadv_gw_get_selected_orig(bat_priv);
 	if (!curr_gw_orig)
 		goto reselect;
 	/* this node already is the gateway */
 	if (curr_gw_orig == orig_node)
 		goto out;
 	if (!bat_priv->algo_ops->gw.is_eligible(bat_priv, curr_gw_orig,
 						orig_node))
 		goto out;
 reselect:
 	batadv_gw_reselect(bat_priv);
 out:
 	if (curr_gw_orig)
 		batadv_orig_node_put(curr_gw_orig);
 }
 /**
  * batadv_gw_node_add() - add gateway node to list of available gateways
  * @bat_priv: the bat priv with all the soft interface information
  * @orig_node: originator announcing gateway capabilities
  * @gateway: announced bandwidth information
  *
  * Has to be called with the appropriate locks being acquired
  * (gw.list_lock).
  */
 static void batadv_gw_node_add(struct batadv_priv *bat_priv,
 			       struct batadv_orig_node *orig_node,
 			       struct batadv_tvlv_gateway_data *gateway)
 {
 	struct batadv_gw_node *gw_node;
 	lockdep_assert_held(&bat_priv->gw.list_lock);
 	if (gateway->bandwidth_down == 0)
 		return;
 	gw_node = kzalloc(sizeof(*gw_node), GFP_ATOMIC);
 	if (!gw_node)
 		return;
 	kref_init(&gw_node->refcount);
 	INIT_HLIST_NODE(&gw_node->list);
 	kref_get(&orig_node->refcount);
 	gw_node->orig_node = orig_node;
 	gw_node->bandwidth_down = ntohl(gateway->bandwidth_down);
 	gw_node->bandwidth_up = ntohl(gateway->bandwidth_up);
 	kref_get(&gw_node->refcount);
 	hlist_add_head_rcu(&gw_node->list, &bat_priv->gw.gateway_list);
 	bat_priv->gw.generation++;
 	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 		   "Found new gateway %pM -> gw bandwidth: %u.%u/%u.%u MBit\n",
 		   orig_node->orig,
 		   ntohl(gateway->bandwidth_down) / 10,
 		   ntohl(gateway->bandwidth_down) % 10,
 		   ntohl(gateway->bandwidth_up) / 10,
 		   ntohl(gateway->bandwidth_up) % 10);
 	/* don't return reference to new gw_node */
 	batadv_gw_node_put(gw_node);
 }
 /**
  * batadv_gw_node_get() - retrieve gateway node from list of available gateways
  * @bat_priv: the bat priv with all the soft interface information
  * @orig_node: originator announcing gateway capabilities
  *
  * Return: gateway node if found or NULL otherwise.
  */
 struct batadv_gw_node *batadv_gw_node_get(struct batadv_priv *bat_priv,
 					  struct batadv_orig_node *orig_node)
 {
 	struct batadv_gw_node *gw_node_tmp, *gw_node = NULL;
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(gw_node_tmp, &bat_priv->gw.gateway_list,
 				 list) {
 		if (gw_node_tmp->orig_node != orig_node)
 			continue;
 		if (!kref_get_unless_zero(&gw_node_tmp->refcount))
 			continue;
 		gw_node = gw_node_tmp;
 		break;
 	}
 	rcu_read_unlock();
 	return gw_node;
 }
 /**
  * batadv_gw_node_update() - update list of available gateways with changed
  *  bandwidth information
  * @bat_priv: the bat priv with all the soft interface information
  * @orig_node: originator announcing gateway capabilities
  * @gateway: announced bandwidth information
  */
 void batadv_gw_node_update(struct batadv_priv *bat_priv,
 			   struct batadv_orig_node *orig_node,
 			   struct batadv_tvlv_gateway_data *gateway)
 {
 	struct batadv_gw_node *gw_node, *curr_gw = NULL;
 	spin_lock_bh(&bat_priv->gw.list_lock);
 	gw_node = batadv_gw_node_get(bat_priv, orig_node);
 	if (!gw_node) {
 		batadv_gw_node_add(bat_priv, orig_node, gateway);
 		spin_unlock_bh(&bat_priv->gw.list_lock);
 		goto out;
 	}
 	spin_unlock_bh(&bat_priv->gw.list_lock);
 	if (gw_node->bandwidth_down == ntohl(gateway->bandwidth_down) &&
 	    gw_node->bandwidth_up == ntohl(gateway->bandwidth_up))
 		goto out;
 	batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 		   "Gateway bandwidth of originator %pM changed from %u.%u/%u.%u MBit to %u.%u/%u.%u MBit\n",
 		   orig_node->orig,
 		   gw_node->bandwidth_down / 10,
 		   gw_node->bandwidth_down % 10,
 		   gw_node->bandwidth_up / 10,
 		   gw_node->bandwidth_up % 10,
 		   ntohl(gateway->bandwidth_down) / 10,
 		   ntohl(gateway->bandwidth_down) % 10,
 		   ntohl(gateway->bandwidth_up) / 10,
 		   ntohl(gateway->bandwidth_up) % 10);
 	gw_node->bandwidth_down = ntohl(gateway->bandwidth_down);
 	gw_node->bandwidth_up = ntohl(gateway->bandwidth_up);
 	if (ntohl(gateway->bandwidth_down) == 0) {
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Gateway %pM removed from gateway list\n",
 			   orig_node->orig);
 		/* Note: We don't need a NULL check here, since curr_gw never
 		 * gets dereferenced.
 		 */
 		spin_lock_bh(&bat_priv->gw.list_lock);
 		if (!hlist_unhashed(&gw_node->list)) {
 			hlist_del_init_rcu(&gw_node->list);
 			batadv_gw_node_put(gw_node);
 			bat_priv->gw.generation++;
 		}
 		spin_unlock_bh(&bat_priv->gw.list_lock);
 		curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 		if (gw_node == curr_gw)
 			batadv_gw_reselect(bat_priv);
 		if (curr_gw)
 			batadv_gw_node_put(curr_gw);
 	}
 out:
 	if (gw_node)
 		batadv_gw_node_put(gw_node);
 }
 /**
  * batadv_gw_node_delete() - Remove orig_node from gateway list
  * @bat_priv: the bat priv with all the soft interface information
  * @orig_node: orig node which is currently in process of being removed
  */
 void batadv_gw_node_delete(struct batadv_priv *bat_priv,
 			   struct batadv_orig_node *orig_node)
 {
 	struct batadv_tvlv_gateway_data gateway;
 	gateway.bandwidth_down = 0;
 	gateway.bandwidth_up = 0;
 	batadv_gw_node_update(bat_priv, orig_node, &gateway);
 }
 /**
  * batadv_gw_node_free() - Free gateway information from soft interface
  * @bat_priv: the bat priv with all the soft interface information
  */
 void batadv_gw_node_free(struct batadv_priv *bat_priv)
 {
 	struct batadv_gw_node *gw_node;
 	struct hlist_node *node_tmp;
 	spin_lock_bh(&bat_priv->gw.list_lock);
 	hlist_for_each_entry_safe(gw_node, node_tmp,
 				  &bat_priv->gw.gateway_list, list) {
 		hlist_del_init_rcu(&gw_node->list);
 		batadv_gw_node_put(gw_node);
 		bat_priv->gw.generation++;
 	}
 	spin_unlock_bh(&bat_priv->gw.list_lock);
 }
 #ifdef CONFIG_BATMAN_ADV_DEBUGFS
 /**
  * batadv_gw_client_seq_print_text() - Print the gateway table in a seq file
  * @seq: seq file to print on
  * @offset: not used
  *
  * Return: always 0
  */
 int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset)
 {
 	struct net_device *net_dev = (struct net_device *)seq->private;
 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
 	struct batadv_hard_iface *primary_if;
 	primary_if = batadv_seq_print_text_primary_if_get(seq);
 	if (!primary_if)
 		return 0;
 	seq_printf(seq, "[B.A.T.M.A.N. adv %s, MainIF/MAC: %s/%pM (%s %s)]\n",
 		   BATADV_SOURCE_VERSION, primary_if->net_dev->name,
 		   primary_if->net_dev->dev_addr, net_dev->name,
 		   bat_priv->algo_ops->name);
 	batadv_hardif_put(primary_if);
 	if (!bat_priv->algo_ops->gw.print) {
 		seq_puts(seq,
 			 "No printing function for this routing protocol\n");
 		return 0;
 	}
 	bat_priv->algo_ops->gw.print(bat_priv, seq);
 	return 0;
 }
 #endif
 /**
  * batadv_gw_dump() - Dump gateways into a message
  * @msg: Netlink message to dump into
  * @cb: Control block containing additional options
  *
  * Return: Error code, or length of message
  */
 int batadv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	struct batadv_hard_iface *primary_if = NULL;
 	struct net *net = sock_net(cb->skb->sk);
 	struct net_device *soft_iface;
 	struct batadv_priv *bat_priv;
 	int ifindex;
 	int ret;
 	ifindex = batadv_netlink_get_ifindex(cb->nlh,
 					     BATADV_ATTR_MESH_IFINDEX);
 	if (!ifindex)
 		return -EINVAL;
 	soft_iface = dev_get_by_index(net, ifindex);
 	if (!soft_iface || !batadv_softif_is_valid(soft_iface)) {
 		ret = -ENODEV;
 		goto out;
 	}
 	bat_priv = netdev_priv(soft_iface);
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
 		ret = -ENOENT;
 		goto out;
 	}
 	if (!bat_priv->algo_ops->gw.dump) {
 		ret = -EOPNOTSUPP;
 		goto out;
 	}
 	bat_priv->algo_ops->gw.dump(msg, cb, bat_priv);
 	ret = msg->len;
 out:
 	if (primary_if)
 		batadv_hardif_put(primary_if);
 	if (soft_iface)
 		dev_put(soft_iface);
 	return ret;
 }
 /**
  * batadv_gw_dhcp_recipient_get() - check if a packet is a DHCP message
  * @skb: the packet to check
  * @header_len: a pointer to the batman-adv header size
  * @chaddr: buffer where the client address will be stored. Valid
  *  only if the function returns BATADV_DHCP_TO_CLIENT
  *
  * This function may re-allocate the data buffer of the skb passed as argument.
  *
  * Return:
  * - BATADV_DHCP_NO if the packet is not a dhcp message or if there was an error
  *   while parsing it
  * - BATADV_DHCP_TO_SERVER if this is a message going to the DHCP server
  * - BATADV_DHCP_TO_CLIENT if this is a message going to a DHCP client
  */
 enum batadv_dhcp_recipient
 batadv_gw_dhcp_recipient_get(struct sk_buff *skb, unsigned int *header_len,
 			     u8 *chaddr)
 {
 	enum batadv_dhcp_recipient ret = BATADV_DHCP_NO;
 	struct ethhdr *ethhdr;
 	struct iphdr *iphdr;
 	struct ipv6hdr *ipv6hdr;
 	struct udphdr *udphdr;
 	struct vlan_ethhdr *vhdr;
 	int chaddr_offset;
 	__be16 proto;
 	u8 *p;
 	/* check for ethernet header */
 	if (!pskb_may_pull(skb, *header_len + ETH_HLEN))
 		return BATADV_DHCP_NO;
 	ethhdr = eth_hdr(skb);
 	proto = ethhdr->h_proto;
 	*header_len += ETH_HLEN;
 	/* check for initial vlan header */
 	if (proto == htons(ETH_P_8021Q)) {
 		if (!pskb_may_pull(skb, *header_len + VLAN_HLEN))
 			return BATADV_DHCP_NO;
 		vhdr = vlan_eth_hdr(skb);
 		proto = vhdr->h_vlan_encapsulated_proto;
 		*header_len += VLAN_HLEN;
 	}
 	/* check for ip header */
 	switch (proto) {
 	case htons(ETH_P_IP):
 		if (!pskb_may_pull(skb, *header_len + sizeof(*iphdr)))
 			return BATADV_DHCP_NO;
 		iphdr = (struct iphdr *)(skb->data + *header_len);
 		*header_len += iphdr->ihl * 4;
 		/* check for udp header */
 		if (iphdr->protocol != IPPROTO_UDP)
 			return BATADV_DHCP_NO;
 		break;
 	case htons(ETH_P_IPV6):
 		if (!pskb_may_pull(skb, *header_len + sizeof(*ipv6hdr)))
 			return BATADV_DHCP_NO;
 		ipv6hdr = (struct ipv6hdr *)(skb->data + *header_len);
 		*header_len += sizeof(*ipv6hdr);
 		/* check for udp header */
 		if (ipv6hdr->nexthdr != IPPROTO_UDP)
 			return BATADV_DHCP_NO;
 		break;
 	default:
 		return BATADV_DHCP_NO;
 	}
 	if (!pskb_may_pull(skb, *header_len + sizeof(*udphdr)))
 		return BATADV_DHCP_NO;
 	udphdr = (struct udphdr *)(skb->data + *header_len);
 	*header_len += sizeof(*udphdr);
 	/* check for bootp port */
 	switch (proto) {
 	case htons(ETH_P_IP):
 		if (udphdr->dest == htons(67))
 			ret = BATADV_DHCP_TO_SERVER;
 		else if (udphdr->source == htons(67))
 			ret = BATADV_DHCP_TO_CLIENT;
 		break;
 	case htons(ETH_P_IPV6):
 		if (udphdr->dest == htons(547))
 			ret = BATADV_DHCP_TO_SERVER;
 		else if (udphdr->source == htons(547))
 			ret = BATADV_DHCP_TO_CLIENT;
 		break;
 	}
 	chaddr_offset = *header_len + BATADV_DHCP_CHADDR_OFFSET;
 	/* store the client address if the message is going to a client */
 	if (ret == BATADV_DHCP_TO_CLIENT &&
 	    pskb_may_pull(skb, chaddr_offset + ETH_ALEN)) {
 		/* check if the DHCP packet carries an Ethernet DHCP */
 		p = skb->data + *header_len + BATADV_DHCP_HTYPE_OFFSET;
 		if (*p != BATADV_DHCP_HTYPE_ETHERNET)
 			return BATADV_DHCP_NO;
 		/* check if the DHCP packet carries a valid Ethernet address */
 		p = skb->data + *header_len + BATADV_DHCP_HLEN_OFFSET;
 		if (*p != ETH_ALEN)
 			return BATADV_DHCP_NO;
 		ether_addr_copy(chaddr, skb->data + chaddr_offset);
 	}
 	return ret;
 }
 /**
  * batadv_gw_out_of_range() - check if the dhcp request destination is the best
  *  gateway
  * @bat_priv: the bat priv with all the soft interface information
  * @skb: the outgoing packet
  *
  * Check if the skb is a DHCP request and if it is sent to the current best GW
  * server. Due to topology changes it may be the case that the GW server
  * previously selected is not the best one anymore.
  *
  * This call might reallocate skb data.
  * Must be invoked only when the DHCP packet is going TO a DHCP SERVER.
  *
  * Return: true if the packet destination is unicast and it is not the best gw,
  * false otherwise.
  */
 bool batadv_gw_out_of_range(struct batadv_priv *bat_priv,
 			    struct sk_buff *skb)
 {
 	struct batadv_neigh_node *neigh_curr = NULL;
 	struct batadv_neigh_node *neigh_old = NULL;
 	struct batadv_orig_node *orig_dst_node = NULL;
 	struct batadv_gw_node *gw_node = NULL;
 	struct batadv_gw_node *curr_gw = NULL;
 	struct batadv_neigh_ifinfo *curr_ifinfo, *old_ifinfo;
 	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
 	bool out_of_range = false;
 	u8 curr_tq_avg;
 	unsigned short vid;
 	vid = batadv_get_vid(skb, 0);
 	if (is_multicast_ether_addr(ethhdr->h_dest))
 		goto out;
 	orig_dst_node = batadv_transtable_search(bat_priv, ethhdr->h_source,
 						 ethhdr->h_dest, vid);
 	if (!orig_dst_node)
 		goto out;
 	gw_node = batadv_gw_node_get(bat_priv, orig_dst_node);
 	if (!gw_node)
 		goto out;
 	switch (atomic_read(&bat_priv->gw.mode)) {
 	case BATADV_GW_MODE_SERVER:
 		/* If we are a GW then we are our best GW. We can artificially
 		 * set the tq towards ourself as the maximum value
 		 */
 		curr_tq_avg = BATADV_TQ_MAX_VALUE;
 		break;
 	case BATADV_GW_MODE_CLIENT:
 		curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
 		if (!curr_gw)
 			goto out;
 		/* packet is going to our gateway */
 		if (curr_gw->orig_node == orig_dst_node)
 			goto out;
 		/* If the dhcp packet has been sent to a different gw,
 		 * we have to evaluate whether the old gw is still
 		 * reliable enough
 		 */
 		neigh_curr = batadv_find_router(bat_priv, curr_gw->orig_node,
 						NULL);
 		if (!neigh_curr)
 			goto out;
 		curr_ifinfo = batadv_neigh_ifinfo_get(neigh_curr,
 						      BATADV_IF_DEFAULT);
 		if (!curr_ifinfo)
 			goto out;
 		curr_tq_avg = curr_ifinfo->bat_iv.tq_avg;
 		batadv_neigh_ifinfo_put(curr_ifinfo);
 		break;
 	case BATADV_GW_MODE_OFF:
 	default:
 		goto out;
 	}
 	neigh_old = batadv_find_router(bat_priv, orig_dst_node, NULL);
 	if (!neigh_old)
 		goto out;
 	old_ifinfo = batadv_neigh_ifinfo_get(neigh_old, BATADV_IF_DEFAULT);
 	if (!old_ifinfo)
 		goto out;
 	if ((curr_tq_avg - old_ifinfo->bat_iv.tq_avg) > BATADV_GW_THRESHOLD)
 		out_of_range = true;
 	batadv_neigh_ifinfo_put(old_ifinfo);
 out:
 	if (orig_dst_node)
 		batadv_orig_node_put(orig_dst_node);
 	if (curr_gw)
 		batadv_gw_node_put(curr_gw);
 	if (gw_node)
 		batadv_gw_node_put(gw_node);
 	if (neigh_old)
 		batadv_neigh_node_put(neigh_old);
 	if (neigh_curr)
 		batadv_neigh_node_put(neigh_curr);
 	return out_of_range;
 }

net/batman-adv/gateway_common.c

Diff comments View file @ e2d0d35

 // SPDX-License-Identifier: GPL-2.0
 /* Copyright (C) 2009-2019  B.A.T.M.A.N. contributors:
  *
  * Marek Lindner
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "gateway_common.h"
 #include "main.h"
 #include <linux/atomic.h>
 #include <linux/byteorder/generic.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/math64.h>
 #include <linux/netdevice.h>
 #include <linux/stddef.h>
 #include <linux/string.h>
 #include <uapi/linux/batadv_packet.h>
+#include <uapi/linux/batman_adv.h>
 #include "gateway_client.h"
 #include "log.h"
 #include "tvlv.h"
 /**
  * batadv_parse_throughput() - parse supplied string buffer to extract
  *  throughput information
  * @net_dev: the soft interface net device
  * @buff: string buffer to parse
  * @description: text shown when throughput string cannot be parsed
  * @throughput: pointer holding the returned throughput information
  *
  * Return: false on parse error and true otherwise.
  */
 bool batadv_parse_throughput(struct net_device *net_dev, char *buff,
 			     const char *description, u32 *throughput)
 {
 	enum batadv_bandwidth_units bw_unit_type = BATADV_BW_UNIT_KBIT;
 	u64 lthroughput;
 	char *tmp_ptr;
 	int ret;
 	if (strlen(buff) > 4) {
 		tmp_ptr = buff + strlen(buff) - 4;
 		if (strncasecmp(tmp_ptr, "mbit", 4) == 0)
 			bw_unit_type = BATADV_BW_UNIT_MBIT;
 		if (strncasecmp(tmp_ptr, "kbit", 4) == 0 ||
 		    bw_unit_type == BATADV_BW_UNIT_MBIT)
 			*tmp_ptr = '\0';
 	}
 	ret = kstrtou64(buff, 10, &lthroughput);
 	if (ret) {
 		batadv_err(net_dev,
 			   "Invalid throughput speed for %s: %s\n",
 			   description, buff);
 		return false;
 	}
 	switch (bw_unit_type) {
 	case BATADV_BW_UNIT_MBIT:
 		/* prevent overflow */
 		if (U64_MAX / 10 < lthroughput) {
 			batadv_err(net_dev,
 				   "Throughput speed for %s too large: %s\n",
 				   description, buff);
 			return false;
 		}
 		lthroughput *= 10;
 		break;
 	case BATADV_BW_UNIT_KBIT:
 	default:
 		lthroughput = div_u64(lthroughput, 100);
 		break;
 	}
 	if (lthroughput > U32_MAX) {
 		batadv_err(net_dev,
 			   "Throughput speed for %s too large: %s\n",
 			   description, buff);
 		return false;
 	}
 	*throughput = lthroughput;
 	return true;
 }
 /**
  * batadv_parse_gw_bandwidth() - parse supplied string buffer to extract
  *  download and upload bandwidth information
  * @net_dev: the soft interface net device
  * @buff: string buffer to parse
  * @down: pointer holding the returned download bandwidth information
  * @up: pointer holding the returned upload bandwidth information
  *
  * Return: false on parse error and true otherwise.
  */
 static bool batadv_parse_gw_bandwidth(struct net_device *net_dev, char *buff,
 				      u32 *down, u32 *up)
 {
 	char *slash_ptr;
 	bool ret;
 	slash_ptr = strchr(buff, '/');
 	if (slash_ptr)
 		*slash_ptr = 0;
 	ret = batadv_parse_throughput(net_dev, buff, "download gateway speed",
 				      down);
 	if (!ret)
 		return false;
 	/* we also got some upload info */
 	if (slash_ptr) {
 		ret = batadv_parse_throughput(net_dev, slash_ptr + 1,
 					      "upload gateway speed", up);
 		if (!ret)
 			return false;
 	}
 	return true;
 }
 /**
  * batadv_gw_tvlv_container_update() - update the gw tvlv container after
  *  gateway setting change
  * @bat_priv: the bat priv with all the soft interface information
  */
 void batadv_gw_tvlv_container_update(struct batadv_priv *bat_priv)
 {
 	struct batadv_tvlv_gateway_data gw;
 	u32 down, up;
 	char gw_mode;
 	gw_mode = atomic_read(&bat_priv->gw.mode);
 	switch (gw_mode) {
 	case BATADV_GW_MODE_OFF:
 	case BATADV_GW_MODE_CLIENT:
 		batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_GW, 1);
 		break;
 	case BATADV_GW_MODE_SERVER:
 		down = atomic_read(&bat_priv->gw.bandwidth_down);
 		up = atomic_read(&bat_priv->gw.bandwidth_up);
 		gw.bandwidth_down = htonl(down);
 		gw.bandwidth_up = htonl(up);
 		batadv_tvlv_container_register(bat_priv, BATADV_TVLV_GW, 1,
 					       &gw, sizeof(gw));
 		break;
 	}
 }
 /**
  * batadv_gw_bandwidth_set() - Parse and set download/upload gateway bandwidth
  *  from supplied string buffer
  * @net_dev: netdev struct of the soft interface
  * @buff: the buffer containing the user data
  * @count: number of bytes in the buffer
  *
  * Return: 'count' on success or a negative error code in case of failure
  */
 ssize_t batadv_gw_bandwidth_set(struct net_device *net_dev, char *buff,
 				size_t count)
 {
 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
 	u32 down_curr;
 	u32 up_curr;
 	u32 down_new = 0;
 	u32 up_new = 0;
 	bool ret;
 	down_curr = (unsigned int)atomic_read(&bat_priv->gw.bandwidth_down);
 	up_curr = (unsigned int)atomic_read(&bat_priv->gw.bandwidth_up);
 	ret = batadv_parse_gw_bandwidth(net_dev, buff, &down_new, &up_new);
 	if (!ret)
 		return -EINVAL;
 	if (!down_new)
 		down_new = 1;
 	if (!up_new)
 		up_new = down_new / 5;
 	if (!up_new)
 		up_new = 1;
 	if (down_curr == down_new && up_curr == up_new)
 		return count;
 	batadv_gw_reselect(bat_priv);
 	batadv_info(net_dev,
 		    "Changing gateway bandwidth from: '%u.%u/%u.%u MBit' to: '%u.%u/%u.%u MBit'\n",
 		    down_curr / 10, down_curr % 10, up_curr / 10, up_curr % 10,
 		    down_new / 10, down_new % 10, up_new / 10, up_new % 10);
 	atomic_set(&bat_priv->gw.bandwidth_down, down_new);
 	atomic_set(&bat_priv->gw.bandwidth_up, up_new);
 	batadv_gw_tvlv_container_update(bat_priv);
 	return count;
 }
 /**
  * batadv_gw_tvlv_ogm_handler_v1() - process incoming gateway tvlv container
  * @bat_priv: the bat priv with all the soft interface information
  * @orig: the orig_node of the ogm
  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
  * @tvlv_value: tvlv buffer containing the gateway data
  * @tvlv_value_len: tvlv buffer length
  */
 static void batadv_gw_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
 					  struct batadv_orig_node *orig,
 					  u8 flags,
 					  void *tvlv_value, u16 tvlv_value_len)
 {
 	struct batadv_tvlv_gateway_data gateway, *gateway_ptr;
 	/* only fetch the tvlv value if the handler wasn't called via the
 	 * CIFNOTFND flag and if there is data to fetch
 	 */
 	if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND ||
 	    tvlv_value_len < sizeof(gateway)) {
 		gateway.bandwidth_down = 0;
 		gateway.bandwidth_up = 0;
 	} else {
 		gateway_ptr = tvlv_value;
 		gateway.bandwidth_down = gateway_ptr->bandwidth_down;
 		gateway.bandwidth_up = gateway_ptr->bandwidth_up;
 		if (gateway.bandwidth_down == 0 ||
 		    gateway.bandwidth_up == 0) {
 			gateway.bandwidth_down = 0;
 			gateway.bandwidth_up = 0;
 		}
 	}
 	batadv_gw_node_update(bat_priv, orig, &gateway);
 	/* restart gateway selection */
 	if (gateway.bandwidth_down != 0 &&
 	    atomic_read(&bat_priv->gw.mode) == BATADV_GW_MODE_CLIENT)
 		batadv_gw_check_election(bat_priv, orig);
 }
 /**
  * batadv_gw_init() - initialise the gateway handling internals
  * @bat_priv: the bat priv with all the soft interface information
  */
 void batadv_gw_init(struct batadv_priv *bat_priv)
 {
 	if (bat_priv->algo_ops->gw.init_sel_class)
 		bat_priv->algo_ops->gw.init_sel_class(bat_priv);
 	else
 		atomic_set(&bat_priv->gw.sel_class, 1);
 	batadv_tvlv_handler_register(bat_priv, batadv_gw_tvlv_ogm_handler_v1,
 				     NULL, BATADV_TVLV_GW, 1,
 				     BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
 }
 /**
  * batadv_gw_free() - free the gateway handling internals
  * @bat_priv: the bat priv with all the soft interface information
  */
 void batadv_gw_free(struct batadv_priv *bat_priv)
 {
 	batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_GW, 1);
 	batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_GW, 1);
 }

net/batman-adv/gateway_common.h

Diff comments View file @ e2d0d35

 /* SPDX-License-Identifier: GPL-2.0 */
 /* Copyright (C) 2009-2019  B.A.T.M.A.N. contributors:
  *
  * Marek Lindner
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #ifndef _NET_BATMAN_ADV_GATEWAY_COMMON_H_
 #define _NET_BATMAN_ADV_GATEWAY_COMMON_H_
 #include "main.h"
 #include <linux/types.h>
 struct net_device;
-enum batadv_gw_modes {
-	BATADV_GW_MODE_OFF,
-	BATADV_GW_MODE_CLIENT,
-	BATADV_GW_MODE_SERVER,
-};
 /**
  * enum batadv_bandwidth_units - bandwidth unit types
  */
 enum batadv_bandwidth_units {
 	/** @BATADV_BW_UNIT_KBIT: unit type kbit */
 	BATADV_BW_UNIT_KBIT,
 	/** @BATADV_BW_UNIT_MBIT: unit type mbit */
 	BATADV_BW_UNIT_MBIT,
 };
 #define BATADV_GW_MODE_OFF_NAME	"off"
 #define BATADV_GW_MODE_CLIENT_NAME	"client"
 #define BATADV_GW_MODE_SERVER_NAME	"server"
 ssize_t batadv_gw_bandwidth_set(struct net_device *net_dev, char *buff,
 				size_t count);
 void batadv_gw_tvlv_container_update(struct batadv_priv *bat_priv);
 void batadv_gw_init(struct batadv_priv *bat_priv);
 void batadv_gw_free(struct batadv_priv *bat_priv);
 bool batadv_parse_throughput(struct net_device *net_dev, char *buff,
 			     const char *description, u32 *throughput);
 #endif /* _NET_BATMAN_ADV_GATEWAY_COMMON_H_ */

net/batman-adv/netlink.c

Diff comments View file @ e2d0d35

 // SPDX-License-Identifier: GPL-2.0
 /* Copyright (C) 2016-2019  B.A.T.M.A.N. contributors:
  *
  * Matthias Schiffer
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "netlink.h"
 #include "main.h"
 #include <linux/atomic.h>
 #include <linux/bitops.h>
 #include <linux/bug.h>
 #include <linux/byteorder/generic.h>
 #include <linux/cache.h>
 #include <linux/err.h>
 #include <linux/errno.h>
 #include <linux/export.h>
 #include <linux/genetlink.h>
 #include <linux/gfp.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/netdevice.h>
 #include <linux/netlink.h>
 #include <linux/printk.h>
 #include <linux/rtnetlink.h>
 #include <linux/skbuff.h>
 #include <linux/stddef.h>
 #include <linux/types.h>
 #include <net/genetlink.h>
 #include <net/netlink.h>
 #include <net/sock.h>
 #include <uapi/linux/batadv_packet.h>
 #include <uapi/linux/batman_adv.h>
 #include "bat_algo.h"
 #include "bridge_loop_avoidance.h"
 #include "distributed-arp-table.h"
 #include "gateway_client.h"
+#include "gateway_common.h"
 #include "hard-interface.h"
 #include "multicast.h"
 #include "originator.h"
 #include "soft-interface.h"
 #include "tp_meter.h"
 #include "translation-table.h"
 struct net;
 struct genl_family batadv_netlink_family;
 /* multicast groups */
 enum batadv_netlink_multicast_groups {
 	BATADV_NL_MCGRP_CONFIG,
 	BATADV_NL_MCGRP_TPMETER,
 };
 /**
  * enum batadv_genl_ops_flags - flags for genl_ops's internal_flags
  */
 enum batadv_genl_ops_flags {
 	/**
 	 * @BATADV_FLAG_NEED_MESH: request requires valid soft interface in
 	 *  attribute BATADV_ATTR_MESH_IFINDEX and expects a pointer to it to be
 	 *  saved in info->user_ptr[0]
 	 */
 	BATADV_FLAG_NEED_MESH = BIT(0),
 	/**
 	 * @BATADV_FLAG_NEED_HARDIF: request requires valid hard interface in
 	 *  attribute BATADV_ATTR_HARD_IFINDEX and expects a pointer to it to be
 	 *  saved in info->user_ptr[1]
 	 */
 	BATADV_FLAG_NEED_HARDIF = BIT(1),
 	/**
 	 * @BATADV_FLAG_NEED_VLAN: request requires valid vlan in
 	 *  attribute BATADV_ATTR_VLANID and expects a pointer to it to be
 	 *  saved in info->user_ptr[1]
 	 */
 	BATADV_FLAG_NEED_VLAN = BIT(2),
 };
 static const struct genl_multicast_group batadv_netlink_mcgrps[] = {
 	[BATADV_NL_MCGRP_CONFIG] = { .name = BATADV_NL_MCAST_GROUP_CONFIG },
 	[BATADV_NL_MCGRP_TPMETER] = { .name = BATADV_NL_MCAST_GROUP_TPMETER },
 };
 static const struct nla_policy batadv_netlink_policy[NUM_BATADV_ATTR] = {
 	[BATADV_ATTR_VERSION]			= { .type = NLA_STRING },
 	[BATADV_ATTR_ALGO_NAME]			= { .type = NLA_STRING },
 	[BATADV_ATTR_MESH_IFINDEX]		= { .type = NLA_U32 },
 	[BATADV_ATTR_MESH_IFNAME]		= { .type = NLA_STRING },
 	[BATADV_ATTR_MESH_ADDRESS]		= { .len = ETH_ALEN },
 	[BATADV_ATTR_HARD_IFINDEX]		= { .type = NLA_U32 },
 	[BATADV_ATTR_HARD_IFNAME]		= { .type = NLA_STRING },
 	[BATADV_ATTR_HARD_ADDRESS]		= { .len = ETH_ALEN },
 	[BATADV_ATTR_ORIG_ADDRESS]		= { .len = ETH_ALEN },
 	[BATADV_ATTR_TPMETER_RESULT]		= { .type = NLA_U8 },
 	[BATADV_ATTR_TPMETER_TEST_TIME]		= { .type = NLA_U32 },
 	[BATADV_ATTR_TPMETER_BYTES]		= { .type = NLA_U64 },
 	[BATADV_ATTR_TPMETER_COOKIE]		= { .type = NLA_U32 },
 	[BATADV_ATTR_ACTIVE]			= { .type = NLA_FLAG },
 	[BATADV_ATTR_TT_ADDRESS]		= { .len = ETH_ALEN },
 	[BATADV_ATTR_TT_TTVN]			= { .type = NLA_U8 },
 	[BATADV_ATTR_TT_LAST_TTVN]		= { .type = NLA_U8 },
 	[BATADV_ATTR_TT_CRC32]			= { .type = NLA_U32 },
 	[BATADV_ATTR_TT_VID]			= { .type = NLA_U16 },
 	[BATADV_ATTR_TT_FLAGS]			= { .type = NLA_U32 },
 	[BATADV_ATTR_FLAG_BEST]			= { .type = NLA_FLAG },
 	[BATADV_ATTR_LAST_SEEN_MSECS]		= { .type = NLA_U32 },
 	[BATADV_ATTR_NEIGH_ADDRESS]		= { .len = ETH_ALEN },
 	[BATADV_ATTR_TQ]			= { .type = NLA_U8 },
 	[BATADV_ATTR_THROUGHPUT]		= { .type = NLA_U32 },
 	[BATADV_ATTR_BANDWIDTH_UP]		= { .type = NLA_U32 },
 	[BATADV_ATTR_BANDWIDTH_DOWN]		= { .type = NLA_U32 },
 	[BATADV_ATTR_ROUTER]			= { .len = ETH_ALEN },
 	[BATADV_ATTR_BLA_OWN]			= { .type = NLA_FLAG },
 	[BATADV_ATTR_BLA_ADDRESS]		= { .len = ETH_ALEN },
 	[BATADV_ATTR_BLA_VID]			= { .type = NLA_U16 },
 	[BATADV_ATTR_BLA_BACKBONE]		= { .len = ETH_ALEN },
 	[BATADV_ATTR_BLA_CRC]			= { .type = NLA_U16 },
 	[BATADV_ATTR_DAT_CACHE_IP4ADDRESS]	= { .type = NLA_U32 },
 	[BATADV_ATTR_DAT_CACHE_HWADDRESS]	= { .len = ETH_ALEN },
 	[BATADV_ATTR_DAT_CACHE_VID]		= { .type = NLA_U16 },
 	[BATADV_ATTR_MCAST_FLAGS]		= { .type = NLA_U32 },
 	[BATADV_ATTR_MCAST_FLAGS_PRIV]		= { .type = NLA_U32 },
 	[BATADV_ATTR_VLANID]			= { .type = NLA_U16 },
 	[BATADV_ATTR_AGGREGATED_OGMS_ENABLED]	= { .type = NLA_U8 },
 	[BATADV_ATTR_AP_ISOLATION_ENABLED]	= { .type = NLA_U8 },
 	[BATADV_ATTR_ISOLATION_MARK]		= { .type = NLA_U32 },
 	[BATADV_ATTR_ISOLATION_MASK]		= { .type = NLA_U32 },
 	[BATADV_ATTR_BONDING_ENABLED]		= { .type = NLA_U8 },
 	[BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED]	= { .type = NLA_U8 },
 	[BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED]	= { .type = NLA_U8 },
 	[BATADV_ATTR_FRAGMENTATION_ENABLED]	= { .type = NLA_U8 },
+	[BATADV_ATTR_GW_BANDWIDTH_DOWN]		= { .type = NLA_U32 },
+	[BATADV_ATTR_GW_BANDWIDTH_UP]		= { .type = NLA_U32 },
+	[BATADV_ATTR_GW_MODE]			= { .type = NLA_U8 },
+	[BATADV_ATTR_GW_SEL_CLASS]		= { .type = NLA_U32 },
 };
 /**
  * batadv_netlink_get_ifindex() - Extract an interface index from a message
  * @nlh: Message header
  * @attrtype: Attribute which holds an interface index
  *
  * Return: interface index, or 0.
  */
 int
 batadv_netlink_get_ifindex(const struct nlmsghdr *nlh, int attrtype)
 {
 	struct nlattr *attr = nlmsg_find_attr(nlh, GENL_HDRLEN, attrtype);
 	return attr ? nla_get_u32(attr) : 0;
 }
 /**
  * batadv_netlink_mesh_fill_ap_isolation() - Add ap_isolation softif attribute
  * @msg: Netlink message to dump into
  * @bat_priv: the bat priv with all the soft interface information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_mesh_fill_ap_isolation(struct sk_buff *msg,
 						 struct batadv_priv *bat_priv)
 {
 	struct batadv_softif_vlan *vlan;
 	u8 ap_isolation;
 	vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
 	if (!vlan)
 		return 0;
 	ap_isolation = atomic_read(&vlan->ap_isolation);
 	batadv_softif_vlan_put(vlan);
 	return nla_put_u8(msg, BATADV_ATTR_AP_ISOLATION_ENABLED,
 			  !!ap_isolation);
 }
 /**
  * batadv_option_set_ap_isolation() - Set ap_isolation from genl msg
  * @attr: parsed BATADV_ATTR_AP_ISOLATION_ENABLED attribute
  * @bat_priv: the bat priv with all the soft interface information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_set_mesh_ap_isolation(struct nlattr *attr,
 						struct batadv_priv *bat_priv)
 {
 	struct batadv_softif_vlan *vlan;
 	vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
 	if (!vlan)
 		return -ENOENT;
 	atomic_set(&vlan->ap_isolation, !!nla_get_u8(attr));
 	batadv_softif_vlan_put(vlan);
 	return 0;
 }
 /**
  * batadv_netlink_mesh_fill() - Fill message with mesh attributes
  * @msg: Netlink message to dump into
  * @bat_priv: the bat priv with all the soft interface information
  * @cmd: type of message to generate
  * @portid: Port making netlink request
  * @seq: sequence number for message
  * @flags: Additional flags for message
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_mesh_fill(struct sk_buff *msg,
 				    struct batadv_priv *bat_priv,
 				    enum batadv_nl_commands cmd,
 				    u32 portid, u32 seq, int flags)
 {
 	struct net_device *soft_iface = bat_priv->soft_iface;
 	struct batadv_hard_iface *primary_if = NULL;
 	struct net_device *hard_iface;
 	void *hdr;
 	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, flags, cmd);
 	if (!hdr)
 		return -ENOBUFS;
 	if (nla_put_string(msg, BATADV_ATTR_VERSION, BATADV_SOURCE_VERSION) ||
 	    nla_put_string(msg, BATADV_ATTR_ALGO_NAME,
 			   bat_priv->algo_ops->name) ||
 	    nla_put_u32(msg, BATADV_ATTR_MESH_IFINDEX, soft_iface->ifindex) ||
 	    nla_put_string(msg, BATADV_ATTR_MESH_IFNAME, soft_iface->name) ||
 	    nla_put(msg, BATADV_ATTR_MESH_ADDRESS, ETH_ALEN,
 		    soft_iface->dev_addr) ||
 	    nla_put_u8(msg, BATADV_ATTR_TT_TTVN,
 		       (u8)atomic_read(&bat_priv->tt.vn)))
 		goto nla_put_failure;
 #ifdef CONFIG_BATMAN_ADV_BLA
 	if (nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
 			ntohs(bat_priv->bla.claim_dest.group)))
 		goto nla_put_failure;
 #endif
 	if (batadv_mcast_mesh_info_put(msg, bat_priv))
 		goto nla_put_failure;
 	primary_if = batadv_primary_if_get_selected(bat_priv);
 	if (primary_if && primary_if->if_status == BATADV_IF_ACTIVE) {
 		hard_iface = primary_if->net_dev;
 		if (nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
 				hard_iface->ifindex) ||
 		    nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
 				   hard_iface->name) ||
 		    nla_put(msg, BATADV_ATTR_HARD_ADDRESS, ETH_ALEN,
 			    hard_iface->dev_addr))
 			goto nla_put_failure;
 	}
 	if (nla_put_u8(msg, BATADV_ATTR_AGGREGATED_OGMS_ENABLED,
 		       !!atomic_read(&bat_priv->aggregated_ogms)))
 		goto nla_put_failure;
 	if (batadv_netlink_mesh_fill_ap_isolation(msg, bat_priv))
 		goto nla_put_failure;
 	if (nla_put_u32(msg, BATADV_ATTR_ISOLATION_MARK,
 			bat_priv->isolation_mark))
 		goto nla_put_failure;
 	if (nla_put_u32(msg, BATADV_ATTR_ISOLATION_MASK,
 			bat_priv->isolation_mark_mask))
 		goto nla_put_failure;
 	if (nla_put_u8(msg, BATADV_ATTR_BONDING_ENABLED,
 		       !!atomic_read(&bat_priv->bonding)))
 		goto nla_put_failure;
 #ifdef CONFIG_BATMAN_ADV_BLA
 	if (nla_put_u8(msg, BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED,
 		       !!atomic_read(&bat_priv->bridge_loop_avoidance)))
 		goto nla_put_failure;
 #endif /* CONFIG_BATMAN_ADV_BLA */
 #ifdef CONFIG_BATMAN_ADV_DAT
 	if (nla_put_u8(msg, BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED,
 		       !!atomic_read(&bat_priv->distributed_arp_table)))
 		goto nla_put_failure;
 #endif /* CONFIG_BATMAN_ADV_DAT */
 	if (nla_put_u8(msg, BATADV_ATTR_FRAGMENTATION_ENABLED,
 		       !!atomic_read(&bat_priv->fragmentation)))
 		goto nla_put_failure;
+	if (nla_put_u32(msg, BATADV_ATTR_GW_BANDWIDTH_DOWN,
+			atomic_read(&bat_priv->gw.bandwidth_down)))
+		goto nla_put_failure;
+	if (nla_put_u32(msg, BATADV_ATTR_GW_BANDWIDTH_UP,
+			atomic_read(&bat_priv->gw.bandwidth_up)))
+		goto nla_put_failure;
+	if (nla_put_u8(msg, BATADV_ATTR_GW_MODE,
+		       atomic_read(&bat_priv->gw.mode)))
+		goto nla_put_failure;
+	if (bat_priv->algo_ops->gw.get_best_gw_node &&
+	    bat_priv->algo_ops->gw.is_eligible) {
+		/* GW selection class is not available if the routing algorithm
+		 * in use does not implement the GW API
+		 */
+		if (nla_put_u32(msg, BATADV_ATTR_GW_SEL_CLASS,
+				atomic_read(&bat_priv->gw.sel_class)))
+			goto nla_put_failure;
+	}
 	if (primary_if)
 		batadv_hardif_put(primary_if);
 	genlmsg_end(msg, hdr);
 	return 0;
 nla_put_failure:
 	if (primary_if)
 		batadv_hardif_put(primary_if);
 	genlmsg_cancel(msg, hdr);
 	return -EMSGSIZE;
 }
 /**
  * batadv_netlink_notify_mesh() - send softif attributes to listener
  * @bat_priv: the bat priv with all the soft interface information
  *
  * Return: 0 on success, < 0 on error
  */
 static int batadv_netlink_notify_mesh(struct batadv_priv *bat_priv)
 {
 	struct sk_buff *msg;
 	int ret;
 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg)
 		return -ENOMEM;
 	ret = batadv_netlink_mesh_fill(msg, bat_priv, BATADV_CMD_SET_MESH,
 				       0, 0, 0);
 	if (ret < 0) {
 		nlmsg_free(msg);
 		return ret;
 	}
 	genlmsg_multicast_netns(&batadv_netlink_family,
 				dev_net(bat_priv->soft_iface), msg, 0,
 				BATADV_NL_MCGRP_CONFIG, GFP_KERNEL);
 	return 0;
 }
 /**
  * batadv_netlink_get_mesh() - Get softif attributes
  * @skb: Netlink message with request data
  * @info: receiver information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_get_mesh(struct sk_buff *skb, struct genl_info *info)
 {
 	struct batadv_priv *bat_priv = info->user_ptr[0];
 	struct sk_buff *msg;
 	int ret;
 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg)
 		return -ENOMEM;
 	ret = batadv_netlink_mesh_fill(msg, bat_priv, BATADV_CMD_GET_MESH,
 				       info->snd_portid, info->snd_seq, 0);
 	if (ret < 0) {
 		nlmsg_free(msg);
 		return ret;
 	}
 	ret = genlmsg_reply(msg, info);
 	return ret;
 }
 /**
  * batadv_netlink_set_mesh() - Set softif attributes
  * @skb: Netlink message with request data
  * @info: receiver information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_set_mesh(struct sk_buff *skb, struct genl_info *info)
 {
 	struct batadv_priv *bat_priv = info->user_ptr[0];
 	struct nlattr *attr;
 	if (info->attrs[BATADV_ATTR_AGGREGATED_OGMS_ENABLED]) {
 		attr = info->attrs[BATADV_ATTR_AGGREGATED_OGMS_ENABLED];
 		atomic_set(&bat_priv->aggregated_ogms, !!nla_get_u8(attr));
 	}
 	if (info->attrs[BATADV_ATTR_AP_ISOLATION_ENABLED]) {
 		attr = info->attrs[BATADV_ATTR_AP_ISOLATION_ENABLED];
 		batadv_netlink_set_mesh_ap_isolation(attr, bat_priv);
 	}
 	if (info->attrs[BATADV_ATTR_ISOLATION_MARK]) {
 		attr = info->attrs[BATADV_ATTR_ISOLATION_MARK];
 		bat_priv->isolation_mark = nla_get_u32(attr);
 	}
 	if (info->attrs[BATADV_ATTR_ISOLATION_MASK]) {
 		attr = info->attrs[BATADV_ATTR_ISOLATION_MASK];
 		bat_priv->isolation_mark_mask = nla_get_u32(attr);
 	}
 	if (info->attrs[BATADV_ATTR_BONDING_ENABLED]) {
 		attr = info->attrs[BATADV_ATTR_BONDING_ENABLED];
 		atomic_set(&bat_priv->bonding, !!nla_get_u8(attr));
 	}
 #ifdef CONFIG_BATMAN_ADV_BLA
 	if (info->attrs[BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED]) {
 		attr = info->attrs[BATADV_ATTR_BRIDGE_LOOP_AVOIDANCE_ENABLED];
 		atomic_set(&bat_priv->bridge_loop_avoidance,
 			   !!nla_get_u8(attr));
 		batadv_bla_status_update(bat_priv->soft_iface);
 	}
 #endif /* CONFIG_BATMAN_ADV_BLA */
 #ifdef CONFIG_BATMAN_ADV_DAT
 	if (info->attrs[BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED]) {
 		attr = info->attrs[BATADV_ATTR_DISTRIBUTED_ARP_TABLE_ENABLED];
 		atomic_set(&bat_priv->distributed_arp_table,
 			   !!nla_get_u8(attr));
 		batadv_dat_status_update(bat_priv->soft_iface);
 	}
 #endif /* CONFIG_BATMAN_ADV_DAT */
 	if (info->attrs[BATADV_ATTR_FRAGMENTATION_ENABLED]) {
 		attr = info->attrs[BATADV_ATTR_FRAGMENTATION_ENABLED];
 		atomic_set(&bat_priv->fragmentation, !!nla_get_u8(attr));
 		batadv_update_min_mtu(bat_priv->soft_iface);
+	}
+	if (info->attrs[BATADV_ATTR_GW_BANDWIDTH_DOWN]) {
+		attr = info->attrs[BATADV_ATTR_GW_BANDWIDTH_DOWN];
+		atomic_set(&bat_priv->gw.bandwidth_down, nla_get_u32(attr));
+		batadv_gw_tvlv_container_update(bat_priv);
+	}
+	if (info->attrs[BATADV_ATTR_GW_BANDWIDTH_UP]) {
+		attr = info->attrs[BATADV_ATTR_GW_BANDWIDTH_UP];
+		atomic_set(&bat_priv->gw.bandwidth_up, nla_get_u32(attr));
+		batadv_gw_tvlv_container_update(bat_priv);
+	}
+	if (info->attrs[BATADV_ATTR_GW_MODE]) {
+		u8 gw_mode;
+		attr = info->attrs[BATADV_ATTR_GW_MODE];
+		gw_mode = nla_get_u8(attr);
+		if (gw_mode <= BATADV_GW_MODE_SERVER) {
+			/* Invoking batadv_gw_reselect() is not enough to really
+			 * de-select the current GW. It will only instruct the
+			 * gateway client code to perform a re-election the next
+			 * time that this is needed.
+			 *
+			 * When gw client mode is being switched off the current
+			 * GW must be de-selected explicitly otherwise no GW_ADD
+			 * uevent is thrown on client mode re-activation. This
+			 * is operation is performed in
+			 * batadv_gw_check_client_stop().
+			 */
+			batadv_gw_reselect(bat_priv);
+			/* always call batadv_gw_check_client_stop() before
+			 * changing the gateway state
+			 */
+			batadv_gw_check_client_stop(bat_priv);
+			atomic_set(&bat_priv->gw.mode, gw_mode);
+			batadv_gw_tvlv_container_update(bat_priv);
+		}
+	}
+	if (info->attrs[BATADV_ATTR_GW_SEL_CLASS] &&
+	    bat_priv->algo_ops->gw.get_best_gw_node &&
+	    bat_priv->algo_ops->gw.is_eligible) {
+		/* setting the GW selection class is allowed only if the routing
+		 * algorithm in use implements the GW API
+		 */
+		u32 sel_class_max = 0xffffffffu;
+		u32 sel_class;
+		attr = info->attrs[BATADV_ATTR_GW_SEL_CLASS];
+		sel_class = nla_get_u32(attr);
+		if (!bat_priv->algo_ops->gw.store_sel_class)
+			sel_class_max = BATADV_TQ_MAX_VALUE;
+		if (sel_class >= 1 && sel_class <= sel_class_max) {
+			atomic_set(&bat_priv->gw.sel_class, sel_class);
+			batadv_gw_reselect(bat_priv);
+		}
 	}
 	batadv_netlink_notify_mesh(bat_priv);
 	return 0;
 }
 /**
  * batadv_netlink_tp_meter_put() - Fill information of started tp_meter session
  * @msg: netlink message to be sent back
  * @cookie: tp meter session cookie
  *
  *  Return: 0 on success, < 0 on error
  */
 static int
 batadv_netlink_tp_meter_put(struct sk_buff *msg, u32 cookie)
 {
 	if (nla_put_u32(msg, BATADV_ATTR_TPMETER_COOKIE, cookie))
 		return -ENOBUFS;
 	return 0;
 }
 /**
  * batadv_netlink_tpmeter_notify() - send tp_meter result via netlink to client
  * @bat_priv: the bat priv with all the soft interface information
  * @dst: destination of tp_meter session
  * @result: reason for tp meter session stop
  * @test_time: total time ot the tp_meter session
  * @total_bytes: bytes acked to the receiver
  * @cookie: cookie of tp_meter session
  *
  * Return: 0 on success, < 0 on error
  */
 int batadv_netlink_tpmeter_notify(struct batadv_priv *bat_priv, const u8 *dst,
 				  u8 result, u32 test_time, u64 total_bytes,
 				  u32 cookie)
 {
 	struct sk_buff *msg;
 	void *hdr;
 	int ret;
 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg)
 		return -ENOMEM;
 	hdr = genlmsg_put(msg, 0, 0, &batadv_netlink_family, 0,
 			  BATADV_CMD_TP_METER);
 	if (!hdr) {
 		ret = -ENOBUFS;
 		goto err_genlmsg;
 	}
 	if (nla_put_u32(msg, BATADV_ATTR_TPMETER_COOKIE, cookie))
 		goto nla_put_failure;
 	if (nla_put_u32(msg, BATADV_ATTR_TPMETER_TEST_TIME, test_time))
 		goto nla_put_failure;
 	if (nla_put_u64_64bit(msg, BATADV_ATTR_TPMETER_BYTES, total_bytes,
 			      BATADV_ATTR_PAD))
 		goto nla_put_failure;
 	if (nla_put_u8(msg, BATADV_ATTR_TPMETER_RESULT, result))
 		goto nla_put_failure;
 	if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, dst))
 		goto nla_put_failure;
 	genlmsg_end(msg, hdr);
 	genlmsg_multicast_netns(&batadv_netlink_family,
 				dev_net(bat_priv->soft_iface), msg, 0,
 				BATADV_NL_MCGRP_TPMETER, GFP_KERNEL);
 	return 0;
 nla_put_failure:
 	genlmsg_cancel(msg, hdr);
 	ret = -EMSGSIZE;
 err_genlmsg:
 	nlmsg_free(msg);
 	return ret;
 }
 /**
  * batadv_netlink_tp_meter_start() - Start a new tp_meter session
  * @skb: received netlink message
  * @info: receiver information
  *
  * Return: 0 on success, < 0 on error
  */
 static int
 batadv_netlink_tp_meter_start(struct sk_buff *skb, struct genl_info *info)
 {
 	struct batadv_priv *bat_priv = info->user_ptr[0];
 	struct sk_buff *msg = NULL;
 	u32 test_length;
 	void *msg_head;
 	u32 cookie;
 	u8 *dst;
 	int ret;
 	if (!info->attrs[BATADV_ATTR_ORIG_ADDRESS])
 		return -EINVAL;
 	if (!info->attrs[BATADV_ATTR_TPMETER_TEST_TIME])
 		return -EINVAL;
 	dst = nla_data(info->attrs[BATADV_ATTR_ORIG_ADDRESS]);
 	test_length = nla_get_u32(info->attrs[BATADV_ATTR_TPMETER_TEST_TIME]);
 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg) {
 		ret = -ENOMEM;
 		goto out;
 	}
 	msg_head = genlmsg_put(msg, info->snd_portid, info->snd_seq,
 			       &batadv_netlink_family, 0,
 			       BATADV_CMD_TP_METER);
 	if (!msg_head) {
 		ret = -ENOBUFS;
 		goto out;
 	}
 	batadv_tp_start(bat_priv, dst, test_length, &cookie);
 	ret = batadv_netlink_tp_meter_put(msg, cookie);
  out:
 	if (ret) {
 		if (msg)
 			nlmsg_free(msg);
 		return ret;
 	}
 	genlmsg_end(msg, msg_head);
 	return genlmsg_reply(msg, info);
 }
 /**
  * batadv_netlink_tp_meter_start() - Cancel a running tp_meter session
  * @skb: received netlink message
  * @info: receiver information
  *
  * Return: 0 on success, < 0 on error
  */
 static int
 batadv_netlink_tp_meter_cancel(struct sk_buff *skb, struct genl_info *info)
 {
 	struct batadv_priv *bat_priv = info->user_ptr[0];
 	u8 *dst;
 	int ret = 0;
 	if (!info->attrs[BATADV_ATTR_ORIG_ADDRESS])
 		return -EINVAL;
 	dst = nla_data(info->attrs[BATADV_ATTR_ORIG_ADDRESS]);
 	batadv_tp_stop(bat_priv, dst, BATADV_TP_REASON_CANCEL);
 	return ret;
 }
 /**
  * batadv_netlink_hardif_fill() - Fill message with hardif attributes
  * @msg: Netlink message to dump into
  * @bat_priv: the bat priv with all the soft interface information
  * @hard_iface: hard interface which was modified
  * @cmd: type of message to generate
  * @portid: Port making netlink request
  * @seq: sequence number for message
  * @flags: Additional flags for message
  * @cb: Control block containing additional options
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_hardif_fill(struct sk_buff *msg,
 				      struct batadv_priv *bat_priv,
 				      struct batadv_hard_iface *hard_iface,
 				      enum batadv_nl_commands cmd,
 				      u32 portid, u32 seq, int flags,
 				      struct netlink_callback *cb)
 {
 	struct net_device *net_dev = hard_iface->net_dev;
 	void *hdr;
 	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, flags, cmd);
 	if (!hdr)
 		return -ENOBUFS;
 	if (cb)
 		genl_dump_check_consistent(cb, hdr);
 	if (nla_put_u32(msg, BATADV_ATTR_MESH_IFINDEX,
 			bat_priv->soft_iface->ifindex))
 		goto nla_put_failure;
 	if (nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
 			net_dev->ifindex) ||
 	    nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
 			   net_dev->name) ||
 	    nla_put(msg, BATADV_ATTR_HARD_ADDRESS, ETH_ALEN,
 		    net_dev->dev_addr))
 		goto nla_put_failure;
 	if (hard_iface->if_status == BATADV_IF_ACTIVE) {
 		if (nla_put_flag(msg, BATADV_ATTR_ACTIVE))
 			goto nla_put_failure;
 	}
 	genlmsg_end(msg, hdr);
 	return 0;
 nla_put_failure:
 	genlmsg_cancel(msg, hdr);
 	return -EMSGSIZE;
 }
 /**
  * batadv_netlink_notify_hardif() - send hardif attributes to listener
  * @bat_priv: the bat priv with all the soft interface information
  * @hard_iface: hard interface which was modified
  *
  * Return: 0 on success, < 0 on error
  */
 static int batadv_netlink_notify_hardif(struct batadv_priv *bat_priv,
 					struct batadv_hard_iface *hard_iface)
 {
 	struct sk_buff *msg;
 	int ret;
 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg)
 		return -ENOMEM;
 	ret = batadv_netlink_hardif_fill(msg, bat_priv, hard_iface,
 					 BATADV_CMD_SET_HARDIF, 0, 0, 0, NULL);
 	if (ret < 0) {
 		nlmsg_free(msg);
 		return ret;
 	}
 	genlmsg_multicast_netns(&batadv_netlink_family,
 				dev_net(bat_priv->soft_iface), msg, 0,
 				BATADV_NL_MCGRP_CONFIG, GFP_KERNEL);
 	return 0;
 }
 /**
  * batadv_netlink_get_hardif() - Get hardif attributes
  * @skb: Netlink message with request data
  * @info: receiver information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_get_hardif(struct sk_buff *skb,
 				     struct genl_info *info)
 {
 	struct batadv_hard_iface *hard_iface = info->user_ptr[1];
 	struct batadv_priv *bat_priv = info->user_ptr[0];
 	struct sk_buff *msg;
 	int ret;
 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg)
 		return -ENOMEM;
 	ret = batadv_netlink_hardif_fill(msg, bat_priv, hard_iface,
 					 BATADV_CMD_GET_HARDIF,
 					 info->snd_portid, info->snd_seq, 0,
 					 NULL);
 	if (ret < 0) {
 		nlmsg_free(msg);
 		return ret;
 	}
 	ret = genlmsg_reply(msg, info);
 	return ret;
 }
 /**
  * batadv_netlink_set_hardif() - Set hardif attributes
  * @skb: Netlink message with request data
  * @info: receiver information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_set_hardif(struct sk_buff *skb,
 				     struct genl_info *info)
 {
 	struct batadv_hard_iface *hard_iface = info->user_ptr[1];
 	struct batadv_priv *bat_priv = info->user_ptr[0];
 	batadv_netlink_notify_hardif(bat_priv, hard_iface);
 	return 0;
 }
 /**
  * batadv_netlink_dump_hardif() - Dump all hard interface into a messages
  * @msg: Netlink message to dump into
  * @cb: Parameters from query
  *
  * Return: error code, or length of reply message on success
  */
 static int
 batadv_netlink_dump_hardif(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	struct net *net = sock_net(cb->skb->sk);
 	struct net_device *soft_iface;
 	struct batadv_hard_iface *hard_iface;
 	struct batadv_priv *bat_priv;
 	int ifindex;
 	int portid = NETLINK_CB(cb->skb).portid;
 	int skip = cb->args[0];
 	int i = 0;
 	ifindex = batadv_netlink_get_ifindex(cb->nlh,
 					     BATADV_ATTR_MESH_IFINDEX);
 	if (!ifindex)
 		return -EINVAL;
 	soft_iface = dev_get_by_index(net, ifindex);
 	if (!soft_iface)
 		return -ENODEV;
 	if (!batadv_softif_is_valid(soft_iface)) {
 		dev_put(soft_iface);
 		return -ENODEV;
 	}
 	bat_priv = netdev_priv(soft_iface);
 	rtnl_lock();
 	cb->seq = batadv_hardif_generation << 1 | 1;
 	list_for_each_entry(hard_iface, &batadv_hardif_list, list) {
 		if (hard_iface->soft_iface != soft_iface)
 			continue;
 		if (i++ < skip)
 			continue;
 		if (batadv_netlink_hardif_fill(msg, bat_priv, hard_iface,
 					       BATADV_CMD_GET_HARDIF,
 					       portid, cb->nlh->nlmsg_seq,
 					       NLM_F_MULTI, cb)) {
 			i--;
 			break;
 		}
 	}
 	rtnl_unlock();
 	dev_put(soft_iface);
 	cb->args[0] = i;
 	return msg->len;
 }
 /**
  * batadv_netlink_vlan_fill() - Fill message with vlan attributes
  * @msg: Netlink message to dump into
  * @bat_priv: the bat priv with all the soft interface information
  * @vlan: vlan which was modified
  * @cmd: type of message to generate
  * @portid: Port making netlink request
  * @seq: sequence number for message
  * @flags: Additional flags for message
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_vlan_fill(struct sk_buff *msg,
 				    struct batadv_priv *bat_priv,
 				    struct batadv_softif_vlan *vlan,
 				    enum batadv_nl_commands cmd,
 				    u32 portid, u32 seq, int flags)
 {
 	void *hdr;
 	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, flags, cmd);
 	if (!hdr)
 		return -ENOBUFS;
 	if (nla_put_u32(msg, BATADV_ATTR_MESH_IFINDEX,
 			bat_priv->soft_iface->ifindex))
 		goto nla_put_failure;
 	if (nla_put_u32(msg, BATADV_ATTR_VLANID, vlan->vid & VLAN_VID_MASK))
 		goto nla_put_failure;
 	if (nla_put_u8(msg, BATADV_ATTR_AP_ISOLATION_ENABLED,
 		       !!atomic_read(&vlan->ap_isolation)))
 		goto nla_put_failure;
 	genlmsg_end(msg, hdr);
 	return 0;
 nla_put_failure:
 	genlmsg_cancel(msg, hdr);
 	return -EMSGSIZE;
 }
 /**
  * batadv_netlink_notify_vlan() - send vlan attributes to listener
  * @bat_priv: the bat priv with all the soft interface information
  * @vlan: vlan which was modified
  *
  * Return: 0 on success, < 0 on error
  */
 static int batadv_netlink_notify_vlan(struct batadv_priv *bat_priv,
 				      struct batadv_softif_vlan *vlan)
 {
 	struct sk_buff *msg;
 	int ret;
 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg)
 		return -ENOMEM;
 	ret = batadv_netlink_vlan_fill(msg, bat_priv, vlan,
 				       BATADV_CMD_SET_VLAN, 0, 0, 0);
 	if (ret < 0) {
 		nlmsg_free(msg);
 		return ret;
 	}
 	genlmsg_multicast_netns(&batadv_netlink_family,
 				dev_net(bat_priv->soft_iface), msg, 0,
 				BATADV_NL_MCGRP_CONFIG, GFP_KERNEL);
 	return 0;
 }
 /**
  * batadv_netlink_get_vlan() - Get vlan attributes
  * @skb: Netlink message with request data
  * @info: receiver information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_get_vlan(struct sk_buff *skb, struct genl_info *info)
 {
 	struct batadv_softif_vlan *vlan = info->user_ptr[1];
 	struct batadv_priv *bat_priv = info->user_ptr[0];
 	struct sk_buff *msg;
 	int ret;
 	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
 	if (!msg)
 		return -ENOMEM;
 	ret = batadv_netlink_vlan_fill(msg, bat_priv, vlan, BATADV_CMD_GET_VLAN,
 				       info->snd_portid, info->snd_seq, 0);
 	if (ret < 0) {
 		nlmsg_free(msg);
 		return ret;
 	}
 	ret = genlmsg_reply(msg, info);
 	return ret;
 }
 /**
  * batadv_netlink_set_vlan() - Get vlan attributes
  * @skb: Netlink message with request data
  * @info: receiver information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_netlink_set_vlan(struct sk_buff *skb, struct genl_info *info)
 {
 	struct batadv_softif_vlan *vlan = info->user_ptr[1];
 	struct batadv_priv *bat_priv = info->user_ptr[0];
 	struct nlattr *attr;
 	if (info->attrs[BATADV_ATTR_AP_ISOLATION_ENABLED]) {
 		attr = info->attrs[BATADV_ATTR_AP_ISOLATION_ENABLED];
 		atomic_set(&vlan->ap_isolation, !!nla_get_u8(attr));
 	}
 	batadv_netlink_notify_vlan(bat_priv, vlan);
 	return 0;
 }
 /**
  * batadv_get_softif_from_info() - Retrieve soft interface from genl attributes
  * @net: the applicable net namespace
  * @info: receiver information
  *
  * Return: Pointer to soft interface (with increased refcnt) on success, error
  *  pointer on error
  */
 static struct net_device *
 batadv_get_softif_from_info(struct net *net, struct genl_info *info)
 {
 	struct net_device *soft_iface;
 	int ifindex;
 	if (!info->attrs[BATADV_ATTR_MESH_IFINDEX])
 		return ERR_PTR(-EINVAL);
 	ifindex = nla_get_u32(info->attrs[BATADV_ATTR_MESH_IFINDEX]);
 	soft_iface = dev_get_by_index(net, ifindex);
 	if (!soft_iface)
 		return ERR_PTR(-ENODEV);
 	if (!batadv_softif_is_valid(soft_iface))
 		goto err_put_softif;
 	return soft_iface;
 err_put_softif:
 	dev_put(soft_iface);
 	return ERR_PTR(-EINVAL);
 }
 /**
  * batadv_get_hardif_from_info() - Retrieve hardif from genl attributes
  * @bat_priv: the bat priv with all the soft interface information
  * @net: the applicable net namespace
  * @info: receiver information
  *
  * Return: Pointer to hard interface (with increased refcnt) on success, error
  *  pointer on error
  */
 static struct batadv_hard_iface *
 batadv_get_hardif_from_info(struct batadv_priv *bat_priv, struct net *net,
 			    struct genl_info *info)
 {
 	struct batadv_hard_iface *hard_iface;
 	struct net_device *hard_dev;
 	unsigned int hardif_index;
 	if (!info->attrs[BATADV_ATTR_HARD_IFINDEX])
 		return ERR_PTR(-EINVAL);
 	hardif_index = nla_get_u32(info->attrs[BATADV_ATTR_HARD_IFINDEX]);
 	hard_dev = dev_get_by_index(net, hardif_index);
 	if (!hard_dev)
 		return ERR_PTR(-ENODEV);
 	hard_iface = batadv_hardif_get_by_netdev(hard_dev);
 	if (!hard_iface)
 		goto err_put_harddev;
 	if (hard_iface->soft_iface != bat_priv->soft_iface)
 		goto err_put_hardif;
 	/* hard_dev is referenced by hard_iface and not needed here */
 	dev_put(hard_dev);
 	return hard_iface;
 err_put_hardif:
 	batadv_hardif_put(hard_iface);
 err_put_harddev:
 	dev_put(hard_dev);
 	return ERR_PTR(-EINVAL);
 }
 /**
  * batadv_get_vlan_from_info() - Retrieve vlan from genl attributes
  * @bat_priv: the bat priv with all the soft interface information
  * @net: the applicable net namespace
  * @info: receiver information
  *
  * Return: Pointer to vlan on success (with increased refcnt), error pointer
  *  on error
  */
 static struct batadv_softif_vlan *
 batadv_get_vlan_from_info(struct batadv_priv *bat_priv, struct net *net,
 			  struct genl_info *info)
 {
 	struct batadv_softif_vlan *vlan;
 	u16 vid;
 	if (!info->attrs[BATADV_ATTR_VLANID])
 		return ERR_PTR(-EINVAL);
 	vid = nla_get_u16(info->attrs[BATADV_ATTR_VLANID]);
 	vlan = batadv_softif_vlan_get(bat_priv, vid | BATADV_VLAN_HAS_TAG);
 	if (!vlan)
 		return ERR_PTR(-ENOENT);
 	return vlan;
 }
 /**
  * batadv_pre_doit() - Prepare batman-adv genl doit request
  * @ops: requested netlink operation
  * @skb: Netlink message with request data
  * @info: receiver information
  *
  * Return: 0 on success or negative error number in case of failure
  */
 static int batadv_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
 			   struct genl_info *info)
 {
 	struct net *net = genl_info_net(info);
 	struct batadv_hard_iface *hard_iface;
 	struct batadv_priv *bat_priv = NULL;
 	struct batadv_softif_vlan *vlan;
 	struct net_device *soft_iface;
 	u8 user_ptr1_flags;
 	u8 mesh_dep_flags;
 	int ret;
 	user_ptr1_flags = BATADV_FLAG_NEED_HARDIF | BATADV_FLAG_NEED_VLAN;
 	if (WARN_ON(hweight8(ops->internal_flags & user_ptr1_flags) > 1))
 		return -EINVAL;
 	mesh_dep_flags = BATADV_FLAG_NEED_HARDIF | BATADV_FLAG_NEED_VLAN;
 	if (WARN_ON((ops->internal_flags & mesh_dep_flags) &&
 		    (~ops->internal_flags & BATADV_FLAG_NEED_MESH)))
 		return -EINVAL;
 	if (ops->internal_flags & BATADV_FLAG_NEED_MESH) {
 		soft_iface = batadv_get_softif_from_info(net, info);
 		if (IS_ERR(soft_iface))
 			return PTR_ERR(soft_iface);
 		bat_priv = netdev_priv(soft_iface);
 		info->user_ptr[0] = bat_priv;
 	}
 	if (ops->internal_flags & BATADV_FLAG_NEED_HARDIF) {
 		hard_iface = batadv_get_hardif_from_info(bat_priv, net, info);
 		if (IS_ERR(hard_iface)) {
 			ret = PTR_ERR(hard_iface);
 			goto err_put_softif;
 		}
 		info->user_ptr[1] = hard_iface;
 	}
 	if (ops->internal_flags & BATADV_FLAG_NEED_VLAN) {
 		vlan = batadv_get_vlan_from_info(bat_priv, net, info);
 		if (IS_ERR(vlan)) {
 			ret = PTR_ERR(vlan);
 			goto err_put_softif;
 		}
 		info->user_ptr[1] = vlan;
 	}
 	return 0;
 err_put_softif:
 	if (bat_priv)
 		dev_put(bat_priv->soft_iface);
 	return ret;
 }
 /**
  * batadv_post_doit() - End batman-adv genl doit request
  * @ops: requested netlink operation
  * @skb: Netlink message with request data
  * @info: receiver information
  */
 static void batadv_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
 			     struct genl_info *info)
 {
 	struct batadv_hard_iface *hard_iface;
 	struct batadv_softif_vlan *vlan;
 	struct batadv_priv *bat_priv;
 	if (ops->internal_flags & BATADV_FLAG_NEED_HARDIF &&
 	    info->user_ptr[1]) {
 		hard_iface = info->user_ptr[1];
 		batadv_hardif_put(hard_iface);
 	}
 	if (ops->internal_flags & BATADV_FLAG_NEED_VLAN && info->user_ptr[1]) {
 		vlan = info->user_ptr[1];
 		batadv_softif_vlan_put(vlan);
 	}
 	if (ops->internal_flags & BATADV_FLAG_NEED_MESH && info->user_ptr[0]) {
 		bat_priv = info->user_ptr[0];
 		dev_put(bat_priv->soft_iface);
 	}
 }
 static const struct genl_ops batadv_netlink_ops[] = {
 	{
 		.cmd = BATADV_CMD_GET_MESH,
 		/* can be retrieved by unprivileged users */
 		.policy = batadv_netlink_policy,
 		.doit = batadv_netlink_get_mesh,
 		.internal_flags = BATADV_FLAG_NEED_MESH,
 	},
 	{
 		.cmd = BATADV_CMD_TP_METER,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.doit = batadv_netlink_tp_meter_start,
 		.internal_flags = BATADV_FLAG_NEED_MESH,
 	},
 	{
 		.cmd = BATADV_CMD_TP_METER_CANCEL,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.doit = batadv_netlink_tp_meter_cancel,
 		.internal_flags = BATADV_FLAG_NEED_MESH,
 	},
 	{
 		.cmd = BATADV_CMD_GET_ROUTING_ALGOS,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_algo_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_HARDIF,
 		/* can be retrieved by unprivileged users */
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_netlink_dump_hardif,
 		.doit = batadv_netlink_get_hardif,
 		.internal_flags = BATADV_FLAG_NEED_MESH |
 				  BATADV_FLAG_NEED_HARDIF,
 	},
 	{
 		.cmd = BATADV_CMD_GET_TRANSTABLE_LOCAL,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_tt_local_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_TRANSTABLE_GLOBAL,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_tt_global_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_ORIGINATORS,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_orig_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_NEIGHBORS,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_hardif_neigh_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_GATEWAYS,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_gw_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_BLA_CLAIM,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_bla_claim_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_BLA_BACKBONE,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_bla_backbone_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_DAT_CACHE,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_dat_cache_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_MCAST_FLAGS,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_mcast_flags_dump,
 	},
 	{
 		.cmd = BATADV_CMD_SET_MESH,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.doit = batadv_netlink_set_mesh,
 		.internal_flags = BATADV_FLAG_NEED_MESH,
 	},
 	{
 		.cmd = BATADV_CMD_SET_HARDIF,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.doit = batadv_netlink_set_hardif,
 		.internal_flags = BATADV_FLAG_NEED_MESH |
 				  BATADV_FLAG_NEED_HARDIF,
 	},
 	{
 		.cmd = BATADV_CMD_GET_VLAN,
 		/* can be retrieved by unprivileged users */
 		.policy = batadv_netlink_policy,
 		.doit = batadv_netlink_get_vlan,
 		.internal_flags = BATADV_FLAG_NEED_MESH |
 				  BATADV_FLAG_NEED_VLAN,
 	},
 	{
 		.cmd = BATADV_CMD_SET_VLAN,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
 		.doit = batadv_netlink_set_vlan,
 		.internal_flags = BATADV_FLAG_NEED_MESH |
 				  BATADV_FLAG_NEED_VLAN,
 	},
 };
 struct genl_family batadv_netlink_family __ro_after_init = {
 	.hdrsize = 0,
 	.name = BATADV_NL_NAME,
 	.version = 1,
 	.maxattr = BATADV_ATTR_MAX,
 	.netnsok = true,
 	.pre_doit = batadv_pre_doit,
 	.post_doit = batadv_post_doit,
 	.module = THIS_MODULE,
 	.ops = batadv_netlink_ops,
 	.n_ops = ARRAY_SIZE(batadv_netlink_ops),
 	.mcgrps = batadv_netlink_mcgrps,
 	.n_mcgrps = ARRAY_SIZE(batadv_netlink_mcgrps),
 };
 /**
  * batadv_netlink_register() - register batadv genl netlink family
  */
 void __init batadv_netlink_register(void)
 {
 	int ret;
 	ret = genl_register_family(&batadv_netlink_family);
 	if (ret)
 		pr_warn("unable to register netlink family");
 }
 /**
  * batadv_netlink_unregister() - unregister batadv genl netlink family
  */
 void batadv_netlink_unregister(void)
 {
 	genl_unregister_family(&batadv_netlink_family);
 }

net/batman-adv/soft-interface.c

Diff comments View file @ e2d0d35

 // SPDX-License-Identifier: GPL-2.0
 /* Copyright (C) 2007-2019  B.A.T.M.A.N. contributors:
  *
  * Marek Lindner, Simon Wunderlich
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "soft-interface.h"
 #include "main.h"
 #include <linux/atomic.h>
 #include <linux/byteorder/generic.h>
 #include <linux/cache.h>
 #include <linux/compiler.h>
 #include <linux/cpumask.h>
 #include <linux/errno.h>
 #include <linux/etherdevice.h>
 #include <linux/ethtool.h>
 #include <linux/gfp.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
 #include <linux/jiffies.h>
 #include <linux/kernel.h>
 #include <linux/kref.h>
 #include <linux/list.h>
 #include <linux/lockdep.h>
 #include <linux/netdevice.h>
 #include <linux/percpu.h>
 #include <linux/printk.h>
 #include <linux/random.h>
 #include <linux/rculist.h>
 #include <linux/rcupdate.h>
 #include <linux/rtnetlink.h>
 #include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/socket.h>
 #include <linux/spinlock.h>
 #include <linux/stddef.h>
 #include <linux/string.h>
 #include <linux/types.h>
 #include <uapi/linux/batadv_packet.h>
+#include <uapi/linux/batman_adv.h>
 #include "bat_algo.h"
 #include "bridge_loop_avoidance.h"
 #include "debugfs.h"
 #include "distributed-arp-table.h"
 #include "gateway_client.h"
-#include "gateway_common.h"
 #include "hard-interface.h"
 #include "multicast.h"
 #include "network-coding.h"
 #include "originator.h"
 #include "send.h"
 #include "sysfs.h"
 #include "translation-table.h"
 /**
  * batadv_skb_head_push() - Increase header size and move (push) head pointer
  * @skb: packet buffer which should be modified
  * @len: number of bytes to add
  *
  * Return: 0 on success or negative error number in case of failure
  */
 int batadv_skb_head_push(struct sk_buff *skb, unsigned int len)
 {
 	int result;
 	/* TODO: We must check if we can release all references to non-payload
 	 * data using __skb_header_release in our skbs to allow skb_cow_header
 	 * to work optimally. This means that those skbs are not allowed to read
 	 * or write any data which is before the current position of skb->data
 	 * after that call and thus allow other skbs with the same data buffer
 	 * to write freely in that area.
 	 */
 	result = skb_cow_head(skb, len);
 	if (result < 0)
 		return result;
 	skb_push(skb, len);
 	return 0;
 }
 static int batadv_interface_open(struct net_device *dev)
 {
 	netif_start_queue(dev);
 	return 0;
 }
 static int batadv_interface_release(struct net_device *dev)
 {
 	netif_stop_queue(dev);
 	return 0;
 }
 /**
  * batadv_sum_counter() - Sum the cpu-local counters for index 'idx'
  * @bat_priv: the bat priv with all the soft interface information
  * @idx: index of counter to sum up
  *
  * Return: sum of all cpu-local counters
  */
 static u64 batadv_sum_counter(struct batadv_priv *bat_priv,  size_t idx)
 {
 	u64 *counters, sum = 0;
 	int cpu;
 	for_each_possible_cpu(cpu) {
 		counters = per_cpu_ptr(bat_priv->bat_counters, cpu);
 		sum += counters[idx];
 	}
 	return sum;
 }
 static struct net_device_stats *batadv_interface_stats(struct net_device *dev)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct net_device_stats *stats = &dev->stats;
 	stats->tx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_TX);
 	stats->tx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_TX_BYTES);
 	stats->tx_dropped = batadv_sum_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 	stats->rx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_RX);
 	stats->rx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_RX_BYTES);
 	return stats;
 }
 static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct batadv_softif_vlan *vlan;
 	struct sockaddr *addr = p;
 	u8 old_addr[ETH_ALEN];
 	if (!is_valid_ether_addr(addr->sa_data))
 		return -EADDRNOTAVAIL;
 	ether_addr_copy(old_addr, dev->dev_addr);
 	ether_addr_copy(dev->dev_addr, addr->sa_data);
 	/* only modify transtable if it has been initialized before */
 	if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 		return 0;
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) {
 		batadv_tt_local_remove(bat_priv, old_addr, vlan->vid,
 				       "mac address changed", false);
 		batadv_tt_local_add(dev, addr->sa_data, vlan->vid,
 				    BATADV_NULL_IFINDEX, BATADV_NO_MARK);
 	}
 	rcu_read_unlock();
 	return 0;
 }
 static int batadv_interface_change_mtu(struct net_device *dev, int new_mtu)
 {
 	/* check ranges */
 	if (new_mtu < 68 || new_mtu > batadv_hardif_min_mtu(dev))
 		return -EINVAL;
 	dev->mtu = new_mtu;
 	return 0;
 }
 /**
  * batadv_interface_set_rx_mode() - set the rx mode of a device
  * @dev: registered network device to modify
  *
  * We do not actually need to set any rx filters for the virtual batman
  * soft interface. However a dummy handler enables a user to set static
  * multicast listeners for instance.
  */
 static void batadv_interface_set_rx_mode(struct net_device *dev)
 {
 }
 static netdev_tx_t batadv_interface_tx(struct sk_buff *skb,
 				       struct net_device *soft_iface)
 {
 	struct ethhdr *ethhdr;
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct batadv_hard_iface *primary_if = NULL;
 	struct batadv_bcast_packet *bcast_packet;
 	static const u8 stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00,
 					      0x00, 0x00};
 	static const u8 ectp_addr[ETH_ALEN] = {0xCF, 0x00, 0x00, 0x00,
 					       0x00, 0x00};
 	enum batadv_dhcp_recipient dhcp_rcp = BATADV_DHCP_NO;
 	u8 *dst_hint = NULL, chaddr[ETH_ALEN];
 	struct vlan_ethhdr *vhdr;
 	unsigned int header_len = 0;
 	int data_len = skb->len, ret;
 	unsigned long brd_delay = 1;
 	bool do_bcast = false, client_added;
 	unsigned short vid;
 	u32 seqno;
 	int gw_mode;
 	enum batadv_forw_mode forw_mode;
 	struct batadv_orig_node *mcast_single_orig = NULL;
 	int network_offset = ETH_HLEN;
 	__be16 proto;
 	if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
 		goto dropped;
 	/* reset control block to avoid left overs from previous users */
 	memset(skb->cb, 0, sizeof(struct batadv_skb_cb));
 	netif_trans_update(soft_iface);
 	vid = batadv_get_vid(skb, 0);
 	ethhdr = eth_hdr(skb);
 	proto = ethhdr->h_proto;
 	switch (ntohs(proto)) {
 	case ETH_P_8021Q:
 		vhdr = vlan_eth_hdr(skb);
 		proto = vhdr->h_vlan_encapsulated_proto;
 		/* drop batman-in-batman packets to prevent loops */
 		if (proto != htons(ETH_P_BATMAN)) {
 			network_offset += VLAN_HLEN;
 			break;
 		}
 		/* fall through */
 	case ETH_P_BATMAN:
 		goto dropped;
 	}
 	skb_set_network_header(skb, network_offset);
 	if (batadv_bla_tx(bat_priv, skb, vid))
 		goto dropped;
 	/* skb->data might have been reallocated by batadv_bla_tx() */
 	ethhdr = eth_hdr(skb);
 	/* Register the client MAC in the transtable */
 	if (!is_multicast_ether_addr(ethhdr->h_source) &&
 	    !batadv_bla_is_loopdetect_mac(ethhdr->h_source)) {
 		client_added = batadv_tt_local_add(soft_iface, ethhdr->h_source,
 						   vid, skb->skb_iif,
 						   skb->mark);
 		if (!client_added)
 			goto dropped;
 	}
 	/* Snoop address candidates from DHCPACKs for early DAT filling */
 	batadv_dat_snoop_outgoing_dhcp_ack(bat_priv, skb, proto, vid);
 	/* don't accept stp packets. STP does not help in meshes.
 	 * better use the bridge loop avoidance ...
 	 *
 	 * The same goes for ECTP sent at least by some Cisco Switches,
 	 * it might confuse the mesh when used with bridge loop avoidance.
 	 */
 	if (batadv_compare_eth(ethhdr->h_dest, stp_addr))
 		goto dropped;
 	if (batadv_compare_eth(ethhdr->h_dest, ectp_addr))
 		goto dropped;
 	gw_mode = atomic_read(&bat_priv->gw.mode);
 	if (is_multicast_ether_addr(ethhdr->h_dest)) {
 		/* if gw mode is off, broadcast every packet */
 		if (gw_mode == BATADV_GW_MODE_OFF) {
 			do_bcast = true;
 			goto send;
 		}
 		dhcp_rcp = batadv_gw_dhcp_recipient_get(skb, &header_len,
 							chaddr);
 		/* skb->data may have been modified by
 		 * batadv_gw_dhcp_recipient_get()
 		 */
 		ethhdr = eth_hdr(skb);
 		/* if gw_mode is on, broadcast any non-DHCP message.
 		 * All the DHCP packets are going to be sent as unicast
 		 */
 		if (dhcp_rcp == BATADV_DHCP_NO) {
 			do_bcast = true;
 			goto send;
 		}
 		if (dhcp_rcp == BATADV_DHCP_TO_CLIENT)
 			dst_hint = chaddr;
 		else if ((gw_mode == BATADV_GW_MODE_SERVER) &&
 			 (dhcp_rcp == BATADV_DHCP_TO_SERVER))
 			/* gateways should not forward any DHCP message if
 			 * directed to a DHCP server
 			 */
 			goto dropped;
 send:
 		if (do_bcast && !is_broadcast_ether_addr(ethhdr->h_dest)) {
 			forw_mode = batadv_mcast_forw_mode(bat_priv, skb,
 							   &mcast_single_orig);
 			if (forw_mode == BATADV_FORW_NONE)
 				goto dropped;
 			if (forw_mode == BATADV_FORW_SINGLE)
 				do_bcast = false;
 		}
 	}
 	batadv_skb_set_priority(skb, 0);
 	/* ethernet packet should be broadcasted */
 	if (do_bcast) {
 		primary_if = batadv_primary_if_get_selected(bat_priv);
 		if (!primary_if)
 			goto dropped;
 		/* in case of ARP request, we do not immediately broadcasti the
 		 * packet, instead we first wait for DAT to try to retrieve the
 		 * correct ARP entry
 		 */
 		if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
 			brd_delay = msecs_to_jiffies(ARP_REQ_DELAY);
 		if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
 			goto dropped;
 		bcast_packet = (struct batadv_bcast_packet *)skb->data;
 		bcast_packet->version = BATADV_COMPAT_VERSION;
 		bcast_packet->ttl = BATADV_TTL;
 		/* batman packet type: broadcast */
 		bcast_packet->packet_type = BATADV_BCAST;
 		bcast_packet->reserved = 0;
 		/* hw address of first interface is the orig mac because only
 		 * this mac is known throughout the mesh
 		 */
 		ether_addr_copy(bcast_packet->orig,
 				primary_if->net_dev->dev_addr);
 		/* set broadcast sequence number */
 		seqno = atomic_inc_return(&bat_priv->bcast_seqno);
 		bcast_packet->seqno = htonl(seqno);
 		batadv_add_bcast_packet_to_list(bat_priv, skb, brd_delay, true);
 		/* a copy is stored in the bcast list, therefore removing
 		 * the original skb.
 		 */
 		consume_skb(skb);
 	/* unicast packet */
 	} else {
 		/* DHCP packets going to a server will use the GW feature */
 		if (dhcp_rcp == BATADV_DHCP_TO_SERVER) {
 			ret = batadv_gw_out_of_range(bat_priv, skb);
 			if (ret)
 				goto dropped;
 			ret = batadv_send_skb_via_gw(bat_priv, skb, vid);
 		} else if (mcast_single_orig) {
 			ret = batadv_send_skb_unicast(bat_priv, skb,
 						      BATADV_UNICAST, 0,
 						      mcast_single_orig, vid);
 		} else {
 			if (batadv_dat_snoop_outgoing_arp_request(bat_priv,
 								  skb))
 				goto dropped;
 			batadv_dat_snoop_outgoing_arp_reply(bat_priv, skb);
 			ret = batadv_send_skb_via_tt(bat_priv, skb, dst_hint,
 						     vid);
 		}
 		if (ret != NET_XMIT_SUCCESS)
 			goto dropped_freed;
 	}
 	batadv_inc_counter(bat_priv, BATADV_CNT_TX);
 	batadv_add_counter(bat_priv, BATADV_CNT_TX_BYTES, data_len);
 	goto end;
 dropped:
 	kfree_skb(skb);
 dropped_freed:
 	batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED);
 end:
 	if (mcast_single_orig)
 		batadv_orig_node_put(mcast_single_orig);
 	if (primary_if)
 		batadv_hardif_put(primary_if);
 	return NETDEV_TX_OK;
 }
 /**
  * batadv_interface_rx() - receive ethernet frame on local batman-adv interface
  * @soft_iface: local interface which will receive the ethernet frame
  * @skb: ethernet frame for @soft_iface
  * @hdr_size: size of already parsed batman-adv header
  * @orig_node: originator from which the batman-adv packet was sent
  *
  * Sends a ethernet frame to the receive path of the local @soft_iface.
  * skb->data has still point to the batman-adv header with the size @hdr_size.
  * The caller has to have parsed this header already and made sure that at least
  * @hdr_size bytes are still available for pull in @skb.
  *
  * The packet may still get dropped. This can happen when the encapsulated
  * ethernet frame is invalid or contains again an batman-adv packet. Also
  * unicast packets will be dropped directly when it was sent between two
  * isolated clients.
  */
 void batadv_interface_rx(struct net_device *soft_iface,
 			 struct sk_buff *skb, int hdr_size,
 			 struct batadv_orig_node *orig_node)
 {
 	struct batadv_bcast_packet *batadv_bcast_packet;
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct vlan_ethhdr *vhdr;
 	struct ethhdr *ethhdr;
 	unsigned short vid;
 	bool is_bcast;
 	batadv_bcast_packet = (struct batadv_bcast_packet *)skb->data;
 	is_bcast = (batadv_bcast_packet->packet_type == BATADV_BCAST);
 	skb_pull_rcsum(skb, hdr_size);
 	skb_reset_mac_header(skb);
 	/* clean the netfilter state now that the batman-adv header has been
 	 * removed
 	 */
 	nf_reset(skb);
 	if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
 		goto dropped;
 	vid = batadv_get_vid(skb, 0);
 	ethhdr = eth_hdr(skb);
 	switch (ntohs(ethhdr->h_proto)) {
 	case ETH_P_8021Q:
 		if (!pskb_may_pull(skb, VLAN_ETH_HLEN))
 			goto dropped;
 		vhdr = (struct vlan_ethhdr *)skb->data;
 		/* drop batman-in-batman packets to prevent loops */
 		if (vhdr->h_vlan_encapsulated_proto != htons(ETH_P_BATMAN))
 			break;
 		/* fall through */
 	case ETH_P_BATMAN:
 		goto dropped;
 	}
 	/* skb->dev & skb->pkt_type are set here */
 	skb->protocol = eth_type_trans(skb, soft_iface);
 	skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
 	batadv_inc_counter(bat_priv, BATADV_CNT_RX);
 	batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
 			   skb->len + ETH_HLEN);
 	/* Let the bridge loop avoidance check the packet. If will
 	 * not handle it, we can safely push it up.
 	 */
 	if (batadv_bla_rx(bat_priv, skb, vid, is_bcast))
 		goto out;
 	if (orig_node)
 		batadv_tt_add_temporary_global_entry(bat_priv, orig_node,
 						     ethhdr->h_source, vid);
 	if (is_multicast_ether_addr(ethhdr->h_dest)) {
 		/* set the mark on broadcast packets if AP isolation is ON and
 		 * the packet is coming from an "isolated" client
 		 */
 		if (batadv_vlan_ap_isola_get(bat_priv, vid) &&
 		    batadv_tt_global_is_isolated(bat_priv, ethhdr->h_source,
 						 vid)) {
 			/* save bits in skb->mark not covered by the mask and
 			 * apply the mark on the rest
 			 */
 			skb->mark &= ~bat_priv->isolation_mark_mask;
 			skb->mark |= bat_priv->isolation_mark;
 		}
 	} else if (batadv_is_ap_isolated(bat_priv, ethhdr->h_source,
 					 ethhdr->h_dest, vid)) {
 		goto dropped;
 	}
 	netif_rx(skb);
 	goto out;
 dropped:
 	kfree_skb(skb);
 out:
 	return;
 }
 /**
  * batadv_softif_vlan_release() - release vlan from lists and queue for free
  *  after rcu grace period
  * @ref: kref pointer of the vlan object
  */
 static void batadv_softif_vlan_release(struct kref *ref)
 {
 	struct batadv_softif_vlan *vlan;
 	vlan = container_of(ref, struct batadv_softif_vlan, refcount);
 	spin_lock_bh(&vlan->bat_priv->softif_vlan_list_lock);
 	hlist_del_rcu(&vlan->list);
 	spin_unlock_bh(&vlan->bat_priv->softif_vlan_list_lock);
 	kfree_rcu(vlan, rcu);
 }
 /**
  * batadv_softif_vlan_put() - decrease the vlan object refcounter and
  *  possibly release it
  * @vlan: the vlan object to release
  */
 void batadv_softif_vlan_put(struct batadv_softif_vlan *vlan)
 {
 	if (!vlan)
 		return;
 	kref_put(&vlan->refcount, batadv_softif_vlan_release);
 }
 /**
  * batadv_softif_vlan_get() - get the vlan object for a specific vid
  * @bat_priv: the bat priv with all the soft interface information
  * @vid: the identifier of the vlan object to retrieve
  *
  * Return: the private data of the vlan matching the vid passed as argument or
  * NULL otherwise. The refcounter of the returned object is incremented by 1.
  */
 struct batadv_softif_vlan *batadv_softif_vlan_get(struct batadv_priv *bat_priv,
 						  unsigned short vid)
 {
 	struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
 		if (vlan_tmp->vid != vid)
 			continue;
 		if (!kref_get_unless_zero(&vlan_tmp->refcount))
 			continue;
 		vlan = vlan_tmp;
 		break;
 	}
 	rcu_read_unlock();
 	return vlan;
 }
 /**
  * batadv_softif_create_vlan() - allocate the needed resources for a new vlan
  * @bat_priv: the bat priv with all the soft interface information
  * @vid: the VLAN identifier
  *
  * Return: 0 on success, a negative error otherwise.
  */
 int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid)
 {
 	struct batadv_softif_vlan *vlan;
 	int err;
 	spin_lock_bh(&bat_priv->softif_vlan_list_lock);
 	vlan = batadv_softif_vlan_get(bat_priv, vid);
 	if (vlan) {
 		batadv_softif_vlan_put(vlan);
 		spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
 		return -EEXIST;
 	}
 	vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC);
 	if (!vlan) {
 		spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
 		return -ENOMEM;
 	}
 	vlan->bat_priv = bat_priv;
 	vlan->vid = vid;
 	kref_init(&vlan->refcount);
 	atomic_set(&vlan->ap_isolation, 0);
 	kref_get(&vlan->refcount);
 	hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list);
 	spin_unlock_bh(&bat_priv->softif_vlan_list_lock);
 	/* batadv_sysfs_add_vlan cannot be in the spinlock section due to the
 	 * sleeping behavior of the sysfs functions and the fs_reclaim lock
 	 */
 	err = batadv_sysfs_add_vlan(bat_priv->soft_iface, vlan);
 	if (err) {
 		/* ref for the function */
 		batadv_softif_vlan_put(vlan);
 		/* ref for the list */
 		batadv_softif_vlan_put(vlan);
 		return err;
 	}
 	/* add a new TT local entry. This one will be marked with the NOPURGE
 	 * flag
 	 */
 	batadv_tt_local_add(bat_priv->soft_iface,
 			    bat_priv->soft_iface->dev_addr, vid,
 			    BATADV_NULL_IFINDEX, BATADV_NO_MARK);
 	/* don't return reference to new softif_vlan */
 	batadv_softif_vlan_put(vlan);
 	return 0;
 }
 /**
  * batadv_softif_destroy_vlan() - remove and destroy a softif_vlan object
  * @bat_priv: the bat priv with all the soft interface information
  * @vlan: the object to remove
  */
 static void batadv_softif_destroy_vlan(struct batadv_priv *bat_priv,
 				       struct batadv_softif_vlan *vlan)
 {
 	/* explicitly remove the associated TT local entry because it is marked
 	 * with the NOPURGE flag
 	 */
 	batadv_tt_local_remove(bat_priv, bat_priv->soft_iface->dev_addr,
 			       vlan->vid, "vlan interface destroyed", false);
 	batadv_sysfs_del_vlan(bat_priv, vlan);
 	batadv_softif_vlan_put(vlan);
 }
 /**
  * batadv_interface_add_vid() - ndo_add_vid API implementation
  * @dev: the netdev of the mesh interface
  * @proto: protocol of the the vlan id
  * @vid: identifier of the new vlan
  *
  * Set up all the internal structures for handling the new vlan on top of the
  * mesh interface
  *
  * Return: 0 on success or a negative error code in case of failure.
  */
 static int batadv_interface_add_vid(struct net_device *dev, __be16 proto,
 				    unsigned short vid)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct batadv_softif_vlan *vlan;
 	int ret;
 	/* only 802.1Q vlans are supported.
 	 * batman-adv does not know how to handle other types
 	 */
 	if (proto != htons(ETH_P_8021Q))
 		return -EINVAL;
 	vid |= BATADV_VLAN_HAS_TAG;
 	/* if a new vlan is getting created and it already exists, it means that
 	 * it was not deleted yet. batadv_softif_vlan_get() increases the
 	 * refcount in order to revive the object.
 	 *
 	 * if it does not exist then create it.
 	 */
 	vlan = batadv_softif_vlan_get(bat_priv, vid);
 	if (!vlan)
 		return batadv_softif_create_vlan(bat_priv, vid);
 	/* recreate the sysfs object if it was already destroyed (and it should
 	 * be since we received a kill_vid() for this vlan
 	 */
 	if (!vlan->kobj) {
 		ret = batadv_sysfs_add_vlan(bat_priv->soft_iface, vlan);
 		if (ret) {
 			batadv_softif_vlan_put(vlan);
 			return ret;
 		}
 	}
 	/* add a new TT local entry. This one will be marked with the NOPURGE
 	 * flag. This must be added again, even if the vlan object already
 	 * exists, because the entry was deleted by kill_vid()
 	 */
 	batadv_tt_local_add(bat_priv->soft_iface,
 			    bat_priv->soft_iface->dev_addr, vid,
 			    BATADV_NULL_IFINDEX, BATADV_NO_MARK);
 	return 0;
 }
 /**
  * batadv_interface_kill_vid() - ndo_kill_vid API implementation
  * @dev: the netdev of the mesh interface
  * @proto: protocol of the the vlan id
  * @vid: identifier of the deleted vlan
  *
  * Destroy all the internal structures used to handle the vlan identified by vid
  * on top of the mesh interface
  *
  * Return: 0 on success, -EINVAL if the specified prototype is not ETH_P_8021Q
  * or -ENOENT if the specified vlan id wasn't registered.
  */
 static int batadv_interface_kill_vid(struct net_device *dev, __be16 proto,
 				     unsigned short vid)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct batadv_softif_vlan *vlan;
 	/* only 802.1Q vlans are supported. batman-adv does not know how to
 	 * handle other types
 	 */
 	if (proto != htons(ETH_P_8021Q))
 		return -EINVAL;
 	vlan = batadv_softif_vlan_get(bat_priv, vid | BATADV_VLAN_HAS_TAG);
 	if (!vlan)
 		return -ENOENT;
 	batadv_softif_destroy_vlan(bat_priv, vlan);
 	/* finally free the vlan object */
 	batadv_softif_vlan_put(vlan);
 	return 0;
 }
 /* batman-adv network devices have devices nesting below it and are a special
  * "super class" of normal network devices; split their locks off into a
  * separate class since they always nest.
  */
 static struct lock_class_key batadv_netdev_xmit_lock_key;
 static struct lock_class_key batadv_netdev_addr_lock_key;
 /**
  * batadv_set_lockdep_class_one() - Set lockdep class for a single tx queue
  * @dev: device which owns the tx queue
  * @txq: tx queue to modify
  * @_unused: always NULL
  */
 static void batadv_set_lockdep_class_one(struct net_device *dev,
 					 struct netdev_queue *txq,
 					 void *_unused)
 {
 	lockdep_set_class(&txq->_xmit_lock, &batadv_netdev_xmit_lock_key);
 }
 /**
  * batadv_set_lockdep_class() - Set txq and addr_list lockdep class
  * @dev: network device to modify
  */
 static void batadv_set_lockdep_class(struct net_device *dev)
 {
 	lockdep_set_class(&dev->addr_list_lock, &batadv_netdev_addr_lock_key);
 	netdev_for_each_tx_queue(dev, batadv_set_lockdep_class_one, NULL);
 }
 /**
  * batadv_softif_init_late() - late stage initialization of soft interface
  * @dev: registered network device to modify
  *
  * Return: error code on failures
  */
 static int batadv_softif_init_late(struct net_device *dev)
 {
 	struct batadv_priv *bat_priv;
 	u32 random_seqno;
 	int ret;
 	size_t cnt_len = sizeof(u64) * BATADV_CNT_NUM;
 	batadv_set_lockdep_class(dev);
 	bat_priv = netdev_priv(dev);
 	bat_priv->soft_iface = dev;
 	/* batadv_interface_stats() needs to be available as soon as
 	 * register_netdevice() has been called
 	 */
 	bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(u64));
 	if (!bat_priv->bat_counters)
 		return -ENOMEM;
 	atomic_set(&bat_priv->aggregated_ogms, 1);
 	atomic_set(&bat_priv->bonding, 0);
 #ifdef CONFIG_BATMAN_ADV_BLA
 	atomic_set(&bat_priv->bridge_loop_avoidance, 1);
 #endif
 #ifdef CONFIG_BATMAN_ADV_DAT
 	atomic_set(&bat_priv->distributed_arp_table, 1);
 #endif
 #ifdef CONFIG_BATMAN_ADV_MCAST
 	bat_priv->mcast.querier_ipv4.exists = false;
 	bat_priv->mcast.querier_ipv4.shadowing = false;
 	bat_priv->mcast.querier_ipv6.exists = false;
 	bat_priv->mcast.querier_ipv6.shadowing = false;
 	bat_priv->mcast.flags = BATADV_NO_FLAGS;
 	atomic_set(&bat_priv->multicast_mode, 1);
 	atomic_set(&bat_priv->mcast.num_want_all_unsnoopables, 0);
 	atomic_set(&bat_priv->mcast.num_want_all_ipv4, 0);
 	atomic_set(&bat_priv->mcast.num_want_all_ipv6, 0);
 #endif
 	atomic_set(&bat_priv->gw.mode, BATADV_GW_MODE_OFF);
 	atomic_set(&bat_priv->gw.bandwidth_down, 100);
 	atomic_set(&bat_priv->gw.bandwidth_up, 20);
 	atomic_set(&bat_priv->orig_interval, 1000);
 	atomic_set(&bat_priv->hop_penalty, 30);
 #ifdef CONFIG_BATMAN_ADV_DEBUG
 	atomic_set(&bat_priv->log_level, 0);
 #endif
 	atomic_set(&bat_priv->fragmentation, 1);
 	atomic_set(&bat_priv->packet_size_max, ETH_DATA_LEN);
 	atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN);
 	atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN);
 	atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
 	atomic_set(&bat_priv->bcast_seqno, 1);
 	atomic_set(&bat_priv->tt.vn, 0);
 	atomic_set(&bat_priv->tt.local_changes, 0);
 	atomic_set(&bat_priv->tt.ogm_append_cnt, 0);
 #ifdef CONFIG_BATMAN_ADV_BLA
 	atomic_set(&bat_priv->bla.num_requests, 0);
 #endif
 	atomic_set(&bat_priv->tp_num, 0);
 	bat_priv->tt.last_changeset = NULL;
 	bat_priv->tt.last_changeset_len = 0;
 	bat_priv->isolation_mark = 0;
 	bat_priv->isolation_mark_mask = 0;
 	/* randomize initial seqno to avoid collision */
 	get_random_bytes(&random_seqno, sizeof(random_seqno));
 	atomic_set(&bat_priv->frag_seqno, random_seqno);
 	bat_priv->primary_if = NULL;
 	batadv_nc_init_bat_priv(bat_priv);
 	ret = batadv_algo_select(bat_priv, batadv_routing_algo);
 	if (ret < 0)
 		goto free_bat_counters;
 	ret = batadv_debugfs_add_meshif(dev);
 	if (ret < 0)
 		goto free_bat_counters;
 	ret = batadv_mesh_init(dev);
 	if (ret < 0)
 		goto unreg_debugfs;
 	return 0;
 unreg_debugfs:
 	batadv_debugfs_del_meshif(dev);
 free_bat_counters:
 	free_percpu(bat_priv->bat_counters);
 	bat_priv->bat_counters = NULL;
 	return ret;
 }
 /**
  * batadv_softif_slave_add() - Add a slave interface to a batadv_soft_interface
  * @dev: batadv_soft_interface used as master interface
  * @slave_dev: net_device which should become the slave interface
  * @extack: extended ACK report struct
  *
  * Return: 0 if successful or error otherwise.
  */
 static int batadv_softif_slave_add(struct net_device *dev,
 				   struct net_device *slave_dev,
 				   struct netlink_ext_ack *extack)
 {
 	struct batadv_hard_iface *hard_iface;
 	struct net *net = dev_net(dev);
 	int ret = -EINVAL;
 	hard_iface = batadv_hardif_get_by_netdev(slave_dev);
 	if (!hard_iface || hard_iface->soft_iface)
 		goto out;
 	ret = batadv_hardif_enable_interface(hard_iface, net, dev->name);
 out:
 	if (hard_iface)
 		batadv_hardif_put(hard_iface);
 	return ret;
 }
 /**
  * batadv_softif_slave_del() - Delete a slave iface from a batadv_soft_interface
  * @dev: batadv_soft_interface used as master interface
  * @slave_dev: net_device which should be removed from the master interface
  *
  * Return: 0 if successful or error otherwise.
  */
 static int batadv_softif_slave_del(struct net_device *dev,
 				   struct net_device *slave_dev)
 {
 	struct batadv_hard_iface *hard_iface;
 	int ret = -EINVAL;
 	hard_iface = batadv_hardif_get_by_netdev(slave_dev);
 	if (!hard_iface || hard_iface->soft_iface != dev)
 		goto out;
 	batadv_hardif_disable_interface(hard_iface, BATADV_IF_CLEANUP_KEEP);
 	ret = 0;
 out:
 	if (hard_iface)
 		batadv_hardif_put(hard_iface);
 	return ret;
 }
 static const struct net_device_ops batadv_netdev_ops = {
 	.ndo_init = batadv_softif_init_late,
 	.ndo_open = batadv_interface_open,
 	.ndo_stop = batadv_interface_release,
 	.ndo_get_stats = batadv_interface_stats,
 	.ndo_vlan_rx_add_vid = batadv_interface_add_vid,
 	.ndo_vlan_rx_kill_vid = batadv_interface_kill_vid,
 	.ndo_set_mac_address = batadv_interface_set_mac_addr,
 	.ndo_change_mtu = batadv_interface_change_mtu,
 	.ndo_set_rx_mode = batadv_interface_set_rx_mode,
 	.ndo_start_xmit = batadv_interface_tx,
 	.ndo_validate_addr = eth_validate_addr,
 	.ndo_add_slave = batadv_softif_slave_add,
 	.ndo_del_slave = batadv_softif_slave_del,
 };
 static void batadv_get_drvinfo(struct net_device *dev,
 			       struct ethtool_drvinfo *info)
 {
 	strlcpy(info->driver, "B.A.T.M.A.N. advanced", sizeof(info->driver));
 	strlcpy(info->version, BATADV_SOURCE_VERSION, sizeof(info->version));
 	strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
 	strlcpy(info->bus_info, "batman", sizeof(info->bus_info));
 }
 /* Inspired by drivers/net/ethernet/dlink/sundance.c:1702
  * Declare each description string in struct.name[] to get fixed sized buffer
  * and compile time checking for strings longer than ETH_GSTRING_LEN.
  */
 static const struct {
 	const char name[ETH_GSTRING_LEN];
 } batadv_counters_strings[] = {
 	{ "tx" },
 	{ "tx_bytes" },
 	{ "tx_dropped" },
 	{ "rx" },
 	{ "rx_bytes" },
 	{ "forward" },
 	{ "forward_bytes" },
 	{ "mgmt_tx" },
 	{ "mgmt_tx_bytes" },
 	{ "mgmt_rx" },
 	{ "mgmt_rx_bytes" },
 	{ "frag_tx" },
 	{ "frag_tx_bytes" },
 	{ "frag_rx" },
 	{ "frag_rx_bytes" },
 	{ "frag_fwd" },
 	{ "frag_fwd_bytes" },
 	{ "tt_request_tx" },
 	{ "tt_request_rx" },
 	{ "tt_response_tx" },
 	{ "tt_response_rx" },
 	{ "tt_roam_adv_tx" },
 	{ "tt_roam_adv_rx" },
 #ifdef CONFIG_BATMAN_ADV_DAT
 	{ "dat_get_tx" },
 	{ "dat_get_rx" },
 	{ "dat_put_tx" },
 	{ "dat_put_rx" },
 	{ "dat_cached_reply_tx" },
 #endif
 #ifdef CONFIG_BATMAN_ADV_NC
 	{ "nc_code" },
 	{ "nc_code_bytes" },
 	{ "nc_recode" },
 	{ "nc_recode_bytes" },
 	{ "nc_buffer" },
 	{ "nc_decode" },
 	{ "nc_decode_bytes" },
 	{ "nc_decode_failed" },
 	{ "nc_sniffed" },
 #endif
 };
 static void batadv_get_strings(struct net_device *dev, u32 stringset, u8 *data)
 {
 	if (stringset == ETH_SS_STATS)
 		memcpy(data, batadv_counters_strings,
 		       sizeof(batadv_counters_strings));
 }
 static void batadv_get_ethtool_stats(struct net_device *dev,
 				     struct ethtool_stats *stats, u64 *data)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	int i;
 	for (i = 0; i < BATADV_CNT_NUM; i++)
 		data[i] = batadv_sum_counter(bat_priv, i);
 }
 static int batadv_get_sset_count(struct net_device *dev, int stringset)
 {
 	if (stringset == ETH_SS_STATS)
 		return BATADV_CNT_NUM;
 	return -EOPNOTSUPP;
 }
 static const struct ethtool_ops batadv_ethtool_ops = {
 	.get_drvinfo = batadv_get_drvinfo,
 	.get_link = ethtool_op_get_link,
 	.get_strings = batadv_get_strings,
 	.get_ethtool_stats = batadv_get_ethtool_stats,
 	.get_sset_count = batadv_get_sset_count,
 };
 /**
  * batadv_softif_free() - Deconstructor of batadv_soft_interface
  * @dev: Device to cleanup and remove
  */
 static void batadv_softif_free(struct net_device *dev)
 {
 	batadv_debugfs_del_meshif(dev);
 	batadv_mesh_free(dev);
 	/* some scheduled RCU callbacks need the bat_priv struct to accomplish
 	 * their tasks. Wait for them all to be finished before freeing the
 	 * netdev and its private data (bat_priv)
 	 */
 	rcu_barrier();
 }
 /**
  * batadv_softif_init_early() - early stage initialization of soft interface
  * @dev: registered network device to modify
  */
 static void batadv_softif_init_early(struct net_device *dev)
 {
 	ether_setup(dev);
 	dev->netdev_ops = &batadv_netdev_ops;
 	dev->needs_free_netdev = true;
 	dev->priv_destructor = batadv_softif_free;
 	dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_NETNS_LOCAL;
 	dev->features |= NETIF_F_LLTX;
 	dev->priv_flags |= IFF_NO_QUEUE;
 	/* can't call min_mtu, because the needed variables
 	 * have not been initialized yet
 	 */
 	dev->mtu = ETH_DATA_LEN;
 	/* generate random address */
 	eth_hw_addr_random(dev);
 	dev->ethtool_ops = &batadv_ethtool_ops;
 }
 /**
  * batadv_softif_create() - Create and register soft interface
  * @net: the applicable net namespace
  * @name: name of the new soft interface
  *
  * Return: newly allocated soft_interface, NULL on errors
  */
 struct net_device *batadv_softif_create(struct net *net, const char *name)
 {
 	struct net_device *soft_iface;
 	int ret;
 	soft_iface = alloc_netdev(sizeof(struct batadv_priv), name,
 				  NET_NAME_UNKNOWN, batadv_softif_init_early);
 	if (!soft_iface)
 		return NULL;
 	dev_net_set(soft_iface, net);
 	soft_iface->rtnl_link_ops = &batadv_link_ops;
 	ret = register_netdevice(soft_iface);
 	if (ret < 0) {
 		pr_err("Unable to register the batman interface '%s': %i\n",
 		       name, ret);
 		free_netdev(soft_iface);
 		return NULL;
 	}
 	return soft_iface;
 }
 /**
  * batadv_softif_destroy_sysfs() - deletion of batadv_soft_interface via sysfs
  * @soft_iface: the to-be-removed batman-adv interface
  */
 void batadv_softif_destroy_sysfs(struct net_device *soft_iface)
 {
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct batadv_softif_vlan *vlan;
 	ASSERT_RTNL();
 	/* destroy the "untagged" VLAN */
 	vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
 	if (vlan) {
 		batadv_softif_destroy_vlan(bat_priv, vlan);
 		batadv_softif_vlan_put(vlan);
 	}
 	batadv_sysfs_del_meshif(soft_iface);
 	unregister_netdevice(soft_iface);
 }
 /**
  * batadv_softif_destroy_netlink() - deletion of batadv_soft_interface via
  *  netlink
  * @soft_iface: the to-be-removed batman-adv interface
  * @head: list pointer
  */
 static void batadv_softif_destroy_netlink(struct net_device *soft_iface,
 					  struct list_head *head)
 {
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct batadv_hard_iface *hard_iface;
 	struct batadv_softif_vlan *vlan;
 	list_for_each_entry(hard_iface, &batadv_hardif_list, list) {
 		if (hard_iface->soft_iface == soft_iface)
 			batadv_hardif_disable_interface(hard_iface,
 							BATADV_IF_CLEANUP_KEEP);
 	}
 	/* destroy the "untagged" VLAN */
 	vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS);
 	if (vlan) {
 		batadv_softif_destroy_vlan(bat_priv, vlan);
 		batadv_softif_vlan_put(vlan);
 	}
 	batadv_sysfs_del_meshif(soft_iface);
 	unregister_netdevice_queue(soft_iface, head);
 }
 /**
  * batadv_softif_is_valid() - Check whether device is a batadv soft interface
  * @net_dev: device which should be checked
  *
  * Return: true when net_dev is a batman-adv interface, false otherwise
  */
 bool batadv_softif_is_valid(const struct net_device *net_dev)
 {
 	if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)
 		return true;
 	return false;
 }
 struct rtnl_link_ops batadv_link_ops __read_mostly = {
 	.kind		= "batadv",
 	.priv_size	= sizeof(struct batadv_priv),
 	.setup		= batadv_softif_init_early,
 	.dellink	= batadv_softif_destroy_netlink,
 };

net/batman-adv/sysfs.c

Diff comments View file @ e2d0d35

 // SPDX-License-Identifier: GPL-2.0
 /* Copyright (C) 2010-2019  B.A.T.M.A.N. contributors:
  *
  * Marek Lindner
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 #include "sysfs.h"
 #include "main.h"
 #include <linux/atomic.h>
 #include <linux/compiler.h>
 #include <linux/device.h>
 #include <linux/errno.h>
 #include <linux/gfp.h>
 #include <linux/if.h>
 #include <linux/if_vlan.h>
 #include <linux/kernel.h>
 #include <linux/kobject.h>
 #include <linux/kref.h>
 #include <linux/netdevice.h>
 #include <linux/printk.h>
 #include <linux/rculist.h>
 #include <linux/rcupdate.h>
 #include <linux/rtnetlink.h>
 #include <linux/slab.h>
 #include <linux/stddef.h>
 #include <linux/string.h>
 #include <linux/stringify.h>
 #include <linux/workqueue.h>
 #include <uapi/linux/batadv_packet.h>
+#include <uapi/linux/batman_adv.h>
 #include "bridge_loop_avoidance.h"
 #include "distributed-arp-table.h"
 #include "gateway_client.h"
 #include "gateway_common.h"
 #include "hard-interface.h"
 #include "log.h"
 #include "network-coding.h"
 #include "soft-interface.h"
 static struct net_device *batadv_kobj_to_netdev(struct kobject *obj)
 {
 	struct device *dev = container_of(obj->parent, struct device, kobj);
 	return to_net_dev(dev);
 }
 static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(obj);
 	return netdev_priv(net_dev);
 }
 /**
  * batadv_vlan_kobj_to_batpriv() - convert a vlan kobj in the associated batpriv
  * @obj: kobject to covert
  *
  * Return: the associated batadv_priv struct.
  */
 static struct batadv_priv *batadv_vlan_kobj_to_batpriv(struct kobject *obj)
 {
 	/* VLAN specific attributes are located in the root sysfs folder if they
 	 * refer to the untagged VLAN..
 	 */
 	if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR, obj->name))
 		return batadv_kobj_to_batpriv(obj);
 	/* ..while the attributes for the tagged vlans are located in
 	 * the in the corresponding "vlan%VID" subfolder
 	 */
 	return batadv_kobj_to_batpriv(obj->parent);
 }
 /**
  * batadv_kobj_to_vlan() - convert a kobj in the associated softif_vlan struct
  * @bat_priv: the bat priv with all the soft interface information
  * @obj: kobject to covert
  *
  * Return: the associated softif_vlan struct if found, NULL otherwise.
  */
 static struct batadv_softif_vlan *
 batadv_kobj_to_vlan(struct batadv_priv *bat_priv, struct kobject *obj)
 {
 	struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
 	rcu_read_lock();
 	hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
 		if (vlan_tmp->kobj != obj)
 			continue;
 		if (!kref_get_unless_zero(&vlan_tmp->refcount))
 			continue;
 		vlan = vlan_tmp;
 		break;
 	}
 	rcu_read_unlock();
 	return vlan;
 }
 #define BATADV_UEV_TYPE_VAR	"BATTYPE="
 #define BATADV_UEV_ACTION_VAR	"BATACTION="
 #define BATADV_UEV_DATA_VAR	"BATDATA="
 static char *batadv_uev_action_str[] = {
 	"add",
 	"del",
 	"change",
 	"loopdetect",
 };
 static char *batadv_uev_type_str[] = {
 	"gw",
 	"bla",
 };
 /* Use this, if you have customized show and store functions for vlan attrs */
 #define BATADV_ATTR_VLAN(_name, _mode, _show, _store)	\
 struct batadv_attribute batadv_attr_vlan_##_name = {	\
 	.attr = {.name = __stringify(_name),		\
 		 .mode = _mode },			\
 	.show   = _show,				\
 	.store  = _store,				\
 }
 /* Use this, if you have customized show and store functions */
 #define BATADV_ATTR(_name, _mode, _show, _store)	\
 struct batadv_attribute batadv_attr_##_name = {		\
 	.attr = {.name = __stringify(_name),		\
 		 .mode = _mode },			\
 	.show   = _show,				\
 	.store  = _store,				\
 }
 #define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func)			\
 ssize_t batadv_store_##_name(struct kobject *kobj,			\
 			     struct attribute *attr, char *buff,	\
 			     size_t count)				\
 {									\
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);	\
 	struct batadv_priv *bat_priv = netdev_priv(net_dev);		\
 									\
 	return __batadv_store_bool_attr(buff, count, _post_func, attr,	\
 					&bat_priv->_name, net_dev);	\
 }
 #define BATADV_ATTR_SIF_SHOW_BOOL(_name)				\
 ssize_t batadv_show_##_name(struct kobject *kobj,			\
 			    struct attribute *attr, char *buff)		\
 {									\
 	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);	\
 									\
 	return sprintf(buff, "%s\n",					\
 		       atomic_read(&bat_priv->_name) == 0 ?		\
 		       "disabled" : "enabled");				\
 }									\
 /* Use this, if you are going to turn a [name] in the soft-interface
  * (bat_priv) on or off
  */
 #define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func)			\
 	static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func)		\
 	static BATADV_ATTR_SIF_SHOW_BOOL(_name)				\
 	static BATADV_ATTR(_name, _mode, batadv_show_##_name,		\
 			   batadv_store_##_name)
 #define BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func)	\
 ssize_t batadv_store_##_name(struct kobject *kobj,			\
 			     struct attribute *attr, char *buff,	\
 			     size_t count)				\
 {									\
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);	\
 	struct batadv_priv *bat_priv = netdev_priv(net_dev);		\
 									\
 	return __batadv_store_uint_attr(buff, count, _min, _max,	\
 					_post_func, attr,		\
 					&bat_priv->_var, net_dev,	\
 					NULL);	\
 }
 #define BATADV_ATTR_SIF_SHOW_UINT(_name, _var)				\
 ssize_t batadv_show_##_name(struct kobject *kobj,			\
 			    struct attribute *attr, char *buff)		\
 {									\
 	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);	\
 									\
 	return sprintf(buff, "%i\n", atomic_read(&bat_priv->_var));	\
 }									\
 /* Use this, if you are going to set [name] in the soft-interface
  * (bat_priv) to an unsigned integer value
  */
 #define BATADV_ATTR_SIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
 	static BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func)\
 	static BATADV_ATTR_SIF_SHOW_UINT(_name, _var)			\
 	static BATADV_ATTR(_name, _mode, batadv_show_##_name,		\
 			   batadv_store_##_name)
 #define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func)			\
 ssize_t batadv_store_vlan_##_name(struct kobject *kobj,			\
 				  struct attribute *attr, char *buff,	\
 				  size_t count)				\
 {									\
 	struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
 	struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv,	\
 							      kobj);	\
 	size_t res = __batadv_store_bool_attr(buff, count, _post_func,	\
 					      attr, &vlan->_name,	\
 					      bat_priv->soft_iface);	\
 									\
 	batadv_softif_vlan_put(vlan);					\
 	return res;							\
 }
 #define BATADV_ATTR_VLAN_SHOW_BOOL(_name)				\
 ssize_t batadv_show_vlan_##_name(struct kobject *kobj,			\
 				 struct attribute *attr, char *buff)	\
 {									\
 	struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
 	struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv,	\
 							      kobj);	\
 	size_t res = sprintf(buff, "%s\n",				\
 			     atomic_read(&vlan->_name) == 0 ?		\
 			     "disabled" : "enabled");			\
 									\
 	batadv_softif_vlan_put(vlan);					\
 	return res;							\
 }
 /* Use this, if you are going to turn a [name] in the vlan struct on or off */
 #define BATADV_ATTR_VLAN_BOOL(_name, _mode, _post_func)			\
 	static BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func)		\
 	static BATADV_ATTR_VLAN_SHOW_BOOL(_name)			\
 	static BATADV_ATTR_VLAN(_name, _mode, batadv_show_vlan_##_name,	\
 				batadv_store_vlan_##_name)
 #define BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min, _max, _post_func)	\
 ssize_t batadv_store_##_name(struct kobject *kobj,			\
 			     struct attribute *attr, char *buff,	\
 			     size_t count)				\
 {									\
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);	\
 	struct batadv_hard_iface *hard_iface;				\
 	ssize_t length;							\
 									\
 	hard_iface = batadv_hardif_get_by_netdev(net_dev);		\
 	if (!hard_iface)						\
 		return 0;						\
 									\
 	length = __batadv_store_uint_attr(buff, count, _min, _max,	\
 					  _post_func, attr,		\
 					  &hard_iface->_var,		\
 					  hard_iface->soft_iface,	\
 					  net_dev);			\
 									\
 	batadv_hardif_put(hard_iface);				\
 	return length;							\
 }
 #define BATADV_ATTR_HIF_SHOW_UINT(_name, _var)				\
 ssize_t batadv_show_##_name(struct kobject *kobj,			\
 			    struct attribute *attr, char *buff)		\
 {									\
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);	\
 	struct batadv_hard_iface *hard_iface;				\
 	ssize_t length;							\
 									\
 	hard_iface = batadv_hardif_get_by_netdev(net_dev);		\
 	if (!hard_iface)						\
 		return 0;						\
 									\
 	length = sprintf(buff, "%i\n", atomic_read(&hard_iface->_var));	\
 									\
 	batadv_hardif_put(hard_iface);				\
 	return length;							\
 }
 /* Use this, if you are going to set [name] in hard_iface to an
  * unsigned integer value
  */
 #define BATADV_ATTR_HIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
 	static BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min,		\
 					  _max, _post_func)		\
 	static BATADV_ATTR_HIF_SHOW_UINT(_name, _var)			\
 	static BATADV_ATTR(_name, _mode, batadv_show_##_name,		\
 			   batadv_store_##_name)
 static int batadv_store_bool_attr(char *buff, size_t count,
 				  struct net_device *net_dev,
 				  const char *attr_name, atomic_t *attr,
 				  bool *changed)
 {
 	int enabled = -1;
 	*changed = false;
 	if (buff[count - 1] == '\n')
 		buff[count - 1] = '\0';
 	if ((strncmp(buff, "1", 2) == 0) ||
 	    (strncmp(buff, "enable", 7) == 0) ||
 	    (strncmp(buff, "enabled", 8) == 0))
 		enabled = 1;
 	if ((strncmp(buff, "0", 2) == 0) ||
 	    (strncmp(buff, "disable", 8) == 0) ||
 	    (strncmp(buff, "disabled", 9) == 0))
 		enabled = 0;
 	if (enabled < 0) {
 		batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
 			    attr_name, buff);
 		return -EINVAL;
 	}
 	if (atomic_read(attr) == enabled)
 		return count;
 	batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
 		    atomic_read(attr) == 1 ? "enabled" : "disabled",
 		    enabled == 1 ? "enabled" : "disabled");
 	*changed = true;
 	atomic_set(attr, (unsigned int)enabled);
 	return count;
 }
 static inline ssize_t
 __batadv_store_bool_attr(char *buff, size_t count,
 			 void (*post_func)(struct net_device *),
 			 struct attribute *attr,
 			 atomic_t *attr_store, struct net_device *net_dev)
 {
 	bool changed;
 	int ret;
 	ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
 				     attr_store, &changed);
 	if (post_func && changed)
 		post_func(net_dev);
 	return ret;
 }
 static int batadv_store_uint_attr(const char *buff, size_t count,
 				  struct net_device *net_dev,
 				  struct net_device *slave_dev,
 				  const char *attr_name,
 				  unsigned int min, unsigned int max,
 				  atomic_t *attr)
 {
 	char ifname[IFNAMSIZ + 3] = "";
 	unsigned long uint_val;
 	int ret;
 	ret = kstrtoul(buff, 10, &uint_val);
 	if (ret) {
 		batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
 			    attr_name, buff);
 		return -EINVAL;
 	}
 	if (uint_val < min) {
 		batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
 			    attr_name, uint_val, min);
 		return -EINVAL;
 	}
 	if (uint_val > max) {
 		batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
 			    attr_name, uint_val, max);
 		return -EINVAL;
 	}
 	if (atomic_read(attr) == uint_val)
 		return count;
 	if (slave_dev)
 		snprintf(ifname, sizeof(ifname), "%s: ", slave_dev->name);
 	batadv_info(net_dev, "%s: %sChanging from: %i to: %lu\n",
 		    attr_name, ifname, atomic_read(attr), uint_val);
 	atomic_set(attr, uint_val);
 	return count;
 }
 static ssize_t __batadv_store_uint_attr(const char *buff, size_t count,
 					int min, int max,
 					void (*post_func)(struct net_device *),
 					const struct attribute *attr,
 					atomic_t *attr_store,
 					struct net_device *net_dev,
 					struct net_device *slave_dev)
 {
 	int ret;
 	ret = batadv_store_uint_attr(buff, count, net_dev, slave_dev,
 				     attr->name, min, max, attr_store);
 	if (post_func && ret)
 		post_func(net_dev);
 	return ret;
 }
 static ssize_t batadv_show_bat_algo(struct kobject *kobj,
 				    struct attribute *attr, char *buff)
 {
 	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 	return sprintf(buff, "%s\n", bat_priv->algo_ops->name);
 }
 static void batadv_post_gw_reselect(struct net_device *net_dev)
 {
 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
 	batadv_gw_reselect(bat_priv);
 }
 static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
 				   char *buff)
 {
 	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 	int bytes_written;
 	/* GW mode is not available if the routing algorithm in use does not
 	 * implement the GW API
 	 */
 	if (!bat_priv->algo_ops->gw.get_best_gw_node ||
 	    !bat_priv->algo_ops->gw.is_eligible)
 		return -ENOENT;
 	switch (atomic_read(&bat_priv->gw.mode)) {
 	case BATADV_GW_MODE_CLIENT:
 		bytes_written = sprintf(buff, "%s\n",
 					BATADV_GW_MODE_CLIENT_NAME);
 		break;
 	case BATADV_GW_MODE_SERVER:
 		bytes_written = sprintf(buff, "%s\n",
 					BATADV_GW_MODE_SERVER_NAME);
 		break;
 	default:
 		bytes_written = sprintf(buff, "%s\n",
 					BATADV_GW_MODE_OFF_NAME);
 		break;
 	}
 	return bytes_written;
 }
 static ssize_t batadv_store_gw_mode(struct kobject *kobj,
 				    struct attribute *attr, char *buff,
 				    size_t count)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
 	char *curr_gw_mode_str;
 	int gw_mode_tmp = -1;
 	/* toggling GW mode is allowed only if the routing algorithm in use
 	 * provides the GW API
 	 */
 	if (!bat_priv->algo_ops->gw.get_best_gw_node ||
 	    !bat_priv->algo_ops->gw.is_eligible)
 		return -EINVAL;
 	if (buff[count - 1] == '\n')
 		buff[count - 1] = '\0';
 	if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
 		    strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
 		gw_mode_tmp = BATADV_GW_MODE_OFF;
 	if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
 		    strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
 		gw_mode_tmp = BATADV_GW_MODE_CLIENT;
 	if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
 		    strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
 		gw_mode_tmp = BATADV_GW_MODE_SERVER;
 	if (gw_mode_tmp < 0) {
 		batadv_info(net_dev,
 			    "Invalid parameter for 'gw mode' setting received: %s\n",
 			    buff);
 		return -EINVAL;
 	}
 	if (atomic_read(&bat_priv->gw.mode) == gw_mode_tmp)
 		return count;
 	switch (atomic_read(&bat_priv->gw.mode)) {
 	case BATADV_GW_MODE_CLIENT:
 		curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
 		break;
 	case BATADV_GW_MODE_SERVER:
 		curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
 		break;
 	default:
 		curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
 		break;
 	}
 	batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
 		    curr_gw_mode_str, buff);
 	/* Invoking batadv_gw_reselect() is not enough to really de-select the
 	 * current GW. It will only instruct the gateway client code to perform
 	 * a re-election the next time that this is needed.
 	 *
 	 * When gw client mode is being switched off the current GW must be
 	 * de-selected explicitly otherwise no GW_ADD uevent is thrown on
 	 * client mode re-activation. This is operation is performed in
 	 * batadv_gw_check_client_stop().
 	 */
 	batadv_gw_reselect(bat_priv);
 	/* always call batadv_gw_check_client_stop() before changing the gateway
 	 * state
 	 */
 	batadv_gw_check_client_stop(bat_priv);
 	atomic_set(&bat_priv->gw.mode, (unsigned int)gw_mode_tmp);
 	batadv_gw_tvlv_container_update(bat_priv);
 	return count;
 }
 static ssize_t batadv_show_gw_sel_class(struct kobject *kobj,
 					struct attribute *attr, char *buff)
 {
 	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 	/* GW selection class is not available if the routing algorithm in use
 	 * does not implement the GW API
 	 */
 	if (!bat_priv->algo_ops->gw.get_best_gw_node ||
 	    !bat_priv->algo_ops->gw.is_eligible)
 		return -ENOENT;
 	if (bat_priv->algo_ops->gw.show_sel_class)
 		return bat_priv->algo_ops->gw.show_sel_class(bat_priv, buff);
 	return sprintf(buff, "%i\n", atomic_read(&bat_priv->gw.sel_class));
 }
 static ssize_t batadv_store_gw_sel_class(struct kobject *kobj,
 					 struct attribute *attr, char *buff,
 					 size_t count)
 {
 	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 	/* setting the GW selection class is allowed only if the routing
 	 * algorithm in use implements the GW API
 	 */
 	if (!bat_priv->algo_ops->gw.get_best_gw_node ||
 	    !bat_priv->algo_ops->gw.is_eligible)
 		return -EINVAL;
 	if (buff[count - 1] == '\n')
 		buff[count - 1] = '\0';
 	if (bat_priv->algo_ops->gw.store_sel_class)
 		return bat_priv->algo_ops->gw.store_sel_class(bat_priv, buff,
 							      count);
 	return __batadv_store_uint_attr(buff, count, 1, BATADV_TQ_MAX_VALUE,
 					batadv_post_gw_reselect, attr,
 					&bat_priv->gw.sel_class,
 					bat_priv->soft_iface, NULL);
 }
 static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
 				     struct attribute *attr, char *buff)
 {
 	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 	u32 down, up;
 	down = atomic_read(&bat_priv->gw.bandwidth_down);
 	up = atomic_read(&bat_priv->gw.bandwidth_up);
 	return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
 		       down % 10, up / 10, up % 10);
 }
 static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
 				      struct attribute *attr, char *buff,
 				      size_t count)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	if (buff[count - 1] == '\n')
 		buff[count - 1] = '\0';
 	return batadv_gw_bandwidth_set(net_dev, buff, count);
 }
 /**
  * batadv_show_isolation_mark() - print the current isolation mark/mask
  * @kobj: kobject representing the private mesh sysfs directory
  * @attr: the batman-adv attribute the user is interacting with
  * @buff: the buffer that will contain the data to send back to the user
  *
  * Return: the number of bytes written into 'buff' on success or a negative
  * error code in case of failure
  */
 static ssize_t batadv_show_isolation_mark(struct kobject *kobj,
 					  struct attribute *attr, char *buff)
 {
 	struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 	return sprintf(buff, "%#.8x/%#.8x\n", bat_priv->isolation_mark,
 		       bat_priv->isolation_mark_mask);
 }
 /**
  * batadv_store_isolation_mark() - parse and store the isolation mark/mask
  *  entered by the user
  * @kobj: kobject representing the private mesh sysfs directory
  * @attr: the batman-adv attribute the user is interacting with
  * @buff: the buffer containing the user data
  * @count: number of bytes in the buffer
  *
  * Return: 'count' on success or a negative error code in case of failure
  */
 static ssize_t batadv_store_isolation_mark(struct kobject *kobj,
 					   struct attribute *attr, char *buff,
 					   size_t count)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	struct batadv_priv *bat_priv = netdev_priv(net_dev);
 	u32 mark, mask;
 	char *mask_ptr;
 	/* parse the mask if it has been specified, otherwise assume the mask is
 	 * the biggest possible
 	 */
 	mask = 0xFFFFFFFF;
 	mask_ptr = strchr(buff, '/');
 	if (mask_ptr) {
 		*mask_ptr = '\0';
 		mask_ptr++;
 		/* the mask must be entered in hex base as it is going to be a
 		 * bitmask and not a prefix length
 		 */
 		if (kstrtou32(mask_ptr, 16, &mask) < 0)
 			return -EINVAL;
 	}
 	/* the mark can be entered in any base */
 	if (kstrtou32(buff, 0, &mark) < 0)
 		return -EINVAL;
 	bat_priv->isolation_mark_mask = mask;
 	/* erase bits not covered by the mask */
 	bat_priv->isolation_mark = mark & bat_priv->isolation_mark_mask;
 	batadv_info(net_dev,
 		    "New skb mark for extended isolation: %#.8x/%#.8x\n",
 		    bat_priv->isolation_mark, bat_priv->isolation_mark_mask);
 	return count;
 }
 BATADV_ATTR_SIF_BOOL(aggregated_ogms, 0644, NULL);
 BATADV_ATTR_SIF_BOOL(bonding, 0644, NULL);
 #ifdef CONFIG_BATMAN_ADV_BLA
 BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, 0644, batadv_bla_status_update);
 #endif
 #ifdef CONFIG_BATMAN_ADV_DAT
 BATADV_ATTR_SIF_BOOL(distributed_arp_table, 0644, batadv_dat_status_update);
 #endif
 BATADV_ATTR_SIF_BOOL(fragmentation, 0644, batadv_update_min_mtu);
 static BATADV_ATTR(routing_algo, 0444, batadv_show_bat_algo, NULL);
 static BATADV_ATTR(gw_mode, 0644, batadv_show_gw_mode, batadv_store_gw_mode);
 BATADV_ATTR_SIF_UINT(orig_interval, orig_interval, 0644, 2 * BATADV_JITTER,
 		     INT_MAX, NULL);
 BATADV_ATTR_SIF_UINT(hop_penalty, hop_penalty, 0644, 0, BATADV_TQ_MAX_VALUE,
 		     NULL);
 static BATADV_ATTR(gw_sel_class, 0644, batadv_show_gw_sel_class,
 		   batadv_store_gw_sel_class);
 static BATADV_ATTR(gw_bandwidth, 0644, batadv_show_gw_bwidth,
 		   batadv_store_gw_bwidth);
 #ifdef CONFIG_BATMAN_ADV_MCAST
 BATADV_ATTR_SIF_BOOL(multicast_mode, 0644, NULL);
 #endif
 #ifdef CONFIG_BATMAN_ADV_DEBUG
 BATADV_ATTR_SIF_UINT(log_level, log_level, 0644, 0, BATADV_DBG_ALL, NULL);
 #endif
 #ifdef CONFIG_BATMAN_ADV_NC
 BATADV_ATTR_SIF_BOOL(network_coding, 0644, batadv_nc_status_update);
 #endif
 static BATADV_ATTR(isolation_mark, 0644, batadv_show_isolation_mark,
 		   batadv_store_isolation_mark);
 static struct batadv_attribute *batadv_mesh_attrs[] = {
 	&batadv_attr_aggregated_ogms,
 	&batadv_attr_bonding,
 #ifdef CONFIG_BATMAN_ADV_BLA
 	&batadv_attr_bridge_loop_avoidance,
 #endif
 #ifdef CONFIG_BATMAN_ADV_DAT
 	&batadv_attr_distributed_arp_table,
 #endif
 #ifdef CONFIG_BATMAN_ADV_MCAST
 	&batadv_attr_multicast_mode,
 #endif
 	&batadv_attr_fragmentation,
 	&batadv_attr_routing_algo,
 	&batadv_attr_gw_mode,
 	&batadv_attr_orig_interval,
 	&batadv_attr_hop_penalty,
 	&batadv_attr_gw_sel_class,
 	&batadv_attr_gw_bandwidth,
 #ifdef CONFIG_BATMAN_ADV_DEBUG
 	&batadv_attr_log_level,
 #endif
 #ifdef CONFIG_BATMAN_ADV_NC
 	&batadv_attr_network_coding,
 #endif
 	&batadv_attr_isolation_mark,
 	NULL,
 };
 BATADV_ATTR_VLAN_BOOL(ap_isolation, 0644, NULL);
 /* array of vlan specific sysfs attributes */
 static struct batadv_attribute *batadv_vlan_attrs[] = {
 	&batadv_attr_vlan_ap_isolation,
 	NULL,
 };
 /**
  * batadv_sysfs_add_meshif() - Add soft interface specific sysfs entries
  * @dev: netdev struct of the soft interface
  *
  * Return: 0 on success or negative error number in case of failure
  */
 int batadv_sysfs_add_meshif(struct net_device *dev)
 {
 	struct kobject *batif_kobject = &dev->dev.kobj;
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct batadv_attribute **bat_attr;
 	int err;
 	bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
 						    batif_kobject);
 	if (!bat_priv->mesh_obj) {
 		batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
 			   BATADV_SYSFS_IF_MESH_SUBDIR);
 		goto out;
 	}
 	for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
 		err = sysfs_create_file(bat_priv->mesh_obj,
 					&((*bat_attr)->attr));
 		if (err) {
 			batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
 				   dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
 				   ((*bat_attr)->attr).name);
 			goto rem_attr;
 		}
 	}
 	return 0;
 rem_attr:
 	for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
 		sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
 	kobject_uevent(bat_priv->mesh_obj, KOBJ_REMOVE);
 	kobject_del(bat_priv->mesh_obj);
 	kobject_put(bat_priv->mesh_obj);
 	bat_priv->mesh_obj = NULL;
 out:
 	return -ENOMEM;
 }
 /**
  * batadv_sysfs_del_meshif() - Remove soft interface specific sysfs entries
  * @dev: netdev struct of the soft interface
  */
 void batadv_sysfs_del_meshif(struct net_device *dev)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct batadv_attribute **bat_attr;
 	for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
 		sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
 	kobject_uevent(bat_priv->mesh_obj, KOBJ_REMOVE);
 	kobject_del(bat_priv->mesh_obj);
 	kobject_put(bat_priv->mesh_obj);
 	bat_priv->mesh_obj = NULL;
 }
 /**
  * batadv_sysfs_add_vlan() - add all the needed sysfs objects for the new vlan
  * @dev: netdev of the mesh interface
  * @vlan: private data of the newly added VLAN interface
  *
  * Return: 0 on success and -ENOMEM if any of the structure allocations fails.
  */
 int batadv_sysfs_add_vlan(struct net_device *dev,
 			  struct batadv_softif_vlan *vlan)
 {
 	char vlan_subdir[sizeof(BATADV_SYSFS_VLAN_SUBDIR_PREFIX) + 5];
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct batadv_attribute **bat_attr;
 	int err;
 	if (vlan->vid & BATADV_VLAN_HAS_TAG) {
 		sprintf(vlan_subdir, BATADV_SYSFS_VLAN_SUBDIR_PREFIX "%hu",
 			vlan->vid & VLAN_VID_MASK);
 		vlan->kobj = kobject_create_and_add(vlan_subdir,
 						    bat_priv->mesh_obj);
 		if (!vlan->kobj) {
 			batadv_err(dev, "Can't add sysfs directory: %s/%s\n",
 				   dev->name, vlan_subdir);
 			goto out;
 		}
 	} else {
 		/* the untagged LAN uses the root folder to store its "VLAN
 		 * specific attributes"
 		 */
 		vlan->kobj = bat_priv->mesh_obj;
 		kobject_get(bat_priv->mesh_obj);
 	}
 	for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr) {
 		err = sysfs_create_file(vlan->kobj,
 					&((*bat_attr)->attr));
 		if (err) {
 			batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
 				   dev->name, vlan_subdir,
 				   ((*bat_attr)->attr).name);
 			goto rem_attr;
 		}
 	}
 	return 0;
 rem_attr:
 	for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
 		sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
 	if (vlan->kobj != bat_priv->mesh_obj) {
 		kobject_uevent(vlan->kobj, KOBJ_REMOVE);
 		kobject_del(vlan->kobj);
 	}
 	kobject_put(vlan->kobj);
 	vlan->kobj = NULL;
 out:
 	return -ENOMEM;
 }
 /**
  * batadv_sysfs_del_vlan() - remove all the sysfs objects for a given VLAN
  * @bat_priv: the bat priv with all the soft interface information
  * @vlan: the private data of the VLAN to destroy
  */
 void batadv_sysfs_del_vlan(struct batadv_priv *bat_priv,
 			   struct batadv_softif_vlan *vlan)
 {
 	struct batadv_attribute **bat_attr;
 	for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
 		sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
 	if (vlan->kobj != bat_priv->mesh_obj) {
 		kobject_uevent(vlan->kobj, KOBJ_REMOVE);
 		kobject_del(vlan->kobj);
 	}
 	kobject_put(vlan->kobj);
 	vlan->kobj = NULL;
 }
 static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
 				      struct attribute *attr, char *buff)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	struct batadv_hard_iface *hard_iface;
 	ssize_t length;
 	const char *ifname;
 	hard_iface = batadv_hardif_get_by_netdev(net_dev);
 	if (!hard_iface)
 		return 0;
 	if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
 		ifname =  "none";
 	else
 		ifname = hard_iface->soft_iface->name;
 	length = sprintf(buff, "%s\n", ifname);
 	batadv_hardif_put(hard_iface);
 	return length;
 }
 /**
  * batadv_store_mesh_iface_finish() - store new hardif mesh_iface state
  * @net_dev: netdevice to add/remove to/from batman-adv soft-interface
  * @ifname: name of soft-interface to modify
  *
  * Changes the parts of the hard+soft interface which can not be modified under
  * sysfs lock (to prevent deadlock situations).
  *
  * Return: 0 on success, 0 < on failure
  */
 static int batadv_store_mesh_iface_finish(struct net_device *net_dev,
 					  char ifname[IFNAMSIZ])
 {
 	struct net *net = dev_net(net_dev);
 	struct batadv_hard_iface *hard_iface;
 	int status_tmp;
 	int ret = 0;
 	ASSERT_RTNL();
 	hard_iface = batadv_hardif_get_by_netdev(net_dev);
 	if (!hard_iface)
 		return 0;
 	if (strncmp(ifname, "none", 4) == 0)
 		status_tmp = BATADV_IF_NOT_IN_USE;
 	else
 		status_tmp = BATADV_IF_I_WANT_YOU;
 	if (hard_iface->if_status == status_tmp)
 		goto out;
 	if (hard_iface->soft_iface &&
 	    strncmp(hard_iface->soft_iface->name, ifname, IFNAMSIZ) == 0)
 		goto out;
 	if (status_tmp == BATADV_IF_NOT_IN_USE) {
 		batadv_hardif_disable_interface(hard_iface,
 						BATADV_IF_CLEANUP_AUTO);
 		goto out;
 	}
 	/* if the interface already is in use */
 	if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
 		batadv_hardif_disable_interface(hard_iface,
 						BATADV_IF_CLEANUP_AUTO);
 	ret = batadv_hardif_enable_interface(hard_iface, net, ifname);
 out:
 	batadv_hardif_put(hard_iface);
 	return ret;
 }
 /**
  * batadv_store_mesh_iface_work() - store new hardif mesh_iface state
  * @work: work queue item
  *
  * Changes the parts of the hard+soft interface which can not be modified under
  * sysfs lock (to prevent deadlock situations).
  */
 static void batadv_store_mesh_iface_work(struct work_struct *work)
 {
 	struct batadv_store_mesh_work *store_work;
 	int ret;
 	store_work = container_of(work, struct batadv_store_mesh_work, work);
 	rtnl_lock();
 	ret = batadv_store_mesh_iface_finish(store_work->net_dev,
 					     store_work->soft_iface_name);
 	rtnl_unlock();
 	if (ret < 0)
 		pr_err("Failed to store new mesh_iface state %s for %s: %d\n",
 		       store_work->soft_iface_name, store_work->net_dev->name,
 		       ret);
 	dev_put(store_work->net_dev);
 	kfree(store_work);
 }
 static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
 				       struct attribute *attr, char *buff,
 				       size_t count)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	struct batadv_store_mesh_work *store_work;
 	if (buff[count - 1] == '\n')
 		buff[count - 1] = '\0';
 	if (strlen(buff) >= IFNAMSIZ) {
 		pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
 		       buff);
 		return -EINVAL;
 	}
 	store_work = kmalloc(sizeof(*store_work), GFP_KERNEL);
 	if (!store_work)
 		return -ENOMEM;
 	dev_hold(net_dev);
 	INIT_WORK(&store_work->work, batadv_store_mesh_iface_work);
 	store_work->net_dev = net_dev;
 	strlcpy(store_work->soft_iface_name, buff,
 		sizeof(store_work->soft_iface_name));
 	queue_work(batadv_event_workqueue, &store_work->work);
 	return count;
 }
 static ssize_t batadv_show_iface_status(struct kobject *kobj,
 					struct attribute *attr, char *buff)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	struct batadv_hard_iface *hard_iface;
 	ssize_t length;
 	hard_iface = batadv_hardif_get_by_netdev(net_dev);
 	if (!hard_iface)
 		return 0;
 	switch (hard_iface->if_status) {
 	case BATADV_IF_TO_BE_REMOVED:
 		length = sprintf(buff, "disabling\n");
 		break;
 	case BATADV_IF_INACTIVE:
 		length = sprintf(buff, "inactive\n");
 		break;
 	case BATADV_IF_ACTIVE:
 		length = sprintf(buff, "active\n");
 		break;
 	case BATADV_IF_TO_BE_ACTIVATED:
 		length = sprintf(buff, "enabling\n");
 		break;
 	case BATADV_IF_NOT_IN_USE:
 	default:
 		length = sprintf(buff, "not in use\n");
 		break;
 	}
 	batadv_hardif_put(hard_iface);
 	return length;
 }
 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
 /**
  * batadv_store_throughput_override() - parse and store throughput override
  *  entered by the user
  * @kobj: kobject representing the private mesh sysfs directory
  * @attr: the batman-adv attribute the user is interacting with
  * @buff: the buffer containing the user data
  * @count: number of bytes in the buffer
  *
  * Return: 'count' on success or a negative error code in case of failure
  */
 static ssize_t batadv_store_throughput_override(struct kobject *kobj,
 						struct attribute *attr,
 						char *buff, size_t count)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	struct batadv_hard_iface *hard_iface;
 	u32 tp_override;
 	u32 old_tp_override;
 	bool ret;
 	hard_iface = batadv_hardif_get_by_netdev(net_dev);
 	if (!hard_iface)
 		return -EINVAL;
 	if (buff[count - 1] == '\n')
 		buff[count - 1] = '\0';
 	ret = batadv_parse_throughput(net_dev, buff, "throughput_override",
 				      &tp_override);
 	if (!ret)
 		return count;
 	old_tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
 	if (old_tp_override == tp_override)
 		goto out;
 	batadv_info(hard_iface->soft_iface,
 		    "%s: %s: Changing from: %u.%u MBit to: %u.%u MBit\n",
 		    "throughput_override", net_dev->name,
 		    old_tp_override / 10, old_tp_override % 10,
 		    tp_override / 10, tp_override % 10);
 	atomic_set(&hard_iface->bat_v.throughput_override, tp_override);
 out:
 	batadv_hardif_put(hard_iface);
 	return count;
 }
 static ssize_t batadv_show_throughput_override(struct kobject *kobj,
 					       struct attribute *attr,
 					       char *buff)
 {
 	struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 	struct batadv_hard_iface *hard_iface;
 	u32 tp_override;
 	hard_iface = batadv_hardif_get_by_netdev(net_dev);
 	if (!hard_iface)
 		return -EINVAL;
 	tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
 	return sprintf(buff, "%u.%u MBit\n", tp_override / 10,
 		       tp_override % 10);
 }
 #endif
 static BATADV_ATTR(mesh_iface, 0644, batadv_show_mesh_iface,
 		   batadv_store_mesh_iface);
 static BATADV_ATTR(iface_status, 0444, batadv_show_iface_status, NULL);
 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
 BATADV_ATTR_HIF_UINT(elp_interval, bat_v.elp_interval, 0644,
 		     2 * BATADV_JITTER, INT_MAX, NULL);
 static BATADV_ATTR(throughput_override, 0644, batadv_show_throughput_override,
 		   batadv_store_throughput_override);
 #endif
 static struct batadv_attribute *batadv_batman_attrs[] = {
 	&batadv_attr_mesh_iface,
 	&batadv_attr_iface_status,
 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
 	&batadv_attr_elp_interval,
 	&batadv_attr_throughput_override,
 #endif
 	NULL,
 };
 /**
  * batadv_sysfs_add_hardif() - Add hard interface specific sysfs entries
  * @hardif_obj: address where to store the pointer to new sysfs folder
  * @dev: netdev struct of the hard interface
  *
  * Return: 0 on success or negative error number in case of failure
  */
 int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
 {
 	struct kobject *hardif_kobject = &dev->dev.kobj;
 	struct batadv_attribute **bat_attr;
 	int err;
 	*hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
 					     hardif_kobject);
 	if (!*hardif_obj) {
 		batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
 			   BATADV_SYSFS_IF_BAT_SUBDIR);
 		goto out;
 	}
 	for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
 		err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
 		if (err) {
 			batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
 				   dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
 				   ((*bat_attr)->attr).name);
 			goto rem_attr;
 		}
 	}
 	return 0;
 rem_attr:
 	for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
 		sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
 out:
 	return -ENOMEM;
 }
 /**
  * batadv_sysfs_del_hardif() - Remove hard interface specific sysfs entries
  * @hardif_obj: address to the pointer to which stores batman-adv sysfs folder
  *  of the hard interface
  */
 void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
 {
 	kobject_uevent(*hardif_obj, KOBJ_REMOVE);
 	kobject_del(*hardif_obj);
 	kobject_put(*hardif_obj);
 	*hardif_obj = NULL;
 }
 /**
  * batadv_throw_uevent() - Send an uevent with batman-adv specific env data
  * @bat_priv: the bat priv with all the soft interface information
  * @type: subsystem type of event. Stored in uevent's BATTYPE
  * @action: action type of event. Stored in uevent's BATACTION
  * @data: string with additional information to the event (ignored for
  *  BATADV_UEV_DEL). Stored in uevent's BATDATA
  *
  * Return: 0 on success or negative error number in case of failure
  */
 int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type,
 			enum batadv_uev_action action, const char *data)
 {
 	int ret = -ENOMEM;
 	struct kobject *bat_kobj;
 	char *uevent_env[4] = { NULL, NULL, NULL, NULL };
 	bat_kobj = &bat_priv->soft_iface->dev.kobj;
 	uevent_env[0] = kasprintf(GFP_ATOMIC,
 				  "%s%s", BATADV_UEV_TYPE_VAR,
 				  batadv_uev_type_str[type]);
 	if (!uevent_env[0])
 		goto out;
 	uevent_env[1] = kasprintf(GFP_ATOMIC,
 				  "%s%s", BATADV_UEV_ACTION_VAR,
 				  batadv_uev_action_str[action]);
 	if (!uevent_env[1])
 		goto out;
 	/* If the event is DEL, ignore the data field */
 	if (action != BATADV_UEV_DEL) {
 		uevent_env[2] = kasprintf(GFP_ATOMIC,
 					  "%s%s", BATADV_UEV_DATA_VAR, data);
 		if (!uevent_env[2])
 			goto out;
 	}
 	ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env);
 out:
 	kfree(uevent_env[0]);
 	kfree(uevent_env[1]);
 	kfree(uevent_env[2]);
 	if (ret)
 		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
 			   "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
 			   batadv_uev_type_str[type],
 			   batadv_uev_action_str[action],
 			   (action == BATADV_UEV_DEL ? "NULL" : data), ret);
 	return ret;
 }