[B.A.T.M.A.N.] [PATCHv4 00/12] netns and netlink support

[B.A.T.M.A.N.] [PATCHv4 00/12] netns and netlink support

[Andrew Lunn]

This patchset completes netns support, by disabling debugfs entries
when not in the default name space, and correctly handling interface
stack loops when the parent is in a different name space.

It additionally adds netlink support for most of the information found
in debugfs, and is netns awaire.

Note: BLA is still untested, so best assume it is broken...

v4:

* Fix the batctl o -i <ifname> use case by actually performing the
  filtering on the outgoing interface

v3:

* Fix the compat with older kernels. It now at least compiles with
  3.18.32. I've not booted it though.
  * Add missing kerneldoc

v2:

All changes requested by Sven:

* Added lots of missing includes and structure forward declarations
* Add two kernel doc comments
* Fixed an obvious bug in BLA, but it is probably still broken...
* Merged in the compat code Sven suggested. Only compile tested with 4.5.0

Andrew Lunn (7):
  batman-adv: Handle parent interfaces in a different netns
  batman-adv: compat.h: Add workaround for get_link_net()
  batman-adv: Suppress debugfs entries for netns's
  batman-adv: compat: Workarounds for previous patch
  batman-adv: Indicate netlink socket can be used with netns.
  batman-adv: add B.A.T.M.A.N. Dump gateways via netlink
  batman-adv: add B.A.T.M.A.N. Dump BLA claims via netlink

Matthias Schiffer (5):
  batman-adv: add generic netlink query API to replace debugfs files
  batman-adv: netlink: add translation table query
  batman-adv: netlink: add originator and neighbor table queries
  batman-adv: add B.A.T.M.A.N. IV bat_{orig, neigh}_dump implementations
  batman-adv: add B.A.T.M.A.N. V bat_{orig, neigh}_dump implementations

 Makefile                               |   1 +
 compat-include/linux/netlink.h         |  45 +++++
 compat-include/net/genetlink.h         |  34 ++++
 compat.h                               |  13 ++
 include/uapi/linux/batman_adv.h        | 111 ++++++++++++
 net/batman-adv/Makefile                |   1 +
 net/batman-adv/bat_iv_ogm.c            | 277 +++++++++++++++++++++++++++++
 net/batman-adv/bat_v.c                 | 262 ++++++++++++++++++++++++++++
 net/batman-adv/bridge_loop_avoidance.c | 166 ++++++++++++++++++
 net/batman-adv/bridge_loop_avoidance.h |  10 +-
 net/batman-adv/debugfs.c               |  18 ++
 net/batman-adv/gateway_client.c        | 131 ++++++++++++++
 net/batman-adv/gateway_client.h        |   2 +
 net/batman-adv/hard-interface.c        |  50 +++++-
 net/batman-adv/main.c                  |  51 ++++++
 net/batman-adv/main.h                  |   2 +
 net/batman-adv/netlink.c               | 302 ++++++++++++++++++++++++++++++++
 net/batman-adv/netlink.h               |  41 +++++
 net/batman-adv/originator.c            | 161 +++++++++++++++++
 net/batman-adv/originator.h            |   4 +
 net/batman-adv/packet.h                |  36 ----
 net/batman-adv/translation-table.c     | 308 +++++++++++++++++++++++++++++++++
 net/batman-adv/translation-table.h     |   4 +
 net/batman-adv/types.h                 |   9 +
 24 files changed, 1995 insertions(+), 44 deletions(-)
 create mode 100644 compat-include/linux/netlink.h
 create mode 100644 compat-include/net/genetlink.h
 create mode 100644 include/uapi/linux/batman_adv.h
 create mode 100644 net/batman-adv/netlink.c
 create mode 100644 net/batman-adv/netlink.h

-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 01/12] batman-adv: Handle parent interfaces in a different netns

[Andrew Lunn]

batman-adv tries to prevent the user from placing a batX soft
interface into another batman mesh as a hard interface. It does this
by walking up the devices list of parents and ensures they are all
none batX interfaces. iflink can point to an interface in a different
namespace, so also retrieve the parents name space when finding the
parent and use it when doing the comparison.

Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Acked-by: Antonio Quartulli <a@untable.cc>
---
v2: Add missing header files
    Use Sven's code to facilitate a compat.h change

v3: More of Sven's code to facilitate a compat.h
---
 net/batman-adv/hard-interface.c | 50 +++++++++++++++++++++++++++++++++++------
 1 file changed, 43 insertions(+), 7 deletions(-)

diff --git a/net/batman-adv/hard-interface.c b/net/batman-adv/hard-interface.c
index db2009d..5592f4a 100644
--- a/net/batman-adv/hard-interface.c
+++ b/net/batman-adv/hard-interface.c
@@ -36,6 +36,8 @@
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
+#include <net/net_namespace.h>
+#include <net/rtnetlink.h>
 
 #include "bridge_loop_avoidance.h"
 #include "debugfs.h"
@@ -83,25 +85,55 @@ out:
 }
 
 /**
+ * batadv_getlink_net - return link net namespace (of use fallback)
+ * @netdev: net_device to check
+ * @fallback_net: return in case get_link_net is not available for @netdev
+ *
+ * Return: result of rtnl_link_ops->get_link_net or @fallback_net
+ */
+static const struct net *batadv_getlink_net(const struct net_device *netdev,
+					    const struct net *fallback_net)
+{
+	if (!netdev->rtnl_link_ops)
+		return fallback_net;
+
+	if (!netdev->rtnl_link_ops->get_link_net)
+		return fallback_net;
+
+	return netdev->rtnl_link_ops->get_link_net(netdev);
+}
+
+/**
  * batadv_mutual_parents - check if two devices are each others parent
- * @dev1: 1st net_device
- * @dev2: 2nd net_device
+ * @dev1: 1st net dev
+ * @net1: 1st devices netns
+ * @dev2: 2nd net dev
+ * @net2: 2nd devices netns
  *
  * veth devices come in pairs and each is the parent of the other!
  *
  * Return: true if the devices are each others parent, otherwise false
  */
 static bool batadv_mutual_parents(const struct net_device *dev1,
-				  const struct net_device *dev2)
+				  const struct net *net1,
+				  const struct net_device *dev2,
+				  const struct net *net2)
 {
 	int dev1_parent_iflink = dev_get_iflink(dev1);
 	int dev2_parent_iflink = dev_get_iflink(dev2);
+	const struct net *dev1_parent_net;
+	const struct net *dev2_parent_net;
+
+	dev1_parent_net = batadv_getlink_net(dev1, net1);
+	dev2_parent_net = batadv_getlink_net(dev2, net2);
 
 	if (!dev1_parent_iflink || !dev2_parent_iflink)
 		return false;
 
 	return (dev1_parent_iflink == dev2->ifindex) &&
-	       (dev2_parent_iflink == dev1->ifindex);
+		(dev2_parent_iflink == dev1->ifindex) &&
+		net_eq(dev1_parent_net, net2) &&
+		net_eq(dev2_parent_net, net1);
 }
 
 /**
@@ -119,8 +151,9 @@ static bool batadv_mutual_parents(const struct net_device *dev1,
  */
 static bool batadv_is_on_batman_iface(const struct net_device *net_dev)
 {
-	struct net_device *parent_dev;
 	struct net *net = dev_net(net_dev);
+	struct net_device *parent_dev;
+	const struct net *parent_net;
 	bool ret;
 
 	/* check if this is a batman-adv mesh interface */
@@ -132,13 +165,16 @@ static bool batadv_is_on_batman_iface(const struct net_device *net_dev)
 	    dev_get_iflink(net_dev) == net_dev->ifindex)
 		return false;
 
+	parent_net = batadv_getlink_net(net_dev, net);
+
 	/* recurse over the parent device */
-	parent_dev = __dev_get_by_index(net, dev_get_iflink(net_dev));
+	parent_dev = __dev_get_by_index((struct net *)parent_net,
+					dev_get_iflink(net_dev));
 	/* if we got a NULL parent_dev there is something broken.. */
 	if (WARN(!parent_dev, "Cannot find parent device"))
 		return false;
 
-	if (batadv_mutual_parents(net_dev, parent_dev))
+	if (batadv_mutual_parents(net_dev, net, parent_dev, parent_net))
 		return false;
 
 	ret = batadv_is_on_batman_iface(parent_dev);
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 02/12] batman-adv: compat.h: Add workaround for get_link_net()

[Andrew Lunn]

Signed-off-by: Sven Eckelmann <sven@narfation.org>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
v2: Fix accidental newline deletion
---
 compat.h | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/compat.h b/compat.h
index 5a5f478..813e637 100644
--- a/compat.h
+++ b/compat.h
@@ -140,6 +140,13 @@ static int __batadv_interface_kill_vid(struct net_device *dev, __be16 proto,\
 
 #endif /* < KERNEL_VERSION(3, 15, 0) */
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
+
+/* WARNING for batadv_getlink_net */
+#define get_link_net get_xstats_size || 0 || netdev->rtnl_link_ops->get_xstats_size
+
+#endif /* < KERNEL_VERSION(4, 0, 0) */
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 3, 0)
 
 #define IFF_NO_QUEUE	0; dev->tx_queue_len = 0
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 03/12] batman-adv: Suppress debugfs entries for netns's

[Andrew Lunn]

Debugfs is not netns aware. It thus has problems when the same
interface name exists in multiple network name spaces.

Work around this by not creating entries for interfaces in name spaces
other than the default name space. This means meshes in network
namespaces cannot be managed via debugfs, but there will soon be a
netlink interface which is netns aware.

Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
v2: Fix accidental change to __printf
    Add missing includes.
---
 net/batman-adv/debugfs.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/net/batman-adv/debugfs.c b/net/batman-adv/debugfs.c
index 9529004..e54f0da 100644
--- a/net/batman-adv/debugfs.c
+++ b/net/batman-adv/debugfs.c
@@ -42,6 +42,7 @@
 #include <linux/types.h>
 #include <linux/uaccess.h>
 #include <linux/wait.h>
+#include <net/net_namespace.h>
 #include <stdarg.h>
 
 #include "bridge_loop_avoidance.h"
@@ -495,12 +496,16 @@ void batadv_debugfs_destroy(void)
  */
 int batadv_debugfs_add_hardif(struct batadv_hard_iface *hard_iface)
 {
+	struct net *net = dev_net(hard_iface->net_dev);
 	struct batadv_debuginfo **bat_debug;
 	struct dentry *file;
 
 	if (!batadv_debugfs)
 		goto out;
 
+	if (net != &init_net)
+		return 0;
+
 	hard_iface->debug_dir = debugfs_create_dir(hard_iface->net_dev->name,
 						   batadv_debugfs);
 	if (!hard_iface->debug_dir)
@@ -531,6 +536,11 @@ out:
  */
 void batadv_debugfs_del_hardif(struct batadv_hard_iface *hard_iface)
 {
+	struct net *net = dev_net(hard_iface->net_dev);
+
+	if (net != &init_net)
+		return;
+
 	if (batadv_debugfs) {
 		debugfs_remove_recursive(hard_iface->debug_dir);
 		hard_iface->debug_dir = NULL;
@@ -541,11 +551,15 @@ int batadv_debugfs_add_meshif(struct net_device *dev)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
 	struct batadv_debuginfo **bat_debug;
+	struct net *net = dev_net(dev);
 	struct dentry *file;
 
 	if (!batadv_debugfs)
 		goto out;
 
+	if (net != &init_net)
+		return 0;
+
 	bat_priv->debug_dir = debugfs_create_dir(dev->name, batadv_debugfs);
 	if (!bat_priv->debug_dir)
 		goto out;
@@ -582,6 +596,10 @@ out:
 void batadv_debugfs_del_meshif(struct net_device *dev)
 {
 	struct batadv_priv *bat_priv = netdev_priv(dev);
+	struct net *net = dev_net(dev);
+
+	if (net != &init_net)
+		return;
 
 	batadv_debug_log_cleanup(bat_priv);
 
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 04/12] batman-adv: add generic netlink query API to replace debugfs files

[Andrew Lunn]

From: Matthias Schiffer <mschiffer@universe-factory.net>

debugfs is currently severely broken virtually everywhere in the kernel
where files are dynamically added and removed (see
http://lkml.iu.edu/hypermail/linux/kernel/1506.1/02196.html for some
details). In addition to that, debugfs is not namespace-aware.

Also, the debugfs interface will try to fix the whole list of originators/
TT entries into a single buffer. The situation has improved in recent
kernels,as the seq_file infrastructure will fall back to vmalloc now when
kmalloc fails. Still, converting all information to text and potentially
retrying multiple times until the buffer is big enough is very inefficient.

This commit adds generic infrastructur for the netlink interface to
batman-adv and implements the following command:

* BATADV_CMD_GET_ROUTING_ALGOS: will return the list of supported routing
  algorithms
* BATADV_CMD_GET_MESH_INFO: will return basic information about a
  batman-adv softif (name, index and MAC address for both the softif and
  the primary hardif; routing algorithm; batman-adv version)
* BATADV_CMD_GET_HARDIFS: will return the list of hardifs (including
  index, name and MAC address) of all hardifs for a given softif

Signed-off-by: Matthias Schiffer <mschiffer@universe-factory.net>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
v2: Added missing includes and forward declarations of structures.
---
 Makefile                        |   1 +
 include/uapi/linux/batman_adv.h |  49 ++++++++
 net/batman-adv/Makefile         |   1 +
 net/batman-adv/main.c           |  51 ++++++++
 net/batman-adv/main.h           |   2 +
 net/batman-adv/netlink.c        | 260 ++++++++++++++++++++++++++++++++++++++++
 net/batman-adv/netlink.h        |  41 +++++++
 7 files changed, 405 insertions(+)
 create mode 100644 include/uapi/linux/batman_adv.h
 create mode 100644 net/batman-adv/netlink.c
 create mode 100644 net/batman-adv/netlink.h

diff --git a/Makefile b/Makefile
index 5d2c058..f17bde5 100644
--- a/Makefile
+++ b/Makefile
@@ -45,6 +45,7 @@ REVISION= $(shell	if [ -d "$(PWD)/.git" ]; then \
 			fi)
 export NOSTDINC_FLAGS := \
 	-I$(PWD)/compat-include/ \
+	-I$(PWD)/include/ \
 	-include $(PWD)/compat.h \
 	$(CFLAGS)
 
diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
new file mode 100644
index 0000000..b9b7dfd
--- /dev/null
+++ b/include/uapi/linux/batman_adv.h
@@ -0,0 +1,49 @@
+/* Copyright (C) 2016 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/>.
+ */
+
+#ifndef _UAPI_LINUX_BATMAN_ADV_H_
+#define _UAPI_LINUX_BATMAN_ADV_H_
+
+#define BATADV_NL_NAME "batadv"
+
+enum {
+	BATADV_ATTR_UNSPEC,
+	BATADV_ATTR_VERSION,
+	BATADV_ATTR_ALGO_NAME,
+	BATADV_ATTR_MESH_IFINDEX,
+	BATADV_ATTR_MESH_IFNAME,
+	BATADV_ATTR_MESH_ADDRESS,
+	BATADV_ATTR_HARD_IFINDEX,
+	BATADV_ATTR_HARD_IFNAME,
+	BATADV_ATTR_HARD_ADDRESS,
+	BATADV_ATTR_ACTIVE,
+	__BATADV_ATTR_MAX,
+};
+
+#define BATADV_ATTR_MAX (__BATADV_ATTR_MAX - 1)
+
+enum {
+	BATADV_CMD_UNSPEC,
+	BATADV_CMD_GET_ROUTING_ALGOS,
+	BATADV_CMD_GET_MESH_INFO,
+	BATADV_CMD_GET_HARDIFS,
+	__BATADV_CMD_MAX,
+};
+
+#define BATADV_CMD_MAX (__BATADV_CMD_MAX - 1)
+
+#endif /* _UAPI_LINUX_BATMAN_ADV_H_ */
diff --git a/net/batman-adv/Makefile b/net/batman-adv/Makefile
index 797cf2f..4e5adba 100644
--- a/net/batman-adv/Makefile
+++ b/net/batman-adv/Makefile
@@ -33,6 +33,7 @@ batman-adv-y += hash.o
 batman-adv-y += icmp_socket.o
 batman-adv-y += main.o
 batman-adv-$(CONFIG_BATMAN_ADV_MCAST) += multicast.o
+batman-adv-y += netlink.o
 batman-adv-$(CONFIG_BATMAN_ADV_NC) += network-coding.o
 batman-adv-y += originator.o
 batman-adv-y += routing.o
diff --git a/net/batman-adv/main.c b/net/batman-adv/main.c
index 627d14e..3127d28 100644
--- a/net/batman-adv/main.c
+++ b/net/batman-adv/main.c
@@ -35,6 +35,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/netdevice.h>
+#include <linux/netlink.h>
 #include <linux/pkt_sched.h>
 #include <linux/rculist.h>
 #include <linux/rcupdate.h>
@@ -46,7 +47,10 @@
 #include <linux/string.h>
 #include <linux/workqueue.h>
 #include <net/dsfield.h>
+#include <net/genetlink.h>
+#include <net/netlink.h>
 #include <net/rtnetlink.h>
+#include <uapi/linux/batman_adv.h>
 
 #include "bat_algo.h"
 #include "bridge_loop_avoidance.h"
@@ -57,6 +61,7 @@
 #include "hard-interface.h"
 #include "icmp_socket.h"
 #include "multicast.h"
+#include "netlink.h"
 #include "network-coding.h"
 #include "originator.h"
 #include "packet.h"
@@ -101,6 +106,7 @@ static int __init batadv_init(void)
 
 	register_netdevice_notifier(&batadv_hard_if_notifier);
 	rtnl_link_register(&batadv_link_ops);
+	batadv_netlink_register();
 
 	pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n",
 		BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION);
@@ -111,6 +117,7 @@ static int __init batadv_init(void)
 static void __exit batadv_exit(void)
 {
 	batadv_debugfs_destroy();
+	batadv_netlink_unregister();
 	rtnl_link_unregister(&batadv_link_ops);
 	unregister_netdevice_notifier(&batadv_hard_if_notifier);
 	batadv_hardif_remove_interfaces();
@@ -608,6 +615,50 @@ int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
 	return 0;
 }
 
+static int batadv_algo_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
+				  struct batadv_algo_ops *bat_algo_ops)
+{
+	void *hdr;
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
+			  BATADV_CMD_GET_ROUTING_ALGOS);
+	if (!hdr)
+		return -EMSGSIZE;
+
+	if (nla_put_string(msg, BATADV_ATTR_ALGO_NAME, bat_algo_ops->name))
+		goto nla_put_failure;
+
+	genlmsg_end(msg, hdr);
+	return 0;
+
+ nla_put_failure:
+	genlmsg_cancel(msg, hdr);
+	return -EMSGSIZE;
+}
+
+int batadv_algo_dump(struct sk_buff *msg, struct netlink_callback *cb)
+{
+	int portid = NETLINK_CB(cb->skb).portid;
+	struct batadv_algo_ops *bat_algo_ops;
+	int skip = cb->args[0];
+	int i = 0;
+
+	hlist_for_each_entry(bat_algo_ops, &batadv_algo_list, list) {
+		if (i++ < skip)
+			continue;
+
+		if (batadv_algo_dump_entry(msg, portid, cb->nlh->nlmsg_seq,
+					   bat_algo_ops)) {
+			i--;
+			break;
+		}
+	}
+
+	cb->args[0] = i;
+
+	return msg->len;
+}
+
 /**
  * batadv_skb_crc32 - calculate CRC32 of the whole packet and skip bytes in
  *  the header
diff --git a/net/batman-adv/main.h b/net/batman-adv/main.h
index 7692526..3b770df 100644
--- a/net/batman-adv/main.h
+++ b/net/batman-adv/main.h
@@ -191,6 +191,7 @@ enum batadv_uev_type {
 #include "types.h"
 
 struct batadv_ogm_packet;
+struct netlink_callback;
 struct seq_file;
 struct sk_buff;
 
@@ -221,6 +222,7 @@ void batadv_recv_handler_unregister(u8 packet_type);
 int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops);
 int batadv_algo_select(struct batadv_priv *bat_priv, char *name);
 int batadv_algo_seq_print_text(struct seq_file *seq, void *offset);
+int batadv_algo_dump(struct sk_buff *msg, struct netlink_callback *cb);
 __be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr);
 
 /**
diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c
new file mode 100644
index 0000000..e302de3
--- /dev/null
+++ b/net/batman-adv/netlink.c
@@ -0,0 +1,260 @@
+/* Copyright (C) 2016 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 "main.h"
+#include "netlink.h"
+
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/if_ether.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/netlink.h>
+#include <linux/printk.h>
+#include <linux/rculist.h>
+#include <linux/rcupdate.h>
+#include <linux/skbuff.h>
+#include <linux/stddef.h>
+#include <linux/types.h>
+#include <net/sock.h>
+#include <uapi/linux/batman_adv.h>
+
+#include "hard-interface.h"
+#include "soft-interface.h"
+
+struct genl_family batadv_netlink_family = {
+	.id = GENL_ID_GENERATE,
+	.hdrsize = 0,
+	.name = BATADV_NL_NAME,
+	.version = 1,
+	.maxattr = BATADV_ATTR_MAX,
+};
+
+static int
+batadv_netlink_mesh_info_put(struct sk_buff *msg, struct net_device *soft_iface)
+{
+	int ret = -ENOBUFS;
+	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
+	struct batadv_hard_iface *primary_if = NULL;
+	struct net_device *hard_iface;
+
+	if (nla_put_string(msg, BATADV_ATTR_VERSION, BATADV_SOURCE_VERSION) ||
+	    nla_put_string(msg, BATADV_ATTR_ALGO_NAME,
+			   bat_priv->bat_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))
+		goto out;
+
+	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 out;
+	}
+
+	ret = 0;
+
+ out:
+	if (primary_if)
+		batadv_hardif_put(primary_if);
+
+	return ret;
+}
+
+static int
+batadv_netlink_get_mesh_info(struct sk_buff *skb, struct genl_info *info)
+{
+	struct net *net = genl_info_net(info);
+	int ret;
+	struct sk_buff *msg = NULL;
+	void *msg_head;
+	int ifindex;
+	struct net_device *soft_iface;
+
+	if (!info->attrs[BATADV_ATTR_MESH_IFINDEX])
+		return -EINVAL;
+
+	ifindex = nla_get_u32(info->attrs[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;
+	}
+
+	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_GET_MESH_INFO);
+	if (!msg_head) {
+		ret = -ENOBUFS;
+		goto out;
+	}
+
+	ret = batadv_netlink_mesh_info_put(msg, soft_iface);
+
+ out:
+	if (soft_iface)
+		dev_put(soft_iface);
+
+	if (ret) {
+		if (msg)
+			nlmsg_free(msg);
+		return ret;
+	}
+
+	genlmsg_end(msg, msg_head);
+	return genlmsg_reply(msg, info);
+}
+
+static int
+batadv_netlink_dump_hardif_entry(struct sk_buff *msg, u32 portid, u32 seq,
+				 struct batadv_hard_iface *hard_iface)
+{
+	struct net_device *net_dev = hard_iface->net_dev;
+	void *hdr;
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
+			  BATADV_CMD_GET_HARDIFS);
+	if (!hdr)
+		return -EMSGSIZE;
+
+	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;
+}
+
+static int
+batadv_netlink_dump_hardifs(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;
+	int ifindex;
+	int portid = NETLINK_CB(cb->skb).portid;
+	int seq = cb->nlh->nlmsg_seq;
+	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;
+	}
+
+	rcu_read_lock();
+
+	list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
+		if (hard_iface->soft_iface != soft_iface)
+			continue;
+
+		if (i++ < skip)
+			continue;
+
+		if (batadv_netlink_dump_hardif_entry(msg, portid, seq,
+						     hard_iface)) {
+			i--;
+			break;
+		}
+	}
+
+	rcu_read_unlock();
+
+	dev_put(soft_iface);
+
+	cb->args[0] = i;
+
+	return msg->len;
+}
+
+static struct nla_policy batadv_netlink_policy[BATADV_ATTR_MAX + 1] = {
+	[BATADV_ATTR_MESH_IFINDEX]	= { .type = NLA_U32 },
+};
+
+static struct genl_ops batadv_netlink_ops[] = {
+	{
+		.cmd = BATADV_CMD_GET_ROUTING_ALGOS,
+		.flags = GENL_ADMIN_PERM,
+		.policy = batadv_netlink_policy,
+		.dumpit = batadv_algo_dump,
+	},
+	{
+		.cmd = BATADV_CMD_GET_MESH_INFO,
+		.flags = GENL_ADMIN_PERM,
+		.policy = batadv_netlink_policy,
+		.doit = batadv_netlink_get_mesh_info,
+	},
+	{
+		.cmd = BATADV_CMD_GET_HARDIFS,
+		.flags = GENL_ADMIN_PERM,
+		.policy = batadv_netlink_policy,
+		.dumpit = batadv_netlink_dump_hardifs,
+	},
+};
+
+void __init batadv_netlink_register(void)
+{
+	int ret;
+
+	ret = genl_register_family_with_ops(&batadv_netlink_family,
+					    batadv_netlink_ops);
+	if (ret)
+		pr_warn("unable to register netlink family");
+}
+
+void batadv_netlink_unregister(void)
+{
+	genl_unregister_family(&batadv_netlink_family);
+}
diff --git a/net/batman-adv/netlink.h b/net/batman-adv/netlink.h
new file mode 100644
index 0000000..ae0eeb9
--- /dev/null
+++ b/net/batman-adv/netlink.h
@@ -0,0 +1,41 @@
+/* Copyright (C) 2016 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/>.
+ */
+
+#ifndef _NET_BATMAN_ADV_NETLINK_H_
+#define _NET_BATMAN_ADV_NETLINK_H_
+
+#include <linux/compiler.h>
+#include <linux/genetlink.h>
+#include <net/genetlink.h>
+#include <net/netlink.h>
+
+struct nlmsghdr;
+
+void batadv_netlink_register(void);
+void batadv_netlink_unregister(void);
+
+static inline 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;
+}
+
+extern struct genl_family batadv_netlink_family;
+
+#endif /* _NET_BATMAN_ADV_NETLINK_H_ */
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 05/12] batman-adv: compat: Workarounds for previous patch

[Andrew Lunn]

* NETLINK_CB portid changed name
* info->snd_portid changed name
* genl_register_family_with_ops implementation

Signed-off-by: Sven Eckelmann <sven@narfation.org>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
 compat-include/linux/netlink.h | 45 ++++++++++++++++++++++++++++++++++++++++++
 compat-include/net/genetlink.h | 34 +++++++++++++++++++++++++++++++
 compat.h                       |  6 ++++++
 3 files changed, 85 insertions(+)
 create mode 100644 compat-include/linux/netlink.h
 create mode 100644 compat-include/net/genetlink.h

diff --git a/compat-include/linux/netlink.h b/compat-include/linux/netlink.h
new file mode 100644
index 0000000..696f6da
--- /dev/null
+++ b/compat-include/linux/netlink.h
@@ -0,0 +1,45 @@
+/* Copyright (C) 2007-2016 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/>.
+ *
+ * This file contains macros for maintaining compatibility with older versions
+ * of the Linux kernel.
+ */
+
+#ifndef _NET_BATMAN_ADV_COMPAT_LINUX_NETLINK_H_
+#define _NET_BATMAN_ADV_COMPAT_LINUX_NETLINK_H_
+
+#include <linux/version.h>
+#include_next <linux/netlink.h>
+
+#include <net/scm.h>
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
+
+struct batadv_netlink_skb_parms {
+	struct ucred		creds;		/* Skb credentials	*/
+	union {
+		__u32		portid;
+		__u32		pid;
+	};
+	__u32			dst_group;
+};
+
+#undef NETLINK_CB
+#define NETLINK_CB(skb) (*(struct batadv_netlink_skb_parms*)&((skb)->cb))
+
+#endif /* < KERNEL_VERSION(3, 7, 0) */
+
+#endif /* _NET_BATMAN_ADV_COMPAT_LINUX_NETLINK_H_ */
diff --git a/compat-include/net/genetlink.h b/compat-include/net/genetlink.h
new file mode 100644
index 0000000..bf1ba3d
--- /dev/null
+++ b/compat-include/net/genetlink.h
@@ -0,0 +1,34 @@
+/* Copyright (C) 2007-2016 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/>.
+ *
+ * This file contains macros for maintaining compatibility with older versions
+ * of the Linux kernel.
+ */
+
+#ifndef _NET_BATMAN_ADV_COMPAT_NET_GENETLINK_H_
+#define _NET_BATMAN_ADV_COMPAT_NET_GENETLINK_H_
+
+#include <linux/version.h>
+#include_next <net/genetlink.h>
+
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 13, 0)
+
+#define genl_register_family_with_ops(family, ops)     \
+	genl_register_family_with_ops((family), (ops), ARRAY_SIZE(ops))
+
+#endif /* < KERNEL_VERSION(3, 13, 0) */
+
+#endif /* _NET_BATMAN_ADV_COMPAT_NET_GENETLINK_H_ */
diff --git a/compat.h b/compat.h
index 813e637..ac4f7a0 100644
--- a/compat.h
+++ b/compat.h
@@ -62,6 +62,12 @@ static int __batadv_interface_kill_vid(struct net_device *dev, __be16 proto,\
 
 #endif /* < KERNEL_VERSION(3, 3, 0) */
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
+
+#define snd_portid snd_pid
+
+#endif /* < KERNEL_VERSION(3, 7, 0) */
+
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 9, 0)
 
 #define batadv_interface_set_mac_addr(x, y) \
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 06/12] batman-adv: netlink: add translation table query

[Andrew Lunn]

From: Matthias Schiffer <mschiffer@universe-factory.net>

This adds the commands BATADV_CMD_GET_TRANSTABLE_LOCAL and
BATADV_CMD_GET_TRANSTABLE_GLOBAL, which correspond to the transtable_local
and transtable_global debugfs files.

The batadv_tt_client_flags enum is moved to the UAPI to expose it as part
of the netlink API.

Signed-off-by: Matthias Schiffer <mschiffer@universe-factory.net>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
v2: Add missing header files.
---
 include/uapi/linux/batman_adv.h    |  47 ++++++
 net/batman-adv/netlink.c           |  13 ++
 net/batman-adv/packet.h            |  36 -----
 net/batman-adv/translation-table.c | 308 +++++++++++++++++++++++++++++++++++++
 net/batman-adv/translation-table.h |   4 +
 5 files changed, 372 insertions(+), 36 deletions(-)

diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
index b9b7dfd..25dee3c 100644
--- a/include/uapi/linux/batman_adv.h
+++ b/include/uapi/linux/batman_adv.h
@@ -20,6 +20,42 @@
 
 #define BATADV_NL_NAME "batadv"
 
+/**
+ * enum batadv_tt_client_flags - TT client specific flags
+ * @BATADV_TT_CLIENT_DEL: the client has to be deleted from the table
+ * @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_WIFI: this client is connected through a wifi interface.
+ *  This information is used by the "AP Isolation" feature
+ * @BATADV_TT_CLIENT_ISOLA: this client is considered "isolated". This
+ *  information is used by the Extended Isolation feature
+ * @BATADV_TT_CLIENT_NOPURGE: this client should never be removed from the table
+ * @BATADV_TT_CLIENT_NEW: this client has been added to the local table but has
+ *  not been announced yet
+ * @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_TEMP: this global client has been detected to be part of
+ *  the network but no nnode has already announced it
+ *
+ * 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     = (1 << 0),
+	BATADV_TT_CLIENT_ROAM    = (1 << 1),
+	BATADV_TT_CLIENT_WIFI    = (1 << 4),
+	BATADV_TT_CLIENT_ISOLA	 = (1 << 5),
+	BATADV_TT_CLIENT_NOPURGE = (1 << 8),
+	BATADV_TT_CLIENT_NEW     = (1 << 9),
+	BATADV_TT_CLIENT_PENDING = (1 << 10),
+	BATADV_TT_CLIENT_TEMP	 = (1 << 11),
+};
+
 enum {
 	BATADV_ATTR_UNSPEC,
 	BATADV_ATTR_VERSION,
@@ -31,6 +67,15 @@ enum {
 	BATADV_ATTR_HARD_IFNAME,
 	BATADV_ATTR_HARD_ADDRESS,
 	BATADV_ATTR_ACTIVE,
+	BATADV_ATTR_ORIG_ADDRESS,
+	BATADV_ATTR_TT_ADDRESS,
+	BATADV_ATTR_TT_TTVN,
+	BATADV_ATTR_TT_LAST_TTVN,
+	BATADV_ATTR_TT_CRC32,
+	BATADV_ATTR_TT_VID,
+	BATADV_ATTR_TT_FLAGS,
+	BATADV_ATTR_FLAG_BEST,
+	BATADV_ATTR_LAST_SEEN_MSECS,
 	__BATADV_ATTR_MAX,
 };
 
@@ -41,6 +86,8 @@ enum {
 	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_MESH_INFO,
 	BATADV_CMD_GET_HARDIFS,
+	BATADV_CMD_GET_TRANSTABLE_LOCAL,
+	BATADV_CMD_GET_TRANSTABLE_GLOBAL,
 	__BATADV_CMD_MAX,
 };
 
diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c
index e302de3..3fb1c1f 100644
--- a/net/batman-adv/netlink.c
+++ b/net/batman-adv/netlink.c
@@ -35,6 +35,7 @@
 
 #include "hard-interface.h"
 #include "soft-interface.h"
+#include "translation-table.h"
 
 struct genl_family batadv_netlink_family = {
 	.id = GENL_ID_GENERATE,
@@ -242,6 +243,18 @@ static struct genl_ops batadv_netlink_ops[] = {
 		.policy = batadv_netlink_policy,
 		.dumpit = batadv_netlink_dump_hardifs,
 	},
+	{
+		.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,
+	},
 };
 
 void __init batadv_netlink_register(void)
diff --git a/net/batman-adv/packet.h b/net/batman-adv/packet.h
index 372128d..b45460d 100644
--- a/net/batman-adv/packet.h
+++ b/net/batman-adv/packet.h
@@ -126,42 +126,6 @@ enum batadv_tt_data_flags {
 };
 
 /**
- * enum batadv_tt_client_flags - TT client specific flags
- * @BATADV_TT_CLIENT_DEL: the client has to be deleted from the table
- * @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_WIFI: this client is connected through a wifi interface.
- *  This information is used by the "AP Isolation" feature
- * @BATADV_TT_CLIENT_ISOLA: this client is considered "isolated". This
- *  information is used by the Extended Isolation feature
- * @BATADV_TT_CLIENT_NOPURGE: this client should never be removed from the table
- * @BATADV_TT_CLIENT_NEW: this client has been added to the local table but has
- *  not been announced yet
- * @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_TEMP: this global client has been detected to be part of
- *  the network but no nnode has already announced it
- *
- * 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     = BIT(0),
-	BATADV_TT_CLIENT_ROAM    = BIT(1),
-	BATADV_TT_CLIENT_WIFI    = BIT(4),
-	BATADV_TT_CLIENT_ISOLA	 = BIT(5),
-	BATADV_TT_CLIENT_NOPURGE = BIT(8),
-	BATADV_TT_CLIENT_NEW     = BIT(9),
-	BATADV_TT_CLIENT_PENDING = BIT(10),
-	BATADV_TT_CLIENT_TEMP	 = BIT(11),
-};
-
-/**
  * enum batadv_vlan_flags - flags for the four MSB of any vlan ID field
  * @BATADV_VLAN_HAS_TAG: whether the field contains a valid vlan tag or not
  */
diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index feaf492..be42b12 100644
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -35,19 +35,26 @@
 #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/string.h>
 #include <linux/workqueue.h>
+#include <net/genetlink.h>
+#include <net/netlink.h>
+#include <net/sock.h>
+#include <uapi/linux/batman_adv.h>
 
 #include "bridge_loop_avoidance.h"
 #include "hard-interface.h"
 #include "hash.h"
 #include "multicast.h"
+#include "netlink.h"
 #include "originator.h"
 #include "packet.h"
 #include "soft-interface.h"
@@ -1056,6 +1063,138 @@ out:
 	return 0;
 }
 
+static int
+batadv_tt_local_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
+			   struct batadv_priv *bat_priv,
+			   struct batadv_tt_common_entry *common)
+{
+	void *hdr;
+	struct batadv_softif_vlan *vlan;
+	struct batadv_tt_local_entry *local;
+	unsigned int last_seen_msecs;
+	u32 crc;
+
+	local = container_of(common, struct batadv_tt_local_entry, common);
+	last_seen_msecs = jiffies_to_msecs(jiffies - local->last_seen);
+
+	vlan = batadv_softif_vlan_get(bat_priv, common->vid);
+	if (!vlan)
+		return 0;
+
+	crc = vlan->tt.crc;
+
+	batadv_softif_vlan_put(vlan);
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
+			  BATADV_CMD_GET_TRANSTABLE_LOCAL);
+	if (!hdr)
+		return -ENOBUFS;
+
+	if (nla_put(msg, BATADV_ATTR_TT_ADDRESS, ETH_ALEN, common->addr) ||
+	    nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) ||
+	    nla_put_u16(msg, BATADV_ATTR_TT_VID,
+			BATADV_PRINT_VID(common->vid)) ||
+	    nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, common->flags))
+		goto nla_put_failure;
+
+	if (!(common->flags & BATADV_TT_CLIENT_NOPURGE)) {
+		if (nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
+				last_seen_msecs))
+			goto nla_put_failure;
+	}
+
+	genlmsg_end(msg, hdr);
+	return 0;
+
+ nla_put_failure:
+	genlmsg_cancel(msg, hdr);
+	return -EMSGSIZE;
+}
+
+static int
+batadv_tt_local_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
+			    struct batadv_priv *bat_priv,
+			    struct hlist_head *head, int *idx_s)
+{
+	struct batadv_tt_common_entry *common;
+	int idx = 0;
+
+	rcu_read_lock();
+	hlist_for_each_entry_rcu(common, head, hash_entry) {
+		if (idx++ < *idx_s)
+			continue;
+
+		if (batadv_tt_local_dump_entry(msg, portid, seq, bat_priv,
+					       common)) {
+			rcu_read_unlock();
+			*idx_s = idx - 1;
+			return -EMSGSIZE;
+		}
+	}
+	rcu_read_unlock();
+
+	*idx_s = 0;
+	return 0;
+}
+
+int batadv_tt_local_dump(struct sk_buff *msg, struct netlink_callback *cb)
+{
+	struct net *net = sock_net(cb->skb->sk);
+	struct net_device *soft_iface = NULL;
+	struct batadv_priv *bat_priv;
+	struct batadv_hard_iface *primary_if = NULL;
+	struct batadv_hashtable *hash;
+	struct hlist_head *head;
+	int ret;
+	int ifindex;
+	int bucket = cb->args[0];
+	int idx = cb->args[1];
+	int portid = NETLINK_CB(cb->skb).portid;
+
+	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;
+	}
+
+	hash = bat_priv->tt.local_hash;
+
+	while (bucket < hash->size) {
+		head = &hash->table[bucket];
+
+		if (batadv_tt_local_dump_bucket(msg, portid, cb->nlh->nlmsg_seq,
+						bat_priv, head, &idx))
+			break;
+
+		bucket++;
+	}
+
+	ret = msg->len;
+
+ out:
+	if (primary_if)
+		batadv_hardif_put(primary_if);
+	if (soft_iface)
+		dev_put(soft_iface);
+
+	cb->args[0] = bucket;
+	cb->args[1] = idx;
+
+	return ret;
+}
+
 static void
 batadv_tt_local_set_pending(struct batadv_priv *bat_priv,
 			    struct batadv_tt_local_entry *tt_local_entry,
@@ -1702,6 +1841,175 @@ out:
 	return 0;
 }
 
+static int
+batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
+			       struct batadv_tt_common_entry *common,
+			       struct batadv_tt_orig_list_entry *orig,
+			       bool best)
+{
+	void *hdr;
+	struct batadv_orig_node_vlan *vlan;
+	u8 last_ttvn;
+	u32 crc;
+
+	vlan = batadv_orig_node_vlan_get(orig->orig_node,
+					 common->vid);
+	if (!vlan)
+		return 0;
+
+	crc = vlan->tt.crc;
+
+	batadv_orig_node_vlan_put(vlan);
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
+			  BATADV_CMD_GET_TRANSTABLE_GLOBAL);
+	if (!hdr)
+		return -ENOBUFS;
+
+	last_ttvn = atomic_read(&orig->orig_node->last_ttvn);
+
+	if (nla_put(msg, BATADV_ATTR_TT_ADDRESS, ETH_ALEN, common->addr) ||
+	    nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
+		    orig->orig_node->orig) ||
+	    nla_put_u8(msg, BATADV_ATTR_TT_TTVN, orig->ttvn) ||
+	    nla_put_u8(msg, BATADV_ATTR_TT_LAST_TTVN, last_ttvn) ||
+	    nla_put_u32(msg, BATADV_ATTR_TT_CRC32, crc) ||
+	    nla_put_u16(msg, BATADV_ATTR_TT_VID,
+			BATADV_PRINT_VID(common->vid)) ||
+	    nla_put_u32(msg, BATADV_ATTR_TT_FLAGS, common->flags))
+		goto nla_put_failure;
+
+	if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
+		goto nla_put_failure;
+
+	genlmsg_end(msg, hdr);
+	return 0;
+
+ nla_put_failure:
+	genlmsg_cancel(msg, hdr);
+	return -EMSGSIZE;
+}
+
+static int
+batadv_tt_global_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
+			    struct batadv_priv *bat_priv,
+			    struct batadv_tt_common_entry *common, int *sub_s)
+{
+	struct batadv_tt_orig_list_entry *orig_entry, *best_entry;
+	struct batadv_tt_global_entry *global;
+	struct hlist_head *head;
+	int sub = 0;
+	bool best;
+
+	global = container_of(common, struct batadv_tt_global_entry, common);
+	best_entry = batadv_transtable_best_orig(bat_priv, global);
+	head = &global->orig_list;
+
+	hlist_for_each_entry_rcu(orig_entry, head, list) {
+		if (sub++ < *sub_s)
+			continue;
+
+		best = (orig_entry == best_entry);
+
+		if (batadv_tt_global_dump_subentry(msg, portid, seq, common,
+						   orig_entry, best)) {
+			*sub_s = sub - 1;
+			return -EMSGSIZE;
+		}
+	}
+
+	*sub_s = 0;
+	return 0;
+}
+
+static int
+batadv_tt_global_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
+			     struct batadv_priv *bat_priv,
+			     struct hlist_head *head, int *idx_s, int *sub)
+{
+	struct batadv_tt_common_entry *common;
+	int idx = 0;
+
+	rcu_read_lock();
+	hlist_for_each_entry_rcu(common, head, hash_entry) {
+		if (idx++ < *idx_s)
+			continue;
+
+		if (batadv_tt_global_dump_entry(msg, portid, seq, bat_priv,
+						common, sub)) {
+			rcu_read_unlock();
+			*idx_s = idx - 1;
+			return -EMSGSIZE;
+		}
+	}
+	rcu_read_unlock();
+
+	*idx_s = 0;
+	*sub = 0;
+	return 0;
+}
+
+int batadv_tt_global_dump(struct sk_buff *msg, struct netlink_callback *cb)
+{
+	struct net *net = sock_net(cb->skb->sk);
+	struct net_device *soft_iface = NULL;
+	struct batadv_priv *bat_priv;
+	struct batadv_hard_iface *primary_if = NULL;
+	struct batadv_hashtable *hash;
+	struct hlist_head *head;
+	int ret;
+	int ifindex;
+	int bucket = cb->args[0];
+	int idx = cb->args[1];
+	int sub = cb->args[2];
+	int portid = NETLINK_CB(cb->skb).portid;
+
+	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;
+	}
+
+	hash = bat_priv->tt.global_hash;
+
+	while (bucket < hash->size) {
+		head = &hash->table[bucket];
+
+		if (batadv_tt_global_dump_bucket(msg, portid,
+						 cb->nlh->nlmsg_seq, bat_priv,
+						 head, &idx, &sub))
+			break;
+
+		bucket++;
+	}
+
+	ret = msg->len;
+
+ out:
+	if (primary_if)
+		batadv_hardif_put(primary_if);
+	if (soft_iface)
+		dev_put(soft_iface);
+
+	cb->args[0] = bucket;
+	cb->args[1] = idx;
+	cb->args[2] = sub;
+
+	return ret;
+}
+
 /**
  * _batadv_tt_global_del_orig_entry - remove and free an orig_entry
  * @tt_global_entry: the global entry to remove the orig_entry from
diff --git a/net/batman-adv/translation-table.h b/net/batman-adv/translation-table.h
index 7c7e2c0..4697af6 100644
--- a/net/batman-adv/translation-table.h
+++ b/net/batman-adv/translation-table.h
@@ -22,8 +22,10 @@
 
 #include <linux/types.h>
 
+struct netlink_callback;
 struct net_device;
 struct seq_file;
+struct sk_buff;
 
 int batadv_tt_init(struct batadv_priv *bat_priv);
 bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr,
@@ -33,6 +35,8 @@ u16 batadv_tt_local_remove(struct batadv_priv *bat_priv,
 			   const char *message, bool roaming);
 int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset);
 int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset);
+int batadv_tt_local_dump(struct sk_buff *msg, struct netlink_callback *cb);
+int batadv_tt_global_dump(struct sk_buff *msg, struct netlink_callback *cb);
 void batadv_tt_global_del_orig(struct batadv_priv *bat_priv,
 			       struct batadv_orig_node *orig_node,
 			       s32 match_vid, const char *message);
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 07/12] batman-adv: netlink: add originator and neighbor table queries

[Andrew Lunn]

From: Matthias Schiffer <mschiffer@universe-factory.net>

Add BATADV_CMD_GET_ORIGINATORS and BATADV_CMD_GET_NEIGHBORS commands,
using handlers bat_orig_dump and bat_neigh_dump in batadv_algo_ops. Will
always return -EOPNOTSUPP for now, as no implementations exist yet.

Signed-off-by: Matthias Schiffer <mschiffer@universe-factory.net>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
v2: Add missing includes and forward declarations
    Add kernel doc to the two dump functions.

v3: Add kernel doc for new members in batadv_algo_ops
---
 include/uapi/linux/batman_adv.h |   2 +
 net/batman-adv/netlink.c        |  14 ++++
 net/batman-adv/originator.c     | 161 ++++++++++++++++++++++++++++++++++++++++
 net/batman-adv/originator.h     |   4 +
 net/batman-adv/types.h          |   9 +++
 5 files changed, 190 insertions(+)

diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
index 25dee3c..35d8e8c 100644
--- a/include/uapi/linux/batman_adv.h
+++ b/include/uapi/linux/batman_adv.h
@@ -88,6 +88,8 @@ enum {
 	BATADV_CMD_GET_HARDIFS,
 	BATADV_CMD_GET_TRANSTABLE_LOCAL,
 	BATADV_CMD_GET_TRANSTABLE_GLOBAL,
+	BATADV_CMD_GET_ORIGINATORS,
+	BATADV_CMD_GET_NEIGHBORS,
 	__BATADV_CMD_MAX,
 };
 
diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c
index 3fb1c1f..a01bdf5 100644
--- a/net/batman-adv/netlink.c
+++ b/net/batman-adv/netlink.c
@@ -33,6 +33,7 @@
 #include <net/sock.h>
 #include <uapi/linux/batman_adv.h>
 
+#include "originator.h"
 #include "hard-interface.h"
 #include "soft-interface.h"
 #include "translation-table.h"
@@ -222,6 +223,7 @@ batadv_netlink_dump_hardifs(struct sk_buff *msg, struct netlink_callback *cb)
 
 static struct nla_policy batadv_netlink_policy[BATADV_ATTR_MAX + 1] = {
 	[BATADV_ATTR_MESH_IFINDEX]	= { .type = NLA_U32 },
+	[BATADV_ATTR_HARD_IFINDEX]	= { .type = NLA_U32 },
 };
 
 static struct genl_ops batadv_netlink_ops[] = {
@@ -255,6 +257,18 @@ static struct genl_ops batadv_netlink_ops[] = {
 		.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,
+	},
 };
 
 void __init batadv_netlink_register(void)
diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c
index 076d258..0455e54 100644
--- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@ -28,11 +28,15 @@
 #include <linux/list.h>
 #include <linux/lockdep.h>
 #include <linux/netdevice.h>
+#include <linux/netlink.h>
 #include <linux/rculist.h>
 #include <linux/seq_file.h>
+#include <linux/skbuff.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
+#include <net/sock.h>
+#include <uapi/linux/batman_adv.h>
 
 #include "distributed-arp-table.h"
 #include "fragmentation.h"
@@ -40,8 +44,10 @@
 #include "hard-interface.h"
 #include "hash.h"
 #include "multicast.h"
+#include "netlink.h"
 #include "network-coding.h"
 #include "routing.h"
+#include "soft-interface.h"
 #include "translation-table.h"
 
 /* hash class keys */
@@ -719,6 +725,83 @@ int batadv_hardif_neigh_seq_print_text(struct seq_file *seq, void *offset)
 }
 
 /**
+ * batadv_hardif_neigh_dump - Dump to netlink the neighbor infos for a specific
+ *  outgoing interface
+ * @msg: message to dump into
+ * @cb: parameters for the dump
+ *
+ * Return: 0 or error value
+ */
+int batadv_hardif_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb)
+{
+	struct net *net = sock_net(cb->skb->sk);
+	struct net_device *soft_iface = NULL;
+	struct net_device *hard_iface = NULL;
+	struct batadv_hard_iface *hardif = BATADV_IF_DEFAULT;
+	struct batadv_priv *bat_priv;
+	struct batadv_hard_iface *primary_if = NULL;
+	int ret;
+	int ifindex, hard_ifindex;
+
+	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;
+	}
+
+	hard_ifindex = batadv_netlink_get_ifindex(cb->nlh,
+						  BATADV_ATTR_HARD_IFINDEX);
+	if (hard_ifindex) {
+		hard_iface = dev_get_by_index(net, hard_ifindex);
+		if (hard_iface)
+			hardif = batadv_hardif_get_by_netdev(hard_iface);
+
+		if (!hardif) {
+			ret = -ENODEV;
+			goto out;
+		}
+
+		if (hardif->soft_iface != soft_iface) {
+			ret = -ENOENT;
+			goto out;
+		}
+	}
+
+	if (!bat_priv->bat_algo_ops->bat_neigh_dump) {
+		ret = -EOPNOTSUPP;
+		goto out;
+	}
+
+	bat_priv->bat_algo_ops->bat_neigh_dump(msg, cb, bat_priv, hardif);
+
+	ret = msg->len;
+
+ out:
+	if (hardif)
+		batadv_hardif_put(hardif);
+	if (hard_iface)
+		dev_put(hard_iface);
+	if (primary_if)
+		batadv_hardif_put(primary_if);
+	if (soft_iface)
+		dev_put(soft_iface);
+
+	return ret;
+}
+
+/**
  * batadv_orig_ifinfo_release - release orig_ifinfo from lists and queue for
  *  free after rcu grace period
  * @ref: kref pointer of the orig_ifinfo
@@ -1314,6 +1397,84 @@ out:
 	return 0;
 }
 
+/**
+ * batadv_orig_dump - Dump to netlink the originator infos for a specific
+ *  outgoing interface
+ * @msg: message to dump into
+ * @cb: parameters for the dump
+ *
+ * Return: 0 or error value
+ */
+int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb)
+{
+	struct net *net = sock_net(cb->skb->sk);
+	struct net_device *soft_iface = NULL;
+	struct net_device *hard_iface = NULL;
+	struct batadv_hard_iface *hardif = BATADV_IF_DEFAULT;
+	struct batadv_priv *bat_priv;
+	struct batadv_hard_iface *primary_if = NULL;
+	int ret;
+	int ifindex, hard_ifindex;
+
+	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;
+	}
+
+	hard_ifindex = batadv_netlink_get_ifindex(cb->nlh,
+						  BATADV_ATTR_HARD_IFINDEX);
+	if (hard_ifindex) {
+		hard_iface = dev_get_by_index(net, hard_ifindex);
+		if (hard_iface)
+			hardif = batadv_hardif_get_by_netdev(hard_iface);
+
+		if (!hardif) {
+			ret = -ENODEV;
+			goto out;
+		}
+
+		if (hardif->soft_iface != soft_iface) {
+			ret = -ENOENT;
+			goto out;
+		}
+	}
+
+	if (!bat_priv->bat_algo_ops->bat_orig_dump) {
+		ret = -EOPNOTSUPP;
+		goto out;
+	}
+
+	bat_priv->bat_algo_ops->bat_orig_dump(msg, cb, bat_priv, hardif);
+
+	ret = msg->len;
+
+ out:
+	if (hardif)
+		batadv_hardif_put(hardif);
+	if (hard_iface)
+		dev_put(hard_iface);
+	if (primary_if)
+		batadv_hardif_put(primary_if);
+	if (soft_iface)
+		dev_put(soft_iface);
+
+	return ret;
+}
+
 int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
 			    int max_if_num)
 {
diff --git a/net/batman-adv/originator.h b/net/batman-adv/originator.h
index 566306b..ebc5618 100644
--- a/net/batman-adv/originator.h
+++ b/net/batman-adv/originator.h
@@ -31,7 +31,9 @@
 
 #include "hash.h"
 
+struct netlink_callback;
 struct seq_file;
+struct sk_buff;
 
 bool batadv_compare_orig(const struct hlist_node *node, const void *data2);
 int batadv_originator_init(struct batadv_priv *bat_priv);
@@ -61,6 +63,7 @@ batadv_neigh_ifinfo_get(struct batadv_neigh_node *neigh,
 			struct batadv_hard_iface *if_outgoing);
 void batadv_neigh_ifinfo_put(struct batadv_neigh_ifinfo *neigh_ifinfo);
 
+int batadv_hardif_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb);
 int batadv_hardif_neigh_seq_print_text(struct seq_file *seq, void *offset);
 
 struct batadv_orig_ifinfo *
@@ -72,6 +75,7 @@ batadv_orig_ifinfo_new(struct batadv_orig_node *orig_node,
 void batadv_orig_ifinfo_put(struct batadv_orig_ifinfo *orig_ifinfo);
 
 int batadv_orig_seq_print_text(struct seq_file *seq, void *offset);
+int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb);
 int batadv_orig_hardif_seq_print_text(struct seq_file *seq, void *offset);
 int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface,
 			    int max_if_num);
diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h
index 32c6d0e..2c20166 100644
--- a/net/batman-adv/types.h
+++ b/net/batman-adv/types.h
@@ -28,6 +28,7 @@
 #include <linux/if_ether.h>
 #include <linux/kref.h>
 #include <linux/netdevice.h>
+#include <linux/netlink.h>
 #include <linux/sched.h> /* for linux/wait.h */
 #include <linux/spinlock.h>
 #include <linux/types.h>
@@ -1276,7 +1277,9 @@ struct batadv_forw_packet {
  *  better than neigh2 for their respective outgoing interface from the metric
  *  prospective
  * @bat_neigh_print: print the single hop neighbor list (optional)
+ * @bat_neigh_dump: dump neighbors to a netlink socket
  * @bat_orig_print: print the originator table (optional)
+ * @bat_orig_dump: dump originators to a netlink socket
  * @bat_orig_free: free the resources allocated by the routing algorithm for an
  *  orig_node object
  * @bat_orig_add_if: ask the routing algorithm to apply the needed changes to
@@ -1304,9 +1307,15 @@ struct batadv_algo_ops {
 		 struct batadv_neigh_node *neigh2,
 		 struct batadv_hard_iface *if_outgoing2);
 	void (*bat_neigh_print)(struct batadv_priv *priv, struct seq_file *seq);
+	void (*bat_neigh_dump)(struct sk_buff *msg, struct netlink_callback *cb,
+			       struct batadv_priv *priv,
+			       struct batadv_hard_iface *hard_iface);
 	/* orig_node handling API */
 	void (*bat_orig_print)(struct batadv_priv *priv, struct seq_file *seq,
 			       struct batadv_hard_iface *hard_iface);
+	void (*bat_orig_dump)(struct sk_buff *msg, struct netlink_callback *cb,
+			      struct batadv_priv *priv,
+			      struct batadv_hard_iface *hard_iface);
 	void (*bat_orig_free)(struct batadv_orig_node *orig_node);
 	int (*bat_orig_add_if)(struct batadv_orig_node *orig_node,
 			       int max_if_num);
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 08/12] batman-adv: add B.A.T.M.A.N. IV bat_{orig, neigh}_dump implementations

[Andrew Lunn]

From: Matthias Schiffer <mschiffer@universe-factory.net>

Signed-off-by: Matthias Schiffer <mschiffer@universe-factory.net>
---
 include/uapi/linux/batman_adv.h |   2 +
 net/batman-adv/bat_iv_ogm.c     | 274 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 276 insertions(+)

diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
index 35d8e8c..baf4ac8 100644
--- a/include/uapi/linux/batman_adv.h
+++ b/include/uapi/linux/batman_adv.h
@@ -76,6 +76,8 @@ enum {
 	BATADV_ATTR_TT_FLAGS,
 	BATADV_ATTR_FLAG_BEST,
 	BATADV_ATTR_LAST_SEEN_MSECS,
+	BATADV_ATTR_NEIGH_ADDRESS,
+	BATADV_ATTR_TQ,
 	__BATADV_ATTR_MAX,
 };
 
diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index 4815db9..632e60a 100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -48,10 +48,12 @@
 #include <linux/string.h>
 #include <linux/types.h>
 #include <linux/workqueue.h>
+#include <uapi/linux/batman_adv.h>
 
 #include "bitarray.h"
 #include "hard-interface.h"
 #include "hash.h"
+#include "netlink.h"
 #include "network-coding.h"
 #include "originator.h"
 #include "packet.h"
@@ -1975,6 +1977,177 @@ next:
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+static bool
+batadv_iv_ogm_neigh_get_tq_avg(struct batadv_neigh_node *neigh_node,
+			       struct batadv_hard_iface *if_outgoing,
+			       u8 *tq_avg)
+{
+	struct batadv_neigh_ifinfo *n_ifinfo;
+
+	n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
+	if (!n_ifinfo)
+		return false;
+
+	*tq_avg = n_ifinfo->bat_iv.tq_avg;
+	batadv_neigh_ifinfo_put(n_ifinfo);
+
+	return true;
+}
+
+static int
+batadv_iv_ogm_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
+				 struct batadv_priv *bat_priv,
+				 struct batadv_hard_iface *if_outgoing,
+				 struct batadv_orig_node *orig_node,
+				 struct batadv_neigh_node *neigh_node,
+				 bool best)
+{
+	void *hdr;
+	u8 tq_avg;
+	unsigned int last_seen_msecs;
+
+	last_seen_msecs = jiffies_to_msecs(jiffies - orig_node->last_seen);
+
+	if (!batadv_iv_ogm_neigh_get_tq_avg(neigh_node, if_outgoing, &tq_avg))
+		return 0;
+
+	if (if_outgoing != BATADV_IF_DEFAULT &&
+	    if_outgoing != neigh_node->if_incoming)
+		return 0;
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
+			  NLM_F_MULTI, BATADV_CMD_GET_ORIGINATORS);
+	if (!hdr)
+		return -ENOBUFS;
+
+	if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
+		    orig_node->orig) ||
+	    nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
+		    neigh_node->addr) ||
+	    nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
+			neigh_node->if_incoming->net_dev->ifindex) ||
+	    nla_put_u8(msg, BATADV_ATTR_TQ, tq_avg) ||
+	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
+			last_seen_msecs))
+		goto nla_put_failure;
+
+	if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
+		goto nla_put_failure;
+
+	genlmsg_end(msg, hdr);
+	return 0;
+
+ nla_put_failure:
+	genlmsg_cancel(msg, hdr);
+	return -EMSGSIZE;
+}
+
+static int
+batadv_iv_ogm_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
+			      struct batadv_priv *bat_priv,
+			      struct batadv_hard_iface *if_outgoing,
+			      struct batadv_orig_node *orig_node, int *sub_s)
+{
+	struct batadv_neigh_node *neigh_node_best;
+	struct batadv_neigh_node *neigh_node;
+	int sub = 0;
+	bool best;
+	u8 tq_avg_best;
+
+	neigh_node_best = batadv_orig_router_get(orig_node, if_outgoing);
+	if (!neigh_node_best)
+		goto out;
+
+	if (!batadv_iv_ogm_neigh_get_tq_avg(neigh_node_best, if_outgoing,
+					    &tq_avg_best))
+		goto out;
+
+	if (tq_avg_best == 0)
+		goto out;
+
+	hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
+		if (sub++ < *sub_s)
+			continue;
+
+		best = (neigh_node == neigh_node_best);
+
+		if (batadv_iv_ogm_orig_dump_subentry(msg, portid, seq,
+						     bat_priv, if_outgoing,
+						     orig_node, neigh_node,
+						     best)) {
+			batadv_neigh_node_put(neigh_node_best);
+
+			*sub_s = sub - 1;
+			return -EMSGSIZE;
+		}
+	}
+
+ out:
+	if (neigh_node_best)
+		batadv_neigh_node_put(neigh_node_best);
+
+	*sub_s = 0;
+	return 0;
+}
+
+static int
+batadv_iv_ogm_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
+			       struct batadv_priv *bat_priv,
+			       struct batadv_hard_iface *if_outgoing,
+			       struct hlist_head *head, int *idx_s, int *sub)
+{
+	struct batadv_orig_node *orig_node;
+	int idx = 0;
+
+	rcu_read_lock();
+	hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
+		if (idx++ < *idx_s)
+			continue;
+
+		if (batadv_iv_ogm_orig_dump_entry(msg, portid, seq, bat_priv,
+						  if_outgoing, orig_node,
+						  sub)) {
+			rcu_read_unlock();
+			*idx_s = idx - 1;
+			return -EMSGSIZE;
+		}
+	}
+	rcu_read_unlock();
+
+	*idx_s = 0;
+	*sub = 0;
+	return 0;
+}
+
+static void
+batadv_iv_ogm_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
+			struct batadv_priv *bat_priv,
+			struct batadv_hard_iface *if_outgoing)
+{
+	struct batadv_hashtable *hash = bat_priv->orig_hash;
+	struct hlist_head *head;
+	int bucket = cb->args[0];
+	int idx = cb->args[1];
+	int sub = cb->args[2];
+	int portid = NETLINK_CB(cb->skb).portid;
+
+	while (bucket < hash->size) {
+		head = &hash->table[bucket];
+
+		if (batadv_iv_ogm_orig_dump_bucket(msg, portid,
+						   cb->nlh->nlmsg_seq,
+						   bat_priv, if_outgoing, head,
+						   &idx, &sub))
+			break;
+
+		bucket++;
+	}
+
+	cb->args[0] = bucket;
+	cb->args[1] = idx;
+	cb->args[2] = sub;
+}
+
 /**
  * batadv_iv_hardif_neigh_print - print a single hop neighbour node
  * @seq: neighbour table seq_file struct
@@ -2026,6 +2199,105 @@ static void batadv_iv_neigh_print(struct batadv_priv *bat_priv,
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+static int
+batadv_iv_ogm_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
+			       struct batadv_hardif_neigh_node *hardif_neigh)
+{
+	void *hdr;
+	unsigned int last_seen_msecs;
+
+	last_seen_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen);
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
+			  BATADV_CMD_GET_NEIGHBORS);
+	if (!hdr)
+		return -ENOBUFS;
+
+	if (nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
+		    hardif_neigh->addr) ||
+	    nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
+			hardif_neigh->if_incoming->net_dev->ifindex) ||
+	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
+			last_seen_msecs))
+		goto nla_put_failure;
+
+	genlmsg_end(msg, hdr);
+	return 0;
+
+ nla_put_failure:
+	genlmsg_cancel(msg, hdr);
+	return -EMSGSIZE;
+}
+
+static int
+batadv_iv_ogm_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
+				struct batadv_priv *bat_priv,
+				struct batadv_hard_iface *hard_iface,
+				int *idx_s)
+{
+	struct batadv_hardif_neigh_node *hardif_neigh;
+	int idx = 0;
+
+	hlist_for_each_entry_rcu(hardif_neigh,
+				 &hard_iface->neigh_list, list) {
+		if (idx++ < *idx_s)
+			continue;
+
+		if (batadv_iv_ogm_neigh_dump_neigh(msg, portid, seq,
+						   hardif_neigh)) {
+			*idx_s = idx - 1;
+			return -EMSGSIZE;
+		}
+	}
+
+	*idx_s = 0;
+	return 0;
+}
+
+static void
+batadv_iv_ogm_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
+			 struct batadv_priv *bat_priv,
+			 struct batadv_hard_iface *single_hardif)
+{
+	struct batadv_hard_iface *hard_iface;
+	int i_hardif = 0;
+	int i_hardif_s = cb->args[0];
+	int idx = cb->args[1];
+	int portid = NETLINK_CB(cb->skb).portid;
+
+	rcu_read_lock();
+	if (single_hardif) {
+		if (i_hardif_s == 0) {
+			if (batadv_iv_ogm_neigh_dump_hardif(msg, portid,
+							    cb->nlh->nlmsg_seq,
+							    bat_priv,
+							    single_hardif,
+							    &idx) == 0)
+				i_hardif++;
+		}
+	} else {
+		list_for_each_entry_rcu(hard_iface, &batadv_hardif_list,
+					list) {
+			if (hard_iface->soft_iface != bat_priv->soft_iface)
+				continue;
+
+			if (i_hardif++ < i_hardif_s)
+				continue;
+
+			if (batadv_iv_ogm_neigh_dump_hardif(
+				    msg, portid, cb->nlh->nlmsg_seq,
+				    bat_priv, hard_iface, &idx)) {
+				i_hardif--;
+				break;
+			}
+		}
+	}
+	rcu_read_unlock();
+
+	cb->args[0] = i_hardif;
+	cb->args[1] = idx;
+}
+
 /**
  * batadv_iv_ogm_neigh_cmp - compare the metrics of two neighbors
  * @neigh1: the first neighbor object of the comparison
@@ -2125,7 +2397,9 @@ static struct batadv_algo_ops batadv_batman_iv __read_mostly = {
 	.bat_neigh_cmp = batadv_iv_ogm_neigh_cmp,
 	.bat_neigh_is_similar_or_better = batadv_iv_ogm_neigh_is_sob,
 	.bat_neigh_print = batadv_iv_neigh_print,
+	.bat_neigh_dump = batadv_iv_ogm_neigh_dump,
 	.bat_orig_print = batadv_iv_ogm_orig_print,
+	.bat_orig_dump = batadv_iv_ogm_orig_dump,
 	.bat_orig_free = batadv_iv_ogm_orig_free,
 	.bat_orig_add_if = batadv_iv_ogm_orig_add_if,
 	.bat_orig_del_if = batadv_iv_ogm_orig_del_if,
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 09/12] batman-adv: add B.A.T.M.A.N. V bat_{orig, neigh}_dump implementations

[Andrew Lunn]

From: Matthias Schiffer <mschiffer@universe-factory.net>

Signed-off-by: Matthias Schiffer <mschiffer@universe-factory.net>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
v2: Add missing includes
---
 include/uapi/linux/batman_adv.h |   1 +
 net/batman-adv/bat_iv_ogm.c     |   3 +
 net/batman-adv/bat_v.c          | 262 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 266 insertions(+)

diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
index baf4ac8..27f277f 100644
--- a/include/uapi/linux/batman_adv.h
+++ b/include/uapi/linux/batman_adv.h
@@ -78,6 +78,7 @@ enum {
 	BATADV_ATTR_LAST_SEEN_MSECS,
 	BATADV_ATTR_NEIGH_ADDRESS,
 	BATADV_ATTR_TQ,
+	BATADV_ATTR_THROUGHPUT,
 	__BATADV_ATTR_MAX,
 };
 
diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index 632e60a..9abfdbb 100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -35,6 +35,7 @@
 #include <linux/kref.h>
 #include <linux/lockdep.h>
 #include <linux/netdevice.h>
+#include <linux/netlink.h>
 #include <linux/pkt_sched.h>
 #include <linux/printk.h>
 #include <linux/random.h>
@@ -48,6 +49,8 @@
 #include <linux/string.h>
 #include <linux/types.h>
 #include <linux/workqueue.h>
+#include <net/genetlink.h>
+#include <net/netlink.h>
 #include <uapi/linux/batman_adv.h>
 
 #include "bitarray.h"
diff --git a/net/batman-adv/bat_v.c b/net/batman-adv/bat_v.c
index c16cd44..5daa300 100644
--- a/net/batman-adv/bat_v.c
+++ b/net/batman-adv/bat_v.c
@@ -20,24 +20,33 @@
 
 #include <linux/atomic.h>
 #include <linux/bug.h>
+#include <linux/errno.h>
+#include <linux/if_ether.h>
 #include <linux/cache.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/netdevice.h>
+#include <linux/netlink.h>
 #include <linux/rculist.h>
 #include <linux/rcupdate.h>
 #include <linux/seq_file.h>
 #include <linux/stddef.h>
 #include <linux/types.h>
 #include <linux/workqueue.h>
+#include <net/genetlink.h>
+#include <net/netlink.h>
+#include <uapi/linux/batman_adv.h>
 
 #include "bat_v_elp.h"
 #include "bat_v_ogm.h"
 #include "hard-interface.h"
 #include "hash.h"
+#include "netlink.h"
 #include "originator.h"
 #include "packet.h"
 
+struct sk_buff;
+
 static void batadv_v_iface_activate(struct batadv_hard_iface *hard_iface)
 {
 	struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
@@ -203,6 +212,107 @@ static void batadv_v_neigh_print(struct batadv_priv *bat_priv,
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+static int
+batadv_v_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
+			  struct batadv_hardif_neigh_node *hardif_neigh)
+{
+	void *hdr;
+	unsigned int last_seen_msecs;
+	u32 throughput;
+
+	last_seen_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen);
+	throughput = ewma_throughput_read(&hardif_neigh->bat_v.throughput);
+	throughput = throughput * 100;
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
+			  BATADV_CMD_GET_NEIGHBORS);
+	if (!hdr)
+		return -ENOBUFS;
+
+	if (nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
+		    hardif_neigh->addr) ||
+	    nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
+			hardif_neigh->if_incoming->net_dev->ifindex) ||
+	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
+			last_seen_msecs) ||
+	    nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, throughput))
+		goto nla_put_failure;
+
+	genlmsg_end(msg, hdr);
+	return 0;
+
+ nla_put_failure:
+	genlmsg_cancel(msg, hdr);
+	return -EMSGSIZE;
+}
+
+static int
+batadv_v_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
+			   struct batadv_priv *bat_priv,
+			   struct batadv_hard_iface *hard_iface,
+			   int *idx_s)
+{
+	struct batadv_hardif_neigh_node *hardif_neigh;
+	int idx = 0;
+
+	hlist_for_each_entry_rcu(hardif_neigh,
+				 &hard_iface->neigh_list, list) {
+		if (idx++ < *idx_s)
+			continue;
+
+		if (batadv_v_neigh_dump_neigh(msg, portid, seq, hardif_neigh)) {
+			*idx_s = idx - 1;
+			return -EMSGSIZE;
+		}
+	}
+
+	*idx_s = 0;
+	return 0;
+}
+
+static void
+batadv_v_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
+		    struct batadv_priv *bat_priv,
+		    struct batadv_hard_iface *single_hardif)
+{
+	struct batadv_hard_iface *hard_iface;
+	int i_hardif = 0;
+	int i_hardif_s = cb->args[0];
+	int idx = cb->args[1];
+	int portid = NETLINK_CB(cb->skb).portid;
+
+	rcu_read_lock();
+	if (single_hardif) {
+		if (i_hardif_s == 0) {
+			if (batadv_v_neigh_dump_hardif(msg, portid,
+						       cb->nlh->nlmsg_seq,
+						       bat_priv, single_hardif,
+						       &idx) == 0)
+				i_hardif++;
+		}
+	} else {
+		list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) {
+			if (hard_iface->soft_iface != bat_priv->soft_iface)
+				continue;
+
+			if (i_hardif++ < i_hardif_s)
+				continue;
+
+			if (batadv_v_neigh_dump_hardif(msg, portid,
+						       cb->nlh->nlmsg_seq,
+						       bat_priv, hard_iface,
+						       &idx)) {
+				i_hardif--;
+				break;
+			}
+		}
+	}
+	rcu_read_unlock();
+
+	cb->args[0] = i_hardif;
+	cb->args[1] = idx;
+}
+
 /**
  * batadv_v_orig_print - print the originator table
  * @bat_priv: the bat priv with all the soft interface information
@@ -270,6 +380,156 @@ next:
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+static int
+batadv_v_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
+			    struct batadv_priv *bat_priv,
+			    struct batadv_hard_iface *if_outgoing,
+			    struct batadv_orig_node *orig_node,
+			    struct batadv_neigh_node *neigh_node,
+			    bool best)
+{
+	struct batadv_neigh_ifinfo *n_ifinfo;
+	unsigned int last_seen_msecs;
+	u32 throughput;
+	void *hdr;
+
+	n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing);
+	if (!n_ifinfo)
+		return 0;
+
+	throughput = n_ifinfo->bat_v.throughput * 100;
+
+	batadv_neigh_ifinfo_put(n_ifinfo);
+
+	last_seen_msecs = jiffies_to_msecs(jiffies - orig_node->last_seen);
+
+	if (if_outgoing != BATADV_IF_DEFAULT &&
+	    if_outgoing != neigh_node->if_incoming)
+		return 0;
+
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI,
+			  BATADV_CMD_GET_ORIGINATORS);
+	if (!hdr)
+		return -ENOBUFS;
+
+	if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, orig_node->orig) ||
+	    nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN,
+		    neigh_node->addr) ||
+	    nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX,
+			neigh_node->if_incoming->net_dev->ifindex) ||
+	    nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, throughput) ||
+	    nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS,
+			last_seen_msecs))
+		goto nla_put_failure;
+
+	if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST))
+		goto nla_put_failure;
+
+	genlmsg_end(msg, hdr);
+	return 0;
+
+ nla_put_failure:
+	genlmsg_cancel(msg, hdr);
+	return -EMSGSIZE;
+}
+
+static int
+batadv_v_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
+			 struct batadv_priv *bat_priv,
+			 struct batadv_hard_iface *if_outgoing,
+			 struct batadv_orig_node *orig_node, int *sub_s)
+{
+	struct batadv_neigh_node *neigh_node_best;
+	struct batadv_neigh_node *neigh_node;
+	int sub = 0;
+	bool best;
+
+	neigh_node_best = batadv_orig_router_get(orig_node, if_outgoing);
+	if (!neigh_node_best)
+		goto out;
+
+	hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) {
+		if (sub++ < *sub_s)
+			continue;
+
+		best = (neigh_node == neigh_node_best);
+
+		if (batadv_v_orig_dump_subentry(msg, portid, seq, bat_priv,
+						if_outgoing, orig_node,
+						neigh_node, best)) {
+			batadv_neigh_node_put(neigh_node_best);
+
+			*sub_s = sub - 1;
+			return -EMSGSIZE;
+		}
+	}
+
+ out:
+	if (neigh_node_best)
+		batadv_neigh_node_put(neigh_node_best);
+
+	*sub_s = 0;
+	return 0;
+}
+
+static int
+batadv_v_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
+			  struct batadv_priv *bat_priv,
+			  struct batadv_hard_iface *if_outgoing,
+			  struct hlist_head *head, int *idx_s, int *sub)
+{
+	struct batadv_orig_node *orig_node;
+	int idx = 0;
+
+	rcu_read_lock();
+	hlist_for_each_entry_rcu(orig_node, head, hash_entry) {
+		if (idx++ < *idx_s)
+			continue;
+
+		if (batadv_v_orig_dump_entry(msg, portid, seq, bat_priv,
+					     if_outgoing, orig_node, sub)) {
+			rcu_read_unlock();
+			*idx_s = idx - 1;
+			return -EMSGSIZE;
+		}
+	}
+	rcu_read_unlock();
+
+	*idx_s = 0;
+	*sub = 0;
+	return 0;
+}
+
+static void
+batadv_v_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
+		   struct batadv_priv *bat_priv,
+		   struct batadv_hard_iface *if_outgoing)
+{
+	struct batadv_hashtable *hash = bat_priv->orig_hash;
+	struct hlist_head *head;
+	int bucket = cb->args[0];
+	int idx = cb->args[1];
+	int sub = cb->args[2];
+	int portid = NETLINK_CB(cb->skb).portid;
+
+	while (bucket < hash->size) {
+		head = &hash->table[bucket];
+
+		if (batadv_v_orig_dump_bucket(msg, portid,
+					      cb->nlh->nlmsg_seq,
+					      bat_priv, if_outgoing, head, &idx,
+					      &sub))
+			break;
+
+		bucket++;
+	}
+
+	cb->args[0] = bucket;
+	cb->args[1] = idx;
+	cb->args[2] = sub;
+}
+
 static int batadv_v_neigh_cmp(struct batadv_neigh_node *neigh1,
 			      struct batadv_hard_iface *if_outgoing1,
 			      struct batadv_neigh_node *neigh2,
@@ -333,9 +593,11 @@ static struct batadv_algo_ops batadv_batman_v __read_mostly = {
 	.bat_primary_iface_set = batadv_v_primary_iface_set,
 	.bat_hardif_neigh_init = batadv_v_hardif_neigh_init,
 	.bat_orig_print = batadv_v_orig_print,
+	.bat_orig_dump = batadv_v_orig_dump,
 	.bat_neigh_cmp = batadv_v_neigh_cmp,
 	.bat_neigh_is_similar_or_better = batadv_v_neigh_is_sob,
 	.bat_neigh_print = batadv_v_neigh_print,
+	.bat_neigh_dump = batadv_v_neigh_dump,
 };
 
 /**
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 10/12] batman-adv: Indicate netlink socket can be used with netns.

[Andrew Lunn]

Set the netnsof flag on the family structure, indicating it can
be used with different network name spaces.

Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
 net/batman-adv/netlink.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c
index a01bdf5..e188c2b 100644
--- a/net/batman-adv/netlink.c
+++ b/net/batman-adv/netlink.c
@@ -44,6 +44,7 @@ struct genl_family batadv_netlink_family = {
 	.name = BATADV_NL_NAME,
 	.version = 1,
 	.maxattr = BATADV_ATTR_MAX,
+	.netnsok = true,
 };
 
 static int
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 11/12] batman-adv: add B.A.T.M.A.N. Dump gateways via netlink

[Andrew Lunn]

Dump the list of gateways via the netlink socket.

Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
v2: Add missing includes and forward declarations.
---
 include/uapi/linux/batman_adv.h |   4 ++
 net/batman-adv/gateway_client.c | 131 ++++++++++++++++++++++++++++++++++++++++
 net/batman-adv/gateway_client.h |   2 +
 net/batman-adv/netlink.c        |   9 ++-
 4 files changed, 145 insertions(+), 1 deletion(-)

diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
index 27f277f..cce4955 100644
--- a/include/uapi/linux/batman_adv.h
+++ b/include/uapi/linux/batman_adv.h
@@ -79,6 +79,9 @@ enum {
 	BATADV_ATTR_NEIGH_ADDRESS,
 	BATADV_ATTR_TQ,
 	BATADV_ATTR_THROUGHPUT,
+	BATADV_ATTR_BANDWIDTH_UP,
+	BATADV_ATTR_BANDWIDTH_DOWN,
+	BATADV_ATTR_ROUTER,
 	__BATADV_ATTR_MAX,
 };
 
@@ -93,6 +96,7 @@ enum {
 	BATADV_CMD_GET_TRANSTABLE_GLOBAL,
 	BATADV_CMD_GET_ORIGINATORS,
 	BATADV_CMD_GET_NEIGHBORS,
+	BATADV_CMD_GET_GATEWAYS,
 	__BATADV_CMD_MAX,
 };
 
diff --git a/net/batman-adv/gateway_client.c b/net/batman-adv/gateway_client.c
index 31ba24e..7f38aea 100644
--- a/net/batman-adv/gateway_client.c
+++ b/net/batman-adv/gateway_client.c
@@ -20,6 +20,7 @@
 
 #include <linux/atomic.h>
 #include <linux/byteorder/generic.h>
+#include <linux/errno.h>
 #include <linux/etherdevice.h>
 #include <linux/fs.h>
 #include <linux/if_ether.h>
@@ -31,6 +32,7 @@
 #include <linux/kref.h>
 #include <linux/list.h>
 #include <linux/netdevice.h>
+#include <linux/netlink.h>
 #include <linux/rculist.h>
 #include <linux/rcupdate.h>
 #include <linux/seq_file.h>
@@ -39,12 +41,18 @@
 #include <linux/spinlock.h>
 #include <linux/stddef.h>
 #include <linux/udp.h>
+#include <net/genetlink.h>
+#include <net/netlink.h>
+#include <net/sock.h>
+#include <uapi/linux/batman_adv.h>
 
 #include "gateway_common.h"
 #include "hard-interface.h"
+#include "netlink.h"
 #include "originator.h"
 #include "packet.h"
 #include "routing.h"
+#include "soft-interface.h"
 #include "sysfs.h"
 #include "translation-table.h"
 
@@ -662,6 +670,129 @@ out:
 	return 0;
 }
 
+static int
+batadv_gw_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
+		     struct batadv_priv *bat_priv,
+		     struct batadv_gw_node *gw_node)
+{
+	struct batadv_neigh_ifinfo *router_ifinfo = NULL;
+	struct batadv_neigh_node *router;
+	struct batadv_gw_node *curr_gw;
+	int ret = -EINVAL;
+	void *hdr;
+
+	router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
+	if (!router)
+		goto out;
+
+	router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
+	if (!router_ifinfo)
+		goto out;
+
+	curr_gw = batadv_gw_get_selected_gw_node(bat_priv);
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
+			  NLM_F_MULTI, BATADV_CMD_GET_GATEWAYS);
+	if (!hdr) {
+		ret = -ENOBUFS;
+		goto out;
+	}
+
+	ret = -EMSGSIZE;
+
+	if (curr_gw == gw_node)
+		if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) {
+			genlmsg_cancel(msg, hdr);
+			goto out;
+		}
+
+	if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN,
+		    gw_node->orig_node->orig) ||
+	    nla_put_u8(msg, BATADV_ATTR_TQ, router_ifinfo->bat_iv.tq_avg) ||
+	    nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN,
+		    router->addr) ||
+	    nla_put_string(msg, BATADV_ATTR_HARD_IFNAME,
+			   router->if_incoming->net_dev->name) ||
+	    nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN,
+			gw_node->bandwidth_down) ||
+	    nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP,
+			gw_node->bandwidth_up)) {
+		genlmsg_cancel(msg, hdr);
+		goto out;
+	}
+
+	genlmsg_end(msg, hdr);
+	ret = 0;
+
+out:
+	if (router_ifinfo)
+		batadv_neigh_ifinfo_put(router_ifinfo);
+	if (router)
+		batadv_neigh_node_put(router);
+	return ret;
+}
+
+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);
+	int portid = NETLINK_CB(cb->skb).portid;
+	struct net_device *soft_iface = NULL;
+	struct batadv_gw_node *gw_node;
+	struct batadv_priv *bat_priv;
+	int idx_skip = cb->args[0];
+	int ifindex;
+	int idx = 0;
+	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;
+	}
+
+	rcu_read_lock();
+	hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
+		if (idx++ < idx_skip)
+			continue;
+
+		if (batadv_gw_dump_entry(msg, portid, cb->nlh->nlmsg_seq,
+					 bat_priv, gw_node)) {
+			idx_skip = idx - 1;
+			ret = msg->len;
+			goto unlock;
+		}
+	}
+
+	idx_skip = idx;
+	ret = msg->len;
+unlock:
+	rcu_read_unlock();
+
+out:
+	if (primary_if)
+		batadv_hardif_put(primary_if);
+	if (soft_iface)
+		dev_put(soft_iface);
+
+	cb->args[0] = idx_skip;
+
+	return ret;
+}
+
 /**
  * batadv_gw_dhcp_recipient_get - check if a packet is a DHCP message
  * @skb: the packet to check
diff --git a/net/batman-adv/gateway_client.h b/net/batman-adv/gateway_client.h
index 582dd8c..f1b2d39 100644
--- a/net/batman-adv/gateway_client.h
+++ b/net/batman-adv/gateway_client.h
@@ -23,6 +23,7 @@
 #include <linux/types.h>
 
 struct batadv_tvlv_gateway_data;
+struct netlink_callback;
 struct seq_file;
 struct sk_buff;
 
@@ -40,6 +41,7 @@ void batadv_gw_node_delete(struct batadv_priv *bat_priv,
 			   struct batadv_orig_node *orig_node);
 void batadv_gw_node_free(struct batadv_priv *bat_priv);
 int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset);
+int batadv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb);
 bool batadv_gw_out_of_range(struct batadv_priv *bat_priv, struct sk_buff *skb);
 enum batadv_dhcp_recipient
 batadv_gw_dhcp_recipient_get(struct sk_buff *skb, unsigned int *header_len,
diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c
index e188c2b..8fe7df5 100644
--- a/net/batman-adv/netlink.c
+++ b/net/batman-adv/netlink.c
@@ -33,8 +33,9 @@
 #include <net/sock.h>
 #include <uapi/linux/batman_adv.h>
 
-#include "originator.h"
+#include "gateway_client.h"
 #include "hard-interface.h"
+#include "originator.h"
 #include "soft-interface.h"
 #include "translation-table.h"
 
@@ -270,6 +271,12 @@ static struct genl_ops batadv_netlink_ops[] = {
 		.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,
+	},
 };
 
 void __init batadv_netlink_register(void)
-- 
2.8.0.rc3

[B.A.T.M.A.N.] [PATCHv4 12/12] batman-adv: add B.A.T.M.A.N. Dump BLA claims via netlink

[Andrew Lunn]

Dump the list of bridge loop avoidance claims via the netlink socket.

Signed-off-by: Andrew Lunn <andrew@lunn.ch>
---
v2: Missing includes and forward declarations
    Fix exit on error when dumping.
---
 include/uapi/linux/batman_adv.h        |   6 ++
 net/batman-adv/bridge_loop_avoidance.c | 166 +++++++++++++++++++++++++++++++++
 net/batman-adv/bridge_loop_avoidance.h |  10 +-
 net/batman-adv/netlink.c               |   7 ++
 4 files changed, 188 insertions(+), 1 deletion(-)

diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
index cce4955..6a97a2c 100644
--- a/include/uapi/linux/batman_adv.h
+++ b/include/uapi/linux/batman_adv.h
@@ -82,6 +82,11 @@ enum {
 	BATADV_ATTR_BANDWIDTH_UP,
 	BATADV_ATTR_BANDWIDTH_DOWN,
 	BATADV_ATTR_ROUTER,
+	BATADV_ATTR_BLA_OWN,
+	BATADV_ATTR_BLA_ADDRESS,
+	BATADV_ATTR_BLA_VID,
+	BATADV_ATTR_BLA_BACKBONE,
+	BATADV_ATTR_BLA_CRC,
 	__BATADV_ATTR_MAX,
 };
 
@@ -97,6 +102,7 @@ enum {
 	BATADV_CMD_GET_ORIGINATORS,
 	BATADV_CMD_GET_NEIGHBORS,
 	BATADV_CMD_GET_GATEWAYS,
+	BATADV_CMD_GET_BLA_CLAIM,
 	__BATADV_CMD_MAX,
 };
 
diff --git a/net/batman-adv/bridge_loop_avoidance.c b/net/batman-adv/bridge_loop_avoidance.c
index 748a9ea..99458f3 100644
--- a/net/batman-adv/bridge_loop_avoidance.c
+++ b/net/batman-adv/bridge_loop_avoidance.c
@@ -35,6 +35,7 @@
 #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>
@@ -45,11 +46,17 @@
 #include <linux/string.h>
 #include <linux/workqueue.h>
 #include <net/arp.h>
+#include <net/genetlink.h>
+#include <net/netlink.h>
+#include <net/sock.h>
+#include <uapi/linux/batman_adv.h>
 
 #include "hard-interface.h"
 #include "hash.h"
+#include "netlink.h"
 #include "originator.h"
 #include "packet.h"
+#include "soft-interface.h"
 #include "sysfs.h"
 #include "translation-table.h"
 
@@ -1983,6 +1990,165 @@ out:
 }
 
 /**
+ * batadv_bla_claim_dump_entry - dump one entry of the backbone table
+ * to a netlink socket
+ * @msg: buffer for the message
+ * @portid: netlink port
+ * @seq: Sequence number of netlink message
+ * @primary_if: primary interface
+ * @claim: entry to dump
+ *
+ * Return: 0 or error code.
+ */
+static int
+batadv_bla_claim_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
+			    struct batadv_hard_iface *primary_if,
+			    struct batadv_bla_claim *claim)
+{
+	u8 *primary_addr = primary_if->net_dev->dev_addr;
+	u16 backbone_crc;
+	bool is_own;
+	void *hdr;
+	int ret = -EINVAL;
+
+	hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family,
+			  NLM_F_MULTI, BATADV_CMD_GET_BLA_CLAIM);
+	if (!hdr) {
+		ret = -ENOBUFS;
+		goto out;
+	}
+
+	is_own = batadv_compare_eth(claim->backbone_gw->orig,
+				    primary_addr);
+
+	spin_lock_bh(&claim->backbone_gw->crc_lock);
+	backbone_crc = claim->backbone_gw->crc;
+	spin_unlock_bh(&claim->backbone_gw->crc_lock);
+
+	if (is_own)
+		if (nla_put_flag(msg, BATADV_ATTR_BLA_OWN)) {
+			genlmsg_cancel(msg, hdr);
+			goto out;
+		}
+
+	if (nla_put(msg, BATADV_ATTR_BLA_ADDRESS, ETH_ALEN, claim->addr) ||
+	    nla_put_u16(msg, BATADV_ATTR_BLA_VID, claim->vid) ||
+	    nla_put(msg, BATADV_ATTR_BLA_BACKBONE, ETH_ALEN,
+		    claim->backbone_gw->orig) ||
+	    nla_put_u16(msg, BATADV_ATTR_BLA_CRC,
+			backbone_crc)) {
+		genlmsg_cancel(msg, hdr);
+		goto out;
+	}
+
+	genlmsg_end(msg, hdr);
+	ret = 0;
+
+out:
+	return ret;
+}
+
+/**
+ * batadv_bla_claim_dump_bucket - dump one bucket of the backbone table
+ * to a netlink socket
+ * @msg: buffer for the message
+ * @portid: netlink port
+ * @seq: Sequence number of netlink message
+ * @primary_if: primary interface
+ * @head: bucket to dump
+ * @idx_skip: How many entries to skip
+ *
+ * Return: always 0.
+ */
+static int
+batadv_bla_claim_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
+			     struct batadv_hard_iface *primary_if,
+			     struct hlist_head *head, int *idx_skip)
+{
+	struct batadv_bla_claim *claim;
+	int idx = 0;
+
+	rcu_read_lock();
+	hlist_for_each_entry_rcu(claim, head, hash_entry) {
+		if (idx++ < *idx_skip)
+			continue;
+		if (batadv_bla_claim_dump_entry(msg, portid, seq,
+						primary_if, claim)) {
+			*idx_skip = idx - 1;
+			goto unlock;
+		}
+	}
+
+	*idx_skip = idx;
+unlock:
+	rcu_read_unlock();
+	return 0;
+}
+
+/**
+ * batadv_bla_claim_dump - dump backbone table to a netlink socket
+ * @msg: buffer for the message
+ * @cb: callback structure containing arguments
+ *
+ * Return: message length.
+ */
+int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb)
+{
+	struct batadv_hard_iface *primary_if = NULL;
+	int portid = NETLINK_CB(cb->skb).portid;
+	struct net *net = sock_net(cb->skb->sk);
+	struct net_device *soft_iface = NULL;
+	struct batadv_hashtable *hash;
+	struct batadv_priv *bat_priv;
+	int bucket = cb->args[0];
+	struct hlist_head *head;
+	int idx = cb->args[1];
+	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);
+	hash = bat_priv->bla.claim_hash;
+
+	primary_if = batadv_primary_if_get_selected(bat_priv);
+	if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) {
+		ret = -ENOENT;
+		goto out;
+	}
+
+	while (bucket < hash->size) {
+		head = &hash->table[bucket];
+
+		if (batadv_bla_claim_dump_bucket(msg, portid,
+						 cb->nlh->nlmsg_seq,
+						 primary_if, head, &idx))
+			break;
+		bucket++;
+	}
+
+	cb->args[0] = bucket;
+	cb->args[1] = idx;
+
+	ret = msg->len;
+
+out:
+	if (primary_if)
+		batadv_hardif_put(primary_if);
+
+	return 0;
+}
+
+/**
  * batadv_bla_backbone_table_seq_print_text - print the backbone table in a seq
  *  file
  * @seq: seq file to print on
diff --git a/net/batman-adv/bridge_loop_avoidance.h b/net/batman-adv/bridge_loop_avoidance.h
index 0f01dae..a80b9e9 100644
--- a/net/batman-adv/bridge_loop_avoidance.h
+++ b/net/batman-adv/bridge_loop_avoidance.h
@@ -23,6 +23,7 @@
 #include <linux/types.h>
 
 struct net_device;
+struct netlink_callback;
 struct seq_file;
 struct sk_buff;
 
@@ -35,6 +36,7 @@ bool batadv_bla_is_backbone_gw(struct sk_buff *skb,
 			       struct batadv_orig_node *orig_node,
 			       int hdr_size);
 int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset);
+int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb);
 int batadv_bla_backbone_table_seq_print_text(struct seq_file *seq,
 					     void *offset);
 bool batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, u8 *orig,
@@ -47,7 +49,7 @@ void batadv_bla_update_orig_address(struct batadv_priv *bat_priv,
 void batadv_bla_status_update(struct net_device *net_dev);
 int batadv_bla_init(struct batadv_priv *bat_priv);
 void batadv_bla_free(struct batadv_priv *bat_priv);
-
+int batadv_bla_claim_dump(struct sk_buff *msg, struct netlink_callback *cb);
 #define BATADV_BLA_CRC_INIT	0
 #else /* ifdef CONFIG_BATMAN_ADV_BLA */
 
@@ -112,6 +114,12 @@ static inline void batadv_bla_free(struct batadv_priv *bat_priv)
 {
 }
 
+static inline int batadv_bla_claim_dump(struct sk_buff *msg,
+					struct netlink_callback *cb)
+{
+	return -EOPNOTSUPP;
+}
+
 #endif /* ifdef CONFIG_BATMAN_ADV_BLA */
 
 #endif /* ifndef _NET_BATMAN_ADV_BLA_H_ */
diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c
index 8fe7df5..671d5b6 100644
--- a/net/batman-adv/netlink.c
+++ b/net/batman-adv/netlink.c
@@ -33,6 +33,7 @@
 #include <net/sock.h>
 #include <uapi/linux/batman_adv.h>
 
+#include "bridge_loop_avoidance.h"
 #include "gateway_client.h"
 #include "hard-interface.h"
 #include "originator.h"
@@ -277,6 +278,12 @@ static struct genl_ops batadv_netlink_ops[] = {
 		.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,
+	},
 };
 
 void __init batadv_netlink_register(void)
-- 
2.8.0.rc3

Re: [B.A.T.M.A.N.] [PATCHv4 00/12] netns and netlink support

[Sven Eckelmann]

[-- Attachment #1.1: Type: text/plain, Size: 48822 bytes --]

=2D-nextPart1849581.vX7EfrdFzp
Content-Transfer-Encoding: 7Bit
Content-Type: text/plain; charset="us-ascii"

On Monday 09 May 2016 20:07:07 Andrew Lunn wrote:
> This patchset completes netns support, by disabling debugfs entries
> when not in the default name space, and correctly handling interface
> stack loops when the parent is in a different name space.
> 
> It additionally adds netlink support for most of the information found
> in debugfs, and is netns awaire.

Attached is a tarball with the v4 version rebased on the two initial patches
from=20the tp_meter patchset. The patches include many TODOs in the kernel-doc
which should be replaced with actual docs.

The batctl patch was not yet rebased.

I've removed following change in your v4 patchset:

diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c
index 71b63e7..0455e54 100644
=2D-- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@ -1416,7 +1416,8 @@ int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb)
 	int ret;
 	int ifindex, hard_ifindex;
 
=2D	ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
+	ifindex = batadv_netlink_get_ifindex(cb->nlh,
+					     BATADV_ATTR_MESH_IFINDEX);
 	if (!ifindex)
 		return -EINVAL;

I've also added the diff between your patchset and the one attached tarball. I
hope you can see that nothing evil was done :)

Kind regards,
	Sven
=2D-nextPart1849581.vX7EfrdFzp
Content-Disposition: attachment; filename="rebased_split_netlink.tar.gz"
Content-Transfer-Encoding: base64
Content-Type: application/x-compressed-tar; name="rebased_split_netlink.tar.gz"

H4sIAAAAAAACA+w8/XPbxo751for0FxfRo4l6sOSP+QkE9WWE82zldSy0/bSDociVxbPFKnyw47u
Jf/7AbtLckmRspT2Oq930Yxlkgtgd7FYAAuA8tnECJilBwvHDnWXhY7t3jXuO/Vms9mqT4xwbrh1
w7rHP6t+y1zm22ZdgtWnxtx2lvWp58eQ2sIIzdmT7AdJNQ86Hf4fP7n/7f1mp/mk1T5sdVrddnf/
4Emz3e3sHz6B5pO/4BMFoeEDPPl/+jn3vXkPLo0wnNlGAGNzZk+nzIcX80Bevo5c+575AcPlNkPP
X2q4/K8qZ0bIenA9i2rQRfwltJutA2jt95rHvU4T9prtZrMyjib/xcywBx/f969P3/4GqUD1ACUK
pESBlCgQEgUoUQpopWKxSXQ7DcAOwIx8n7khAgUMh8XwYuJ7d8yFe9sPI8PBB9SwfJhhK9guhDMG
d8x3mVMRz6a2wwIw8MpautihyZFwOMwCw7XAZ3PvHq+rAWOVWRgueo2Gczd3NDvSmBU1ZssF8+eG
7TRwzNGnhiDeaHWbB1qr0Wy3jg+0WTh3+DQCb85w/CGCB7saDF3qyA5tDwfm4diMsAbK9FwvBBwT
CxaGyerGA45Sq1SGbhAywwJvyrHdW2TYQ4KG7PBtFtT4TB9mnkPTnvpGEPqRGUY4z2DmRY4FE1YR
M8OeJcc1XELs9sF2cLj2J07C8bAD3BYu72nhexOHzalvx/BvGUwiEougQrPjQ4DQmHCOIu9mhs/J
LwyUGAjZp1CwGycxtm9dZtW96bQ+WX6VzOUo9F3LRzZcRK4LLwx+89rBG82cvap8DO6ZqzHzjjko
Ru5rb8HcOvJ1ppkk8WNk2QIs78EFrrJozJ4rxICk0pGiWKvQg7kdBMQLsdKWZ/6WH8sYe4NB3Bu8
WNf7q0q9Xq/AZX84usa/wdUYij6fAVqwh3DGHSMeQsknhkPKOJW67ZpOZLEGcqxB20ss84zg9juw
V/KpQIwXGQtbCrbYgjpuQcT/DN39UvQ8Meo83cCNlSnEY87B4abC1cvOjXe6AhnPy0whu4cbDm8d
vVlKr13ArQocSfVhzgz3llk1aB12kHcB82lPB9W9XVwJn6F2hLlnMWhx2/fI4hSiPLIghThlXNoG
eIb6Fnch1Ou3dghGQ5XTiXpXsV2LfYJD1jlsH3Y0bTpt7rfbliRPQp7FriADcxRev4b6cQ0ZfVzr
At6MezuXKAOoLXFzVeC8t3PmmdEcNZxB7G30fxg2QhaEuBkbwTKYBnXTMYKAPBLFWdkSkfZlAQo2
PXj+HWGkpLXwU1jZQ9hHVwdhcgzOsTXeE5PkUjK0a7XNZvcIGdo6nFism2NoDCy5Gd8SKzvd2gHs
4fchMfNq8GE4Hr4bvYTvq8GMOc6OPYWPULfg6ffV9z+d7TY0HMpT+O2E1L4Lv1ZgZ2dnaqMEs08L
zw9h9G58fTYcnernF/03Y+i95DD1oUTPCTU27qWNylNEkXeQwcTdRo3fV085few3y6JHNNrkEYAK
GUnOYkXqJY+lD6ppk2lrYuxbnLkNi+E2iBxH8vYR8sTxZg19nVYNNevr15W9xnM49RZL376dhVA9
3UWnqHlY557RD1pfu9Yu8XukoTYgkz2J0LQFvcoePKc/VPQ+u4MLHCA6RTUY23N0En6KcLy+Y5uz
BI5bbDTLt74xJ59h6jM08d40JG/hBJZeBKbhohtj2YHoBh2CkMxzw/M5BeSHPV3SQ06dW/0QfZqA
rDwZXnJP2nRDLW9GN/CGHDXDgffRBMfCiVzYJkO9B2jCF/QURQxdjCVHOachjeWQ4NzDbvim0kon
kY7Vip22GVpN7iHRQLmHMmEQBWwaOTX0QkJO56fh9dt3N9fQH/0CP/Wvrvqj619OEDpElyckT1DQ
sud4wEHSOB7fcMMlzk3wfHB1+hZxUD9cDK9/AfRpzofXo8F4DOfvrqAP7/tX18PTm4v+Fby/uXr/
bjzQYMxYzBhOJMuchDHkIM09cjOF+5dO/hdcIumTzYx7hktlMpscMwNFY7EsZ3xMm1MxuKNGU0Xo
lJsngNsc/cgaesgMXkgH9uHhQbt1I83zb1FdcSJB41VuPfhmIeFE/RvA3DB9LxDTkEqZnCCxK+yJ
jSfGpejec0iKpOAEnJ6cwgVpRuk38c4alb3K3n/YU5S7KeijwbX+Q//6sj/S+2cf9NN3l3hQ4E/f
DPD7Yjj6p/5WRwSERpOwOQL1IVXOC6Gd5eg09A2TNjzwooP6IrexX8khAlK7+Vn/gIYKtSj2dTaA
F/DPwdVocBE/re6jB4B/zV2OJIdJDqTus1uUaebrwpPUiVO6twiq0rMEvN7lvgbpzfUoEme3BlXC
qgFJ+i/6ePifA/5A9M7QY58CKqHyUcYLkIBuyFHCy+jmx9zFyWMQm2ln46DVMg4LtfNj9BX1jJ5r
iXreVDPnzirfdPE3Xfy/oouz6vGm/36oCy2kbNGMQiwHSYGwgR6OLvRR/3IAT3Gb4BZ5SiCN54IL
zI3mIJ7rqIhQ3v0A6koQJgnRUBOXjSBh4WvZQf/6+kq/GY3fD057KM3Bgpn2lFY6waFjtsnP28z3
cYsJdF1XCfTPrwdX+kV/fN1D6cOt4CLLI8nn16ObSxW6hxRDbMfhT3Dz4GLlJ2Hc43pTgGJ1qJf9
n3swQ22ABwNljJJWGmkSbLTk+hSy6l+owle5UMOnqHQohJCyDYyJh3JGoagaRAuLjmUkYQsPZWFJ
Gy493FJ/O2XsIeo5dsBLWAedm/waaFz7VmXvy8kaGUE/AGXDIjEJogWdF0jnrApMDLciLqeXZ4XS
IhEekRXCXi8qCmBmpREg7UQsdvHSJjNUVjcdtLK4ZMoS4HR5c8uXHXEtSzO3HFlYdTUU012291eM
dVk4ZlLWEh/tjw/NaXuqaR3WNayJkT2JluEK81zWSmZ5f5/OqfjNz6lKlmEJey9RDQczzausPLfN
+UIPPPOOhUXNPHiUfY4ny3ej8+EblT2Xp8jQXY4QOaFtGgFR28tTi/fg4wRHp7sSgcIFddOjsGnR
AD10PGzXQNeiqNVHGykQ1y2djJBNip/LZTtoH1qtDtM0dng02W8drV02iVm4aLKNlqx7SEuG37Rk
FUi866cU8a3zzTc1TKbNnqqN6pJlW1Lm4/PUWX+aeOEZ6Bxzs40KX7MNCyPumGbQarZoCq1mW4hd
QHEek/QGbjs82oTxzqfr6r1nWxSQgJ3EKcdBoAuK9lpHi06qyq8+kyjEBN2eJg27J4QYog6hySR+
fQLPn5Ljjlt6J1Y4YuYpMBFBMgsfRzT1qk8zjipiGK6JiuwfAVSzR7LYafyHvQuOZ1jM+tV9WqPg
jlQu43c3V6eD+HBQi/0D6frLx9g751pLcK21vwXXJBDdIRT7lELRdQz1LxySfCxTGfgfPU9vWS3i
S+RmOKOwV2kpYDDspO1br6HShk0iM6Qn0h7QSNZt19SST0qbNjoIGdN9dnTICg9CpYTVE9DhtxPQ
txPQ3+gElNgJMkGlJqIgzpMN5ORbSUsVNix83NV5nNXAUNpWEnbgwSOp/0QCVkSDZGY7p9Pk05fc
w9RQW76ENwM8pw3PePTlqn89ID9Rm1m4C/6bYXOT31OKGG+yBzveEu+Xl9Di93PjEx09UuDY+a/F
DmXBYFFx5keKjz7+JgaaPRWUWC90Wa/iSwEi0qrZTL9ccGkoVHOyYg2F0dgjRpHx8VnIh4HmOcRh
rQ+fPStkO/GHPhSCW50tN0Eou1XsYJcg0Q7jfnWrTyOXjpN0PEkmm53VU8L9soZJqUFCNt2kN5sx
qtwuKjziDFEMnyBTwgkx3k0M2azc3mwW0ZsarW7bONrGkGVCee3ON0P2zZD9/UJ5uTD7JsmNbD6j
aOtnN/7JZvrhZH0CIBvzf/Lt83/646+p/2zn6z/juk8Z6qqHXv33iPnLpDB0/hX1n62Dg3Y3X//Z
bXe+1X/+fes/W5vWf+ZixORTcYlKCkOpNoeqGT1/zi2dqL6qVJQw6RvUX5eD8Vt9ODp/RzaPx3cT
SijfPF6RkjAmZMOMihKrJjNPvh751TUQLguN57J/SuP0WSDy4BOPWwUWIyBMhcfufXtuYGciTnAS
B/PQltx6PloStB5Kb9IV2P13K4q8YlZkChuc5lNEoVuADC1leg0KiyTFY5nWIO6lOZA/o34yqSEq
r4uEA9istBFaR/BIZaBSadja78LmlYb7KxWD3eNcxWBR2ZNS4IQesKwMM7rTzuGRph1aXfNocpAN
7CbAavWS9J4P2hTFw+9WeyWKlwTwZFRLv0OnUL+3rao8EyILdBE1g+f4v0Y4DHc7ekahV/uVopTr
aw+S0gPYqrDiMF9XEbiWTokmdHL4pW09XvdwmJY9wBZ9H/O+aWay7xUuBciVuWHqpB+qn2qw3IVf
/+waCbHssgpC04zj5lGr08wu+2M0Nq+WaHdIPPbwX/uIR/m/NjGMiBz5jyaGVXS5Nr0CRUqxC9Q8
qzj9izfveGikx4vqSZ2taOaCtDDXa+fD0dng5540BvLooPSdCEIpgWzHW6L3z86u8LjUoyqsxARt
ReZt/+qsZBqu59a3IrI6lS1JrJtOKSnYojgA/mBxAPzR4gDg+q2kOABKigMKBDz/OJHhlQS+IqYl
baVocjnybarIlLQVkVRXmPJMf7TkAdaUPMBWJQ+8KLpZa6FD2j2otagMrHSJ/oQKh7ze+6oKhzIv
qwc/rnVolYEJY53bP2sLJmDbgolCcVcKJqC4YKLUhUzFZk0xBZQXU8B2xRR/OGknzwgiLadp3YOj
bnvfXJtpT5E3yNu1jrgtxn8i4gmrKREozpqv5jZQulyvMOsxDegxbJlDmeoMd69fiFqaYEkyr2Wt
pf0FoYVKtrC3NGsDm2VtqE1pgQ3yOSpDC6odlEY6FOYaKb3CfejgTqcX5yj4Bl+THoLS9BDk0kO8
wIZqHPY66M/tNxV/f9se1ySP4AtVJ+SSR65j6FKn5+iKpx9zulsmlHY+FtjB33Z2sBG0cLmgiY0u
+vr4+mo4egNfanmUxEZug6Taz99W0G722+U4oqvtepL2UaI5jFJ0g2t8fjEYFeCopnjT0SkmeovR
qda7fHRrk350MudFKvoCDVEdzimrEIdwVi2VDOpkPMZ5cNtLDCoCBMYtPxRM8NSHjhb2aN4JSNpl
uk2YvZQIjy88zGxThGfQwzDSt14hNO6Ym6QJ4IqFke/2oAl0dohME7ur4SmQ33NTLOP36TGZF4iV
Trma3eTwHGdTg4LTczp2maaTMJI4qrN7eI434ooXlSEqv6squCcrmLJ4hTjxXAaj8JaW/ubiQgFX
B5PinKRJVUSpD0bvfrg5H4v8Kg+L0b6OQl2cs6p8dkWuKxQWGO3C589IiGInjxHKOLs8Mxszo/6K
rujURsnZ+is6ixQQjvbbq1QznjKkfKy/QneM7PgWI1Q96wyp4gGVEIid5WSP8fkSnkqSlp7OSrs8
/3zr0TvKkUx7ZxY5FR/5TL/FdQ6Yw0x0WasxD5OUtoL87Bmkd8QQnYQ+CuBlovSH53r/9Hr4YbDL
lfWOImsvM8hSuMQAM4JTuCz508aOSjq/NhstTu6MIiRIpaks0vpVyhxpsqvEEVWi2WVS12nni1Ki
0OR8oZbeyjJwzGytGQ1LAUiKHVBzyeKHL1to5LfoTTvJmwAr7rfUrHeTXpo0zSljAUIkExhf1e2J
ev0ztCuJbzKFFe2K46xlfBmCguf0nVWrSA6eu2mBCGcI3lc5aIlaTHegAqBqdkWr8nwrPdNnzLBi
NSol9yRfqkJr/h11XX/FT53l7giXB7nY9cFw9KF/EZMQB4+XXHSJTbS1NqN5kgxB7qyyTlIOYD8k
3dTPBMWQsKrIq1o8xZSmgvP5M3wn11OkSXQ70O8NhwLKqQ2TyiQ1OWeDDyc5PSf3j+C56xCf8XRY
HV1cjt/oZ4Pz/s3FNX8JrgZvzt/rIoqbjgnhV3q5HFyW98JXUQoL3SaqQTA4DT+rTwL2e6oX8FNS
bCQqtxKosp2YGT0fz8oUpG0u1zRrXRXhmmR8iaxWyvgoOzvc/yAXJ4eS1EaJ4dEd8ZvPUXCPCmj4
sxNF0MRmkMON+cxcS4wrmfNJquxiIJ8tnGW6HHGNFWxdv7bDB6yZcys92BQEJAhm6hi3QXzq6p9d
Dkf6+8HVpWiUJ52XxWcdAWN5dsGKZNQbAX6JD1RA+vzfJP+/r+b/hQGpLwwKe6aH3AAv60bd4hlK
5n5N/r/Vaq7+/lP3W/7/L8z/r00ai0z/pefWoK1k+g973XaPEqGPZ/ql8yFkJz2zBRT4NSCWHW6F
3aCi5uX5Dxvx3xPyqeYs5Ie7KEDPY4oDh4VjmDyZQ939zLVaJT0S4pUHhutRrEqORxw9jQAx+C8V
pcEaGIZgedTZzA4qkyU8GA799gdEC3Gi5N5BAI4dhJRJEJMRP3rE3CDyOSpb8t+VMhyn4noiafiz
MmEN7aaIGONQFh45B3yIoA5aZUkl+S0o0tlIN6CiU+LKvYygy2Hw1AwHxFMwozIJ8etNCFORfKeR
Iut41R+BoGoSACKT7tsBFRJuVU+wQRL/tWvgxHiRouffvqr0sdmSlEPPtT34MTL8MHIcG+m/jlz+
Y1KaaW6e5T8sS93ngnUm/UhQc5PMfZ1/KijvudQ9omcy9zXs3MJjlrivb57Jlwl8TTPMzvTQaG6e
yW91DvgLOZ04n/EX5/Jb3a9I5nfI/ZHJfKT7U/9qRMEo+TtvNOJbaRq5y95Qf0oh1JMGuvlE8w10
Hu9ET7NJXyJMUn+VvhLEYwQ58EdqBeIxblkr0JHlDWqtwPD8XB+903+8GdwMdponwAcXftJ/j1jE
dBFda67NQayI7uQxCClY1gTV8bGlad3ucXvaWf/K5gqNwsTEChSPMHMpxO+jbHYijtk7xqQwYh8s
bNfxzLvCRnrHj/OoOGqvJ9qwoB3XXonrq8mRiW9bt8h2z1voBp3Y6MW5XAJFvoAWvyt4tF9ro2k7
6ta6/HepuHsMX2IHTTlwq3JbB+mych1PT5IBQxVtBmnfKdoGimXuivO0kNyeui0pKThjcbQzhqcO
ejF9NBImum3ZzSF/PTBJafPdJTtYOZyjuYocbsgK9kxCkgioA8ge3E3UeSGoR+1VnlTzQInyEQNT
38FYpaf2Hb/7QUejwv2uHmdVROXsvUZPxANeT0U2bECnKmAyb4JAKjbziH6rUo/Nd10sOZWYhw9e
4myQL8EMcwbchwmkta/USTAQptWDVqByNWlp96DtWmrL3goOSLngMiIfxx0LT2xvhVoGRz7O4sQp
8HsWzpImNGDcs1kYti9dJpqVHSg+TFwNwqf6XUInFliUCsbZo/hixeypidsHW+w2kdxuJOfEiec5
xatQLqvEt1qlLgR1HVR7Nw47rgozcblW1pwhUltLpC1fnSWDTwOTw9ela5lGbMSDKsHwd1klQnsD
hDY/gK92r/YnNkUxUDsLhGA5zPRMrCoLzmci0uL95wiV4rQ5Tlu+L813egFjKCy1Ov1dei863e8B
O5EvffMn1SIGc4a1lQD1s2coG9IfrRZxmGO0UgweENkIkmgjLEkI+72aY6Kc9gpMOw/D1z+xXuK1
7mO03Hutbqt2rDiRX785SveYHeieq8uUOo8frbUJdM0FvF4Um5Xz4kkGKIjykiRL5atL7fsYmSIJ
VoUXdvhseNwKRJVKqqvp/SA7EOfP+MyazW4SWzjD99vkr++1Dro1dLeLWf51vOKil9vDcStJlLz+
n/a+tbttHGnzs/wr0HnPyfomtqi74km/6yTutM86diZ2us+e2T46lETb2siSR5TkZGfmvy+qCiQB
ECRBXRw7LX2QLRIEcUeh6qmn4kFlGvIHpbyJJrLBAYUqQGyLqd+fA9XvZCEc3sRqHhbzZ96RcXMj
KsesUU6pAHZhXga7cuftSYNfSBfpeWMdeE8+cGEKhCfU7DPpfTOikQ6QyJn3Nz8yE9+04xAiCZYb
OM/s/hQ/dchevOUn4MkMz+Fqk7zYM7Z/GTMyT72o5eM3oK3J4glsWrlgcePspS998QAwjEipEEdb
/7Af2P+rLut/L+f39wDaLYuTUlmwjiP7P4p+5cCo/c3T/1bqjST/f61e2+p/n4P+t2Wj/w3Hjs5Y
jydUHDv/I9jZeaex4MN1Rgz4oJyd3c4DoIYKCekD0mKiMxY/ZUt6X9SF+l+HwQw1zMg0dM/Pw4JE
SNKVAi39H3DJm4IvNe3nvW/4fiTMhuVeLqyqu5Yy2iEt8+zWG4sjyrUHB+w4iWDav/M9oFblMoLI
gwoVK3oDUA5DAXo+4y3o3fgDthh6Yduhi7bYldB5O5hMxpDW2wkN9nFLECBqGCiNWUzFi3pQTSEU
KktAoRo5TqlOT67gko18ntqZLk+pL+il3hL6rk6j2uFriOP4jfp1ZZCt74ofNiq64tuIG0eXqXpV
Z7wSuiqA1pnRs3MPMQ9mDZeXgMcalVvSg8Fs4E1v7LVaWPZOA+HD9U5TSJuyZ7jOtiT4mFCeGY5n
ejJvMBCglN100Fn8P0rvBxnCuQLIiQR1piHa8O0E7EBEHP6Wkg1gXn5j+zDOpIOfWnYUcWIzOQvx
bLw8P71mLwGsrCt9KiTaqgAfnll3MJxiJahRiE8fLprqQ0gj5NwqRTg2uVxHYXmN79kjyrUaUm/x
LREcGCItJHaTuTtHj9BPB/ltSC0oSadhrVFvUQrLK9i06AQxXPi75raApkrtDgLiYGvVXfLz4Eda
F5W2KUMZ1t64ibSTrNCtFIBlFhq9Wc2tZbTh8R3jKnNGdzyaU8ewIS+tYNhBbVxQG7AkVeLhnDaS
N9JN+e1vNbyZxlzHV+Gbbn/Et/b5vYy2ZDvPWf5vyPJ/yP0APBDChxLRuMQAkSL5W+E/WrWGzv9Q
r7nb+F/Pgf8h5VTQtjkViBFFRBDykCLihgTHw6eLz1en5+8RI34p8zzc+IQLCaEZsa+eyHUncvYN
njfjgtIE6+NQiCKcaL5YgK6o51AdWLEr1I0xnAzRnpr1FWI4kV+cig2pMktKB4ELMZx27EJD7bBm
gueh3tLRIlUVLWIRKUrrkp3MCDl6//VyElgxtjU7zevmwLOJkKNnL/G21RvbCDlbKrdthJz1RMgh
YFKBCDnJBwpFyEk66eoajKB/VzxyTkTwogryIUw6+NIDi8ZdIB9U53zNHJRK8B0clcB8c/mlBwsp
HJiG3igoIes+37r5DEWkdxd8JEolQu4fyVfoJ7g2hpdKg2DWveFyw/1RRLg/x54I2+7tm7ix42u7
vKx7bHd/N6cm+3svdzFt+Zd+zyZsT6tI1B69lzcQtUf4vRMRjeO4fqvaqTY2xUjTaKEaC/40s7kb
VuJdYOvlXTDROCii2yt2dfHuwpgOHM9Ofw1TPDkGB1bKcpjIqrPhvqjrU+J+sIqvIMIqOE6r2a4N
vPo64ivUMHRjrZGibebyyHzkG1XKdIuvLt6d8b418UKSXeHLrMvPQv7AeHfan8OJK+0esrzATdRH
N5GPoEWaHwMqFB068zGhGsvDIODTejQowNqdzv+QwJAeWHFDyBp54aCsQUszFfVNl4jZ3OZhs6kp
LdHZOfD/2UWWiy4EU45cIflVFEX2wfuMdGj7/BwYgKLKiFPFzAbzu/su6RXL0hKEvvfxT9oo5Sv8
JfJP2RM7vq7gS8OLiptnSlnM3vN8O2ahsx38H7nZlRhTN9mwKKT7C38JvCg1ze1gSqo9/o/Jvy98
EbZmmgPf+dmH7q/dD5/Prk5DV76sBS/25OMvVX0tP1y+B69Fewf72C+eGdzgY/fwMJ9rLk3Pp/6R
2csOyiM52AnHZO3ZV9KTfRiyI+PDcmVMDslRX2eNuH4vfxiZxk8e7wJ2X1+geNk+l7hiAnnBI/ha
FuL6vfIvIJw5saxoM9RCR9/gy/CeZwi5eNOb4B+VPyOP4Mj/u3QLi2aXCxFdgK6KGSDnFg9AvALJ
D1G3JXlaDvlu8jd8HwFO4UTClydfcr1PmWvKcIeSjke38AXdHE+xkHkhmkzi3aVhuYwSdKk39b0v
+O9/IndOqeK8vkMFMs3zL/8y8scpeGgQkPvTPp/nZS6ajfjWAnqRt5/e1qJDNkW2p5g+iCHG5u59
m6EhHTOjQ7HvDUi8ER7t/IucrdDfacKup94NhHnmIhGFJopC2udKBrcpe3jk1tPkwnC16Ti1XqtV
GVznSwa3GZKBcPjpUAQe/qely8Bzf9FFjpd/yTuOME0DF5S2VE5u7rrUgkfRoUufJ0fRQ+EuI10J
WYwYEUZWsWjVqgipJNty+IkdLI/g+TeVOcjnbdGHWHAwkugzO0pqtcwbMiDii90s69AhqOmmbB/X
T2MWRbfdo3UtUbw04JPFB74+N8xECLxB9++9bxDpqXs/m+5FbsRr4jgT1GaO06g3vV7HWx/HWbUB
GGT8NgmFIZVYtkTLMiTa8lJUYnYEZAkpk63EMiZ8qlroU0VnANOsKy8VWmZDTGMsNRANrlvNNq5b
zbZKOmztqM8sfOyZrY89KyHzVYbrf+K0ug73f74CyIWLloWk0//K0Vdotor4Ko7T7vRa/UbParbe
2gRgcdswOvl3zRXTNTe0BbMIbWHgKwT9KV9lp8bJmHWyszz1xQpHlHvE4YDZRNhgdhE2WCoxD8HQ
qa9kiZiLYbJEDJot2B8LHK9G0NBpZDrilZo7gag93wZHt4e4B4bv1Xh0RkgDuC/IAAW9B88RNXC7
+DTOkd/efQKapDgbRQbEx/9bYa6BS3vsFQrHKBfy3dafjq3XN+y4bTCTjeA/mib8BwHMLFAf1vgP
Lj3WNPxHtVbd4r//MvgPGlIpqA+hIybrplhHZLAHPRzwIzEu9nDEw5XuEBHVehCPPXiEC9vRYxiW
gt0MwQpKZFXPPChHqFPfbOwNC8wHQC+skBfgFWf3MTFywOPZIIvNWMCE4ctx6p1ep+HVNmUBq6F+
uBai0NdB8s9WJ/ln6yP5TwZtQK5JowHsiYcAEJaOJlo6Wln2ygzWfZbOus8yWPe1oAHYhk+Li39d
6gjSQjhOjZ9zen5rjeoI9JU4gD8do0LCWu9QRLkgmdEOssxoSa3EF1AKmElWIoXFgY3bSgFVho76
SDK52NnKMqPGJ3nUUfGh6kLKO5skUG/UEKveVIKer8Ryzpbg92ZL8XuzZfi9NUJ1XD8MbOq/nh3T
O2LFBel6SEcNzu0VdL5YH6EryyeCRItn2okbjR+CVHd122fsiFLE8pk4kycKVdgIaufio7Hh6uwB
vFcNXj5Hj203FULrMhZTS2bpBAeCPeN3glQanpHdvGxYvzP4pJmcn4Hy22jThSZQybLzebvlZgPN
psHMTMklHuvky9OoWx/TqGyYRcGq9mW7yRosa3JO+h3B3kkUWWR1hq9CnNSZUz+Fi9rS6o3WbP+f
wpitmogLWbtjvuospSS9I520/7Goq9VsQ0rqMJ01p7WZMtmQc8ja3J/zTc0bdIEYb1foTA0wgS5P
KM36eMUVG4kRKiCvElLr/PSaafU2gQjscQbpG1tioxAQA2JMkjYrK4xB1FbzsdxaqSzVBTAJSxio
yEiVxySNElKrjqbyVmvT1rB0k1O+DSxCZG7E+mVaT78r+/X2k6X/b6X5f86m3jgYIQa6jHS92eaA
bP1/vVGrNHX+l2qjstX/P1v9f71S2P9TGlIMh1RoDkCvG54iCJmqCRuurVtXn47PL6+O35yddM8u
3h6fYWDu9DTvzy7eHJ8dCn6U/mQ69YP7CTkGoKcXlAaLAVuyN9pBp4H44s1o0vNGEZ0NqqQdKGsU
Jng26/ZHQ+DJolUUFYFA/zJZ+NFrPh9/PIX//a/3EyLm9pDEcrYTKk0FowtP9+hmCSs9PzlZNuyD
ZwuvzKrRIZRwYSrXN09da7KyiYYmsQwhIU2t1WLL+Y8m8yNDRh0MGQ3d8FBvurrhgRf0ESwPwuAA
jDftZr892Fg0aML2uYf1KmlDBZZDxfog7J0/9ELGnMtqb30m8GPaFaMrTHjm9BneUkwBV1fdt2en
J+dX3XcnZ69o8tNDwAFFgeGwsfl0wlgAOG9Rj2/O5tPF8Qcln+mEn91hLv6Mz4eBAsbgCYvzHSfg
A4WMCxXl/miEJkag3OdTh0uiIwZLBC5cUDJibvLHkcfizxi+7huRJxvK9Qc/47wi90RRMPhvMh5j
7C5+YzqZ39wyjz3wlpICFlC5cHmUfZJCv3jhZvri+CM7DSY0ql+wa9/jkm9aE51eXpwdm8oSDAf+
lGf6YohZ+YMXxGZFZch4/cnXmc8H7SAuQ04Rzi8+fv70/kQthHAEHfvAMdkDZ1BaRq36/fzkDzU3
6CXsIb6rxGsxrvNi6wGGLZ6Kahd1KLByzcd9/kh6Z348OX93ev4+0YZ33vQLFHgypcLzV8FLhnjz
i38/C1syrg4mhhgS6CA7mQ5vhmNvFnKQQQ6QADsn4I3MZfH7+RT2kbR5dHXy4aMomNi/9AYZ8NlE
gw6nF+xEoRdwuB0hgRoUfTxhY5wq8LQ3giPZN6mJhrNI1/IGJgt2VQUybiFtM2hIeDLkAOLzCud/
l7+07wFJehRIA+fOhFrlYTgVoz7OsQ05ug0lS+rJtBxxdELL0cYO2QHcbD7D0Rnwl42+OYay16ns
fIllwbwX+MSdLpUebgEfNcYCCZuQd2jwbdxHH2DMMGK4xnUmCHtctCyfVRPGj/sivAf01ARG5a0f
hG+Bd4jVe4A5ihz4ovr201u5LqEzcdZi/K/YbqgsuLj1vma7Lvvb31hl79CUDBZUOZlrTgbrm5ys
bk6Ga08pStUwpxLLQ5SsnZLs5A+lBh1zMjFb4xqk1BRmTlw0Fysax0M1BA4nO2/ZFCs8NsQmvFal
2PCq22psetYdVxEhgKaqZodYr56YdZ9lWvcTtv+LT6fv4xeZ0/B+yU9xdfX7ecZtsEjnpUHnk4z7
v5++y7gLhrLUAsLN7psTQDCYE2D5Lk9OzrsfLk/eXj5bMAQiwDs1QchWBA2Rj3hgRsSDioOQx5N+
Lx5HhjswNgyXo3FjuIfjxXCdjxPDVRwf+vVoXOg3tPHwtIAd5MeK9l+XfDky/PTX6WfPLP3sWa6f
vckTX9cp2CUl1cJjue9j03ew6avmpk9z6NdU1CzHd5+V0jXFOe2WnUSoYp4QBUABLJKAIDlOo+a1
+KF8fVikGq6ctXbkCrQ0dOZA8gtMKjhkH8FVcTSCsANwM22x4m8OOLMJEAwrCILRQDPyZmMLtIk3
oQJPwAZkKNbntjl5tGn9af0I7mWmVxAuKfkA3+RMyd2mOTnuftb5R9uifV9oG2Y6wkrFMVXbKExX
QWRpP6aVzmwayzfYmRbbDVju+LkRz8uy75ptucIVflMFI2XGEl51kbq5l3YnXOZbVbfaHjhOr96o
NyuDzGU+eta4ykd30SZcbYJy9QD+JuiNeM24COdFB3WpUuXlVazl9ahYy+tVsZbXpWItr1fFWl5B
xVpek4q1vLyKtbx2FWt53SrWcoaKtbxmFWt5jSrW8npVrOXlVKz8MXx0vSrW8npVrGWzijVZ9jWo
WMtrV7GWs1WsZYxwla1iLWepWN+cXu2C2rGcpWCFRK45UaxehUR1c6JIuQppGuY0sWoVErVTEkWK
VUjUMSeK1apY7pTahUpVTIOV+w+A+ssmlepi5I2jvY3+wviCTrmezKfsw+UbdOwbf2OQlJ2+Y0gM
ppyqfz87PufngMvu1TFfPR5ufRGxxae0MaunxxDYR1nNvBugPOVLFJ24swQKk0G6Z5EodN33vet6
p+o4Tc/1e7pLmUU2RonDlFAQzrkdZJyrNo3eLqnkboC7G/j3ayabs6WTSzq7CFKWwk4yS4UozmAQ
sSWxW5K0wOx5U5ylziIacqaKge9Gt9olDLHU96D3FIVDVHwldbzRajdC4ThHo4Gic6VBYdArTX5U
I+o8iichAdCNbiHKUWZNZHjAKKTgzSd3d5PxUphzQ/EKuoYwnR9PYz4yJ4JtC0stmmSffhlY9DT4
uYBD42K5D9/JJFGdRNb44whJegNEJCH1xIiPn27AhaTuXeD3kVQN6tWf9gUgGoWO1+E67U+7k+td
KuUhy3rhIRN1gSy1t/D8/i9f0Yd+0J1N6NKuuMBHBWZS/iV6RmCKsa6vDQ0AaPNdiWIKX1v+ZYGc
IAJFDukS8VgOSryaPEu4Wf5lNnOiWhteAjhnzOUxXHN0BUOGj875xZvPv14mXHSSbiaS5SV2hYla
C91fku45RkefyOwCw8T0kNs0PiRsMqVQLPn46fQcr+7KfVagFGTOieqAMoqND89Pu8oj7CVLE8z2
DF48xtIkbEUIt9fG/dP38VEXwt4cifrWvVADV6D8ezj42g3WsG5TcYsv3HYrd5iKqCShDnxt5t9E
4bOPlVDdjrIX+chvZ/A19txJOqUYqSvRJyVchakQICDQTZmxcvAVfUmi0mV6k5h2weSqpjZMKQzB
LVb70J3E5DHCL1NBwCdkAExMLl01DM7I+yTN9yTKqaLNjdxhvUZOVCXf7+2kFgVmO8gM0ZXty8ZT
3Hl8gPFhkZYdjDTS5OzDv1ICfWqEQ3xKQesNnnFihTE7tOHEiG64fxZzp3t2fnB832P27m4UMFry
apMCv4VbSUpUtoS7ltLp8aAR17AWxO7pD+RAa6IG0tO8BvEv2T/2p1T/2LgefNtNqQcMMyqZiHjH
ZTWad2IA8jQPt0ARuisG1N9wPeRDYvj/fPEiHJav2Uu6gQP4H5T6z7ylUGwsliy+pVgWpaX5JR/J
YusPnevgB+V6cCC5JGJbSA5yfMXB8xW1dNy0mJnqhggyn5Qg7B3N3dDSY4+KdiRfd/+kVVvx5aOJ
LbvxwZllJ7E8BnwE3QNf3PgmmyAWY3cy0zlJOctoRw3h61dBM6LbblUOq650ODUxs6smrG4w761+
KNUPoOx/wqFbkYb8YLasoGMq7hKyju0ZNPsJqBh6voYPwQXlkd5kAoGRgln+YRYzA7Wxdp6dt+l4
OpstxomDqXocVLPAEyFcKv8S3YjElTWeD7W3fq8jItl6Lc+IUYvysnmzyd2wj9LV7kutvcQBHFLu
beh0mcxFQQ4mCRsSRYR/TefFtrGACCEUmWC9rJ+MEYjxiPzLnJZhErOXL1k2i0UEF3nSgRG0dfRx
FJH8oXlv+RNuosCbPuHmbAx03sUqpZ13jdtDqBfchwFFP4xaS1Ff8ST9sjhk8AKFp8Fo7xEjjqzC
tkpM+f2KFjMutwSFif1T8TZUVFJGUl50jhfyJ10SyxjUJT1CBR7z5aYjeVLjmuAVp0N+2CXJQz5O
4ddMygsYa+L67BklYKPEkdzDZHmBBpJcZBQBQq0AFRFOuLyzrI7/cNIPH7I86cvF/j4aLJzw65ju
S2u0LCe8jU4rnu/PXruVXEnz1VulaJ3gDfCdtFv70tpWaPyvV9UlZbzVdT2Srot6PrpR3SrBtkqw
WAkmZuQGtWCG3UheM6NN36AOSy6lkj6Mf+OC+uNoxUrSJCUJJ0VVFvmvdpPN7I+6koxWFohQhO1i
OG1vLAlXBLTSJFaCAguRl7LhI0nkgyi9OH8AAFIm8cVXUaLE02EpCsKxbm3gUVEsr37Lr/YrjlNv
dlredbMgHOvWFo4l2DaqGAupGkbITGKIYuZei9Bd8V5lCud1kAwsxNQNFmIvZepHgXWVDjeaXtQb
DHYzN8xDRkFIIG4VaGMOJS/mmnBim7vNRMbU9XZKW3oDhfi684PAu+GvxeICJH04vtFifknq4eJx
v5hRNlk1gtiKBr2jtYpMWuCb5DJhqUtPHAciDZo4mJN+VE7OzxN34PLeXaCtI9mxvHBbHrdN8L+1
0/jfYgBfmS/E/Nbw5rbHf8w8IwVcNv9bte5WGzr/W6Plbvnfni//m1uY/01yvkAfZzGkJC64oR/s
7BzzpJr1ART1p+fHVxefLvFR7fb5yen7397AzdCp+HBnHoCDkYhNic58tA7hORXygCtYBLo0HOsx
KB32x3A02vFGD963gEVnj4uP5xdXl58/fkR4+njycMjQX4kN7+5HPsQcFS4Q/lcIX/PNnz1NWreI
9Sw/fAsT4VsSaSWUbz8M9dKs2IZ6yczvNny3sZBCTlIo5FiHCOcSLG5up6KyuG2ItE1wtTlOs1Jx
K53mpkjbXLdFRAytwkQMKiMCs2dEYAUYEUzsCdIMzkgVTeTH5Fbg2xKRK3QKkytEBAksnyCBlWzc
Z9ObzXA3aq5nSq0gGBUcx+0NGh1vjWFeaug4EEVZXSWgyYGFU0PRSCc5dA1Yg0oDq1BpPrKXuu5t
ne+frg3SDXiARzu3jVu6NCs2Uhih64llh2Ie6cqe2cu6K2ZJpdUcVBttx2m5vWYtJxiS8rxxoigp
iA/h0OXCXLUdkos9YSexx/UDy/LoWto3azAMBJvToOxN7yWSljhNGL2eHFDFilCvgPaoXg+1R4/l
yiWcasv9yQBd35Sb08l8Jq4erLLk4cRB/THrj7wAvLm50C126JaL9EctoD+qwVooaT2U2VhcH2OG
6yWmON/13sEfQJkIkj/yNxZHGPDdDwNNhmwMxKnJ2+dmQhErlWh4aB4T2g3IVhxCZpPYXHbvTb07
fwbHl9ATFlIlLGgVcF5FskBwap37SWtaoj5Pz6Amp5OsZumWMjUgCppRYnPHu5Nfjz+fXW3AYGc2
uh2GMS5CE9zWEvYDWcLinrXrzBibkhawKiq/nHloM5NHv7kflaeOklFgyM4VzQt1FRDZUZ/ID0kW
uZ8obQRASHS30k6ioaJCQOunhqFJZBm2fCJLkW0Yl0fYIeG/UEVDv+JlTevVSFWTM0KzMyULZL8n
WRhFaOE48nmWxVCkNVsL44xMXRhaCtVO2rgdMt2GKMvjMP6uJ90pn5te4KP1kP6T7hLpB4hzASrd
UJqC3QxzE0bGa77FMS71sZspDJd7fzqcCFqHqX/9in3h3+x+ghtoSEYrvYMO8TUXY++4tU5LCAl2
ruKxUtC8xSuMMU96k49qst3ct5v7dnPfbu4/xOYerWpr3NvjlXK7tTN9B0HsqzeAQu3aBKGMLfmQ
0533Feb1eH7Hj9b/slWE3WaqqUL7SqPZrFWaPcfxe/1G023bKsJucxVhZFepuYctdsC/OwY+XqFE
sYDlZENwZDwNsIx5U5/AFYR6UOCehJlAuIQARZDuAjgjqxooJa6NFa4n5vNu1ij+dbT0gdwrZLsb
X8+IbouCwf/U/ekDhQ+GUDrSESbKq3C0Gl4l5Mh9+RdktG79htqaK2qVjiTG5aTIzIiHtlVFpVZD
aX5Zsh77D7tWSBq5UeUMkm2qlEL6safDw/DeqvCmFSTSI9PChH2yKnprvYvcUTY6UZipeyk3Qu7Z
ar85qPiOU+0DwiIHhSgeNSMPxU2h12+iWr9l1OpD7FZgxzNqvuHItWa1ftC/9Qf8Duh5kTiSVOze
ENh5wTpZSDUfASWFBRcsfQcuRF7tkLFM7lP+uocuEY8Juzjr+bMZMgN6Y9LiVsPj1xC4ReF4Nxsu
fMPJLqZL5ce2KT8BYn7300n4DJ1cYx0CDtZXDP/gc4BM4SP1dnIfK5BhvWe7k3vQinujvdgXKF7T
XtHxMXwE2Xu96KwKRzV/Fr8bh3ni1dJpllA3pldG01a8MX7I5p1wpn9FJ3t4I2/LyXzah9AVI2T4
jVlthe2AgXA2Hc5u7+hsPaYWjde6CQKMtNfQ5H3FvOBLSmZQ1Pv70TehqfeBpZYwIVANoTWo1PmA
OeB/WxGbvTxyQrmR7KksZy+sHhpSpWyGuH+Tm/ruvjZY9oy7N4mnpvUOpcBEVig0F155MxzxpWKk
JzKvn1hZPvHjTkVkFnQYxMdEcIJUgXjwFm2KDBhqaskOEq9evelsWs664fTiweTasxAN8GGY+tKz
NG/2dgtCdBPb3hZW+0Pgfzsy/hdwv2+cY+fK+cC/z53y6e9wu4tgYIIAl7uDZfC/zbpb0/C/9Wqt
tsX/Pl/8b9UG/wuINHlEsdPfUdXyLyRwIVnmPwKAq8Jn14GZXQkHC8Uc8pXx5i7CttYareWxrSZc
LW9WnrCmA1ZrzdqjAFYFTtVxKgOX92V7U4DVFp5E+HfbEABDI1JnOXH2WF6cPWYXZy8Rjg9hY7lR
B//+XMP08Q4mLuV6Nmg4JYYdS4thx0o5vKSpbZwImPf3pxXyLutgrywOvay7YUDvttsY9Dp8qjUa
bX9QzTziK88bz/lKCsH0Tq515sN+6nl+MxC++y+zbnjeN9wFwT4F+8dPBZO78FxfbwPW7aDeOXTr
xmplsLHHnpSb5Wm3JGQfcglk6n1bhoN9NYCeBRE7Lg+dFnGtd9ruYbUGCEM+r76m8dnR2BMHTbA5
zf7Z9RY3CgFEfDxWuEviI7B8mZ63JjEBLXrEYpJSmDzNtcTTlntelEqtPAH+rfQ2I1uJpsIW/5El
JvwlWx011btUTKbq0YXhLMxDNhtfe6NA8JGIooGNViQk+9dw4dCdo5hcLqGMH8eqYclwxKvnp3CB
iG6IDtDrYTk08eGkjKHo5PoqdxQuzYyYWsmCrDklC8qcUpEBWbJyujWlzJoYpWxiRT7844GUQ/Rf
lJdfpwaUuPlDo3HW5E+ZO4fspZivBv5FZPmJ06rQAoE6YS9fCgI8LWX8QkQn8HV2gk7oydeswNQo
1h6ZrzHDG2MdPP4WHImZ7IjJHFUhMJml3JBF4gTIEAxqqJQuKf8i8EhwVYAz7KgZ/34oxrttmYw8
/Uaa/r8OKWJiCf3+m8TyhInmyixFlGvJoVZcSrHYGPJIFs17RFeQHlolziFOjPeSbkylqL1KcwgD
k48/jdh3MwUlNaM9DTNUeE/BXNSNRYpP8FKqyF7Ku6QkQI5YMSRLJauT97aX0gpM1+GpVVgbpe57
LW9rVJ0kbVO6SJTY1iTSRiZBrgzNSEmkbk1IJmEuMuFjYgCSJGuuwlL0kDL6yzSoipSgENNkopU3
xDWZsmxujIIypV7roBpPX0KXOOmtTl1pWnhX5q2UZsjaqCtT9jQL8kqmitoJNnSe4HnwWupNYMts
WWBOxdMBgxikzYclrdD5M8EOsmcayBpLpcISGKGrLLgrvxND5XpJC9PWLyNtIcuK45G6JdLMlpIV
ZDRcmVbQ5AI01ECShDEqC6yRZwA5zSlYL5kzcCeKb9BwipAcNHAopfyWVwKdLT0pRc0m1FuF6Dyq
1Ubz0OV7REydIMMkhwu53HnMZrkqUOx5/HelDVmt6/K7qV6odeymSm/TNiZfMqqH1qsRkl+XVApt
Nv5FRCqxDp1KngZErehqOhA1r8JakE0pNZ6CBkKaJWJZWTtxe7SrricAYVrBiyqfLXTPdqhoTJoT
kDBn4TCKwKnyrvxkqKJ+GZco8wy8lBScWEqzDrXKghhFISgszhaNN5go6mriKm3dot9sBdYVfC/E
kmtxeEsflEqZU4dhcghHo68bOdRV9GvYDxuJGGg46aGyRqmMNIClAoHKSAywzEErFgiTOIorfYZA
WlK0NMpVpYTqLQw/F6u0ePFEMhJJaYwzfxT4VPysmR6SCb9UlxKc3eKl0hzX3Ox0N8X4kKI5yyVW
AaWxccmIWz7jibw+EMsV/9iF9lOVZEp7YIg/UeuogctlWlqi40CJWjvvlKyeD8Lc0k4IKYeBuMp9
XH+Eb5vkKBGg7/7DJPZgIAEff7pEBH49nAaz2CuCkP+hzz9lOQwm5CEgH6v54yZPDeFQr+ZKxwS3
CliZg2q9XQldRmR+NR3/L34LiAdfmrrUkneTAJBWRLjmxOB7aITXac1zqKYdBt1gyAVRb8qPkV3h
mWJ+GJJOetrzdOR6bT7awFhyNK7T16kbR5RzjMBPpI5vRXnHepLXaRoUNWd0DzGmhTtqWkKsm1PT
PTU90FWnpad7h+siMBS8hUBgWB/4g8r6CAybCJlsCsikOjZRKCb0m5G27h8ayi3kA/yHCdr3Z6nE
7zIH8FKwY50ddz9zWRH47NQHIuOi4Qm4Z3hEOyj8mfamA/Ux5XgkHhr5EEEwPCkZHrr6u6kmbaYS
823x/yr+361k4v9N8P/5Mvj/RqvS0vH/tUp9i/9/vvj/2lL4/8eE/2+EMrua4iqwiIH96CpQq6/Z
VcA1uwrUWo/iKiA8BBxn0G40O9X+plwFuDTG9z3+3VrCVcCM9Gc2SH+WivRP+gD89uni8/vfPn6+
er6+AIT1rbSSzZzqC5DQ+rEsaD9LQPs1sH/UiM8L9L9Iw/svIqGw7zb7g3rdcfxqvd5rXOdC/RdZ
KP9FyNJbOazyJYX/qdVSggdRfGUj5r03vzGC+P3pdDwx3smkB+jzo7pvvAPcI8YbQo3/iFzB/B4O
nFwiYYNbwWCQ4i/xxNwKYIB0/dG9hu2n6+Adsgl/AwuXApbkvjnYMdnhFqTS6HpAncA7y4qNA6mF
WKYWW+MlM2uFBA9OtYLUgVW3dujW6ikGw5XthYsnZipcrG4l3LSBsATvm91OJ/Ob2/sQFbcuk2Ep
zpjn4T/ced34ighSrz5Oy3GcKJmL9GMflv2tZfIJWiZtQ9jHEorUr0/arrl4hibNxcrWTFvcn71F
U/Bd/Hg2zYWFOfN7GTEX38l+uVjZdGmFPM1GnW7Nl6mLQQqQjuWC6VTzmdliKZI9ls2SPT1r5Qab
PAEUUdv7CdkvF7K9q5zBlxaTkNGiA2n4L4YT/mE4uwWWMyJ5470mmSJlmGIMgBz4/GB+HaTAH/Fs
0kKFWL3SOqxWXMkru1RCIsT5LNjFVfvF+URoXhFlGYCOZApKQuY4zv8Zv9hL4T9f/OAOu4vVfXXt
PQsKuhXYeuwm0+Y5s+teu5Zu6cUPZMp5boNe7UKGUk5bqlO7fDKTT1+W/u3r9E3evA/xxk+Vj+NF
/AO7Dxc4Um59iVc48f4YbsSLVT2IVwJPJjenZ+Ey/LgOws/EG3dh5YibhHXmOO7JlfyruNwufjxv
28XqjrY2knAhOfgv5Fm7WMKplmlyojw7n4k37eJ7ONIuVvWhtdTqbf1o1+JHu7Byoc1TQrEMZgkx
jdF5Vkn+uI60LF6WddV3Px6qaXKRK7NyWw29jCdMBPZIJlmrASt+s9mAyNAFsfEZ0Pg4bhGY/ANf
ktcWyZsRqlsxtgDARH4scTMTwr6wRK8vDMB1A7B/sSSmf1EAzm+P5l+oQH67cOSF0O4IcnecVqdZ
8bz6+tDupORsCdTfBtDutkh0tgwSnVkj0XXMeqQPSC/QGrDrWfhvNxP/DQExyzfezH/wvgXlxdAr
86eXwX9Xas0E/rvOL23x34+G/86EP2civRtLIb0xmGo4dhgfO6GktbNDcVZvfYp6M7lWk1G4FjnC
jLOzGSx3m5nQ16IwAm3MF8Z/M7feXh7NreWXDiM3wb7dGryY16euI7/dZkdFfkPXDfyRT7/Lm0KC
CwC447j13qDTbGwMCY7R6doUja8oErwYxJvlQrwTIPA3x+fv/jh9x3eBzx/z07y7+OM8LRV/09XJ
p+cLJUdHNdc19FMqlDwXK85SseIqilzuhfR70Pr6XWr1p4U9p1BmDQpj7WZD86W+C002V5+Ozy+v
jt+cnXTfn128OT4zjG6DeScjVQQtNIzdMM3746uTP47/96VxAEOi7PErJVSGH08wAIffO4gaTiMQ
HvhZhO1Cih+3Xjc2knhMGXepjXSYTCM1juFu1CjSkNIbQxpXY75NRQWKR5Y2ctSG0t7KG0YeN2pa
UOlkCviJ7ayXlyKMSuj2vGrddxwu9F+3O36muJ/Iwyj1J1IJz4YmOja0lvBr+DbzJ9OBP0WI/ZRS
pXs5JJ5HF4fY9yBx/9qM9ZedI0TkWIi+UC0cfSHNd+E7e0RgnTqHLpdS6u6h2zYHX8iKz5jhQjEf
3K/FRQLuBOL9hT0nopHIp+ZknOsmsRafiPiiCFao5QyQoVTvjOBbAINRuTabeuNghKCiMqrXyPUC
/cebNXQgb/HuqzdhkUQritEz4eZhkwZUnrtqJy1grlBKVsxSwaxRmVoqUV62L/6xQNAIO2OEfDn/
fHaWbeOkJ5JpopeDtMV/hUrZMOr56fnvx2cG2A3ll27+FPkKvTLZDhKwlNgaSk8ajKB6TdMwPpTO
4h0y1Ed9lWiB+CW8DsDFHPAjTn/mD8K22pWiWm+eXT/c4VVQjBqaPkLFmOLSh4liu4vIKKovL3w0
8koyrCYfqSEsQVnACrVMolCrRABIDq00LE8qp74yFLQQJTaQICHMJ8tGGafigCh8UCoU6Pz4w0kE
qQuzMgOBxt6db4vjSR5MeJ+EjdjjcuLDcDC77Q4mD+PiWdI5yJjh/D4cIJnjIzlksxA+kW1VMtIn
Z3YaBk9NeaQ8n2HbFwkky+MUDTEm26PYQmztjmmbk2StETkWj2meB+uPLSDJPYRnCDYaaG+QeWDl
Cq1y8LVXzHon5dolOZPtS/DztB1M3xqTKdQtVjJCdoMvw/sUEyWB6JIG+3DnC9dIOpa81s0AsCmI
m7vCMqjY9xQVx8nlbyHIL17CQxifgm0Mt1qoo9w04FMKr+zxjsJ38nIchpWI85Se+fe/WRhZAK7C
ChJ0F95oONiVsP2JTeTdye8pEzLFyVVxbIV0yoCKe0hcU3ZTZRelGkhP8xrEv3ANBGFtHqjo1uO3
V6e/nyTqcXJ+lbYXFoBjiCFHe7cwkt88OJlOUeG4y4NlqGKmHTlbSbIyh/t15NkRj3cddMEv8XzK
v4z8sbQbE85C855Sc4nXW+l5eu5VKmRDWpTj/pMXVmE9hUVVShA58qieJzjQeMrEONMcMES5lbhh
2gLN1AX6tn/PS98f3qNW9waBVv1bn6+bvBgeozMUGwb8/3e/vf3I7vwg8G5CKukvPXLEEMl4e+Kz
gj6aNwrfYnh7vYKcJni+gjTCdUOoJhilYwBfKKJOuc1VcoR680a7Ohi0+45z7faqg1qniDrl1kqd
QnrzKh78+LdZFxETGOxoB5/ZYsR7Q2Q54NeOIid+fTs72tGDr0tXQod/OojWyX9FqDNlj3oxa7po
s/DzXOpNPpxpMc9NbwFeucx3wIPqLi+MDOhnA8b37sz/GuPllKjz9Mr9yfV14CPWcB3yAi8QwV2j
fPh87k6uu+jXk91gTH8bCAA8Q1lVqk67ncwJuWvIjx+4ZXeR/XiqrY1gTyANHKfu9iv1trs+yEGt
edhmB/y7o00TWa3ErNRK5TQ10IFB3ySmqr2+KVWzlKkuylANIczioOWaaC9/JLBFuTDYQoNnyKeq
4s/A4c72KTrAhjUxVDpGgeDYrQp9cx1UtIlOhPOaDMwKu5Bf+kfYYSVHdPNrc0fjiuvAuiXDrRSw
VQiOwuqg4OP07+DokWoUgSRksn3N3p+cn/HO/nB63v148ukD3cwr04GhTGJ5hZtbrsfC+J9qPv7n
zdlxuT/yhncCAbQM/qfaqlV0/I/bqG3xP88B/9NcHv/Dxw6jsZODAOpNh4Mb/nMyuWceCFOgmpIf
fRxUkAS8qRrBQVTOLpSzG5WTMELNJisODjLnhxghCH1ezgcJJYuchAp1ElAhN4IKbQ4pJABCXHjr
t/1GtbkxpBDSd/FvAisXhAoZkDzMCsnDMpE8STQQ3/0zYEBwW8UrGZP8fvou6/ab47f/683F+UlW
mref3j5btJFbJ7RRx9DXqXAjVTvOMlFCzIgS0pBF1JOmyxGmKXmL95zpcthjpnu8p54gQqlWJfBN
tTBCaTnUEctHHZmASdiAZ8enHx4VmVQn+FajWRiZZI06YqUMATutEZ4SIiltD+1ZJgx1A/W21/E9
x+l06o32dS2bZzUlKzPvakpiPHthB9caKeq1VOwNaGUH/v1TRfvU0dXnoN48dM0VI1tpPvOppknx
pk8A7PNotKcbAvO4nTYqdbkcVzl0m41sOE9v5HVRcFZRPWgFnYx9RhdETBVQNvbgKtEbQTazCfM0
UVsym4L2j+/PYWiVUBOv4IPCh+G3hBO69PkoAbE+lhfClGo2kSXiVWh2ipmUhMkW6vdKVIUXGCqX
MN9WGC+kP53y7/5k4DvpOCNTk61MEmQ27aaljorA9vGPsBbP2/HDgGLgy65siYsACGCbgftI0sOP
bmG/dvvTfsSbMAy6k4exDh8yAow2DqSJdqalkTRUm1gRJCIOATJzF5sQwA+iFW4eCJQiRVaSW1XY
sQDRiLbIbu9296UpD96amAALLbcxmLbN6Y/CjMkyZ5V1yCOENbSEAQmpdEMgIFm4lfh7REXSeHbc
pjknkIXDZxfDgQ3GR5GVk0iftA4vUioUt4nTIu7YR8DM5GJYtOUp4qKIlnRx5Xmv6UR6IaoiremC
/uLL8P4V+23ywPgu/w1XfuDi4ungTmLt90boT1axX/SXjztfbNm34bsgzEISLaRvEiuTXGAuBQgu
TGAKBUph3ElTQ2ZK7UMzWOObNWAo0vES+wnARDY8Io+1Qq1KON3UybXCxALUWWTupW6eTyHI3Xjm
DcdACOdNb+YQESdIjG6RERv545vZrZPEqKllfySo2lL4s1xU23JQNY1bwxaplkalkcPAkcqyoWHb
tmC2JcFspQRBCh/hDo1w0b/PAO+2XsYU8/5l5O7NYu2V1+CYIUXjQ1mVDcUEXlsFnpayejN19Y7k
OGxJDcij8Pxqq/pwzFd1nhwzRGuKRNrLv/ASrP2Uw2S8hL7r1lbvFIXguq64A893HK9d6XX8zhL6
rtsi+q5l4WTxSr0WAJlQuAmFqgyIgi7mi48k8xtRShL9jRXjrpQcOpcL7l2coio+LJ59psFVHCW2
6o6dLF3m6DcXEOsuaq+VNaflsS1zIGmgy6BDOGocIfjYQb2TBAZC7qS6jIK8TrnAk4cQ1LOgJVvk
tGsQI8T/hqYDHqFcsKD+PhuEYXndff5fZB4LdyVxjO2enp9elSr8NnLW/7zPt3SekL29OP/19D2o
7T8cn3fFA6j4F+Y1Mu24Gq5oOB7BO4pXGOM0/YeiQck5FWsDsVXly6uRuHPx8fzi6vLzx48h59Z/
8XM432ZsGkJJO4bE3XPQVylJu791IfWaUI4C3Og4tVrFdXvrRTnGi+dqKEdJt52yX7wwOtjaAR5T
9eyIWESrb8vMRrYWyKIV1I8tBfVjxaB+Op6QtHoZMZcNDxQMnSw0ciYgpdtMSR+q4oq8gy9M6e/Q
IY41xI3X+NB9XIhjBCfMBzZKxtWNIBvVpXF5gGMW/q8m4/9O+cLX5/O2LNKUSaFR7vP7Pb8Mlu/y
w3AJ/B9/T7Op4f8a9doW//cs8H91G/xfOHY0ZRjjY4f1fEJNYIAUfn8cAHbPn4WgvjE/7DOYPvwk
hdfIjBRrxUA3itmDWmyIme4omQ4wDjTfaCA7sEcz8MhlwT3fXoJlgIKpm/m/KRCzS0fAGGIXA+yS
QZiXlwyEQOA4/Wa73mldr08y4IJ3Mxa/5WVVNL7RsheyeWLrRgsiX+/IV5rfgTjcvBH4TSQede68
rwAJihOH4C+ksqTO/wKhE6dzP1rd1rHDb3Hf28/2s/1sP9vP9rP9bD/bz/az/Ww/28/2s/38dT7/
H3LUswEA4AEA

=2D-nextPart1849581.vX7EfrdFzp
Content-Disposition: attachment; filename="andrew_netlink-ecsv_netlink.diff"
Content-Transfer-Encoding: 7Bit
Content-Type: text/x-patch; charset="UTF-8"; name="andrew_netlink-ecsv_netlink.diff"

diff --git a/MAINTAINERS b/MAINTAINERS
index 7e47274..ff0322d 100644
=2D-- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9,4 +9,5 @@ S:	Maintained
 F:	Documentation/ABI/testing/sysfs-class-net-batman-adv
 F:	Documentation/ABI/testing/sysfs-class-net-mesh
 F:	Documentation/networking/batman-adv.txt
+F:	include/uapi/linux/batman_adv.h
 F:	net/batman-adv/
diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
index 6a97a2c..4c8e526 100644
=2D-- a/include/uapi/linux/batman_adv.h
+++ b/include/uapi/linux/batman_adv.h
@@ -56,7 +56,44 @@ enum batadv_tt_client_flags {
 	BATADV_TT_CLIENT_TEMP	 = (1 << 11),
 };
 
=2Denum {
+/**
+ * enum batadv_nl_attrs - batman-adv netlink attributes
+ *
+ * @BATADV_ATTR_UNSPEC: unspecified attribute to catch errors
+ * @BATADV_ATTR_VERSION: batman-adv version string
+ * @BATADV_ATTR_ALGO_NAME: name of routing algorithm
+ * @BATADV_ATTR_MESH_IFINDEX: index of the batman-adv interface
+ * @BATADV_ATTR_MESH_IFNAME: name of the batman-adv interface
+ * @BATADV_ATTR_MESH_ADDRESS: mac address of the batman-adv interface
+ * @BATADV_ATTR_HARD_IFINDEX: index of the non-batman-adv interface
+ * @BATADV_ATTR_HARD_IFNAME: name of the non-batman-adv interface
+ * @BATADV_ATTR_HARD_ADDRESS: mac address of the non-batman-adv interface
+ * @BATADV_ATTR_ACTIVE: TODO
+ * @BATADV_ATTR_ORIG_ADDRESS: TODO
+ * @BATADV_ATTR_TT_ADDRESS: TODO
+ * @BATADV_ATTR_TT_TTVN: TODO
+ * @BATADV_ATTR_TT_LAST_TTVN: TODO
+ * @BATADV_ATTR_TT_CRC32: TODO
+ * @BATADV_ATTR_TT_VID: TODO
+ * @BATADV_ATTR_TT_FLAGS: TODO
+ * @BATADV_ATTR_FLAG_BEST: TODO
+ * @BATADV_ATTR_LAST_SEEN_MSECS: TODO
+ * @BATADV_ATTR_NEIGH_ADDRESS: TODO
+ * @BATADV_ATTR_TQ: TODO
+ * @BATADV_ATTR_THROUGHPUT: TODO
+ * @BATADV_ATTR_BANDWIDTH_UP: TODO
+ * @BATADV_ATTR_BANDWIDTH_DOWN: TODO
+ * @BATADV_ATTR_ROUTER: TODO
+ * @BATADV_ATTR_BLA_OWN: TODO
+ * @BATADV_ATTR_BLA_ADDRESS: TODO
+ * @BATADV_ATTR_BLA_VID: TODO
+ * @BATADV_ATTR_BLA_BACKBONE: TODO
+ * @BATADV_ATTR_BLA_CRC: TODO
+ * @__BATADV_ATTR_AFTER_LAST: internal use
+ * @NUM_BATADV_ATTR: total number of batadv_nl_attrs available
+ * @BATADV_ATTR_MAX: highest attribute number currently defined
+ */
+enum batadv_nl_attrs {
 	BATADV_ATTR_UNSPEC,
 	BATADV_ATTR_VERSION,
 	BATADV_ATTR_ALGO_NAME,
@@ -87,15 +124,32 @@ enum {
 	BATADV_ATTR_BLA_VID,
 	BATADV_ATTR_BLA_BACKBONE,
 	BATADV_ATTR_BLA_CRC,
=2D	__BATADV_ATTR_MAX,
+	/* add attributes above here, update the policy in netlink.c */
+	__BATADV_ATTR_AFTER_LAST,
+	NUM_BATADV_ATTR = __BATADV_ATTR_AFTER_LAST,
+	BATADV_ATTR_MAX = __BATADV_ATTR_AFTER_LAST - 1
 };
 
=2D#define BATADV_ATTR_MAX (__BATADV_ATTR_MAX - 1)
=2D
=2Denum {
+/**
+ * enum batadv_nl_commands - supported batman-adv netlink commands
+ *
+ * @BATADV_CMD_UNSPEC: unspecified command to catch errors
+ * @BATADV_CMD_GET_MESH_INFO: Query basic information about batman-adv device
+ * @BATADV_CMD_GET_ROUTING_ALGOS: TODO
+ * @BATADV_CMD_GET_HARDIFS: TODO
+ * @BATADV_CMD_GET_TRANSTABLE_LOCAL: TODO
+ * @BATADV_CMD_GET_TRANSTABLE_GLOBAL: TODO
+ * @BATADV_CMD_GET_ORIGINATORS: TODO
+ * @BATADV_CMD_GET_NEIGHBORS: TODO
+ * @BATADV_CMD_GET_GATEWAYS: TODO
+ * @BATADV_CMD_GET_BLA_CLAIM: TODO
+ * @__BATADV_CMD_AFTER_LAST: internal use
+ * @BATADV_CMD_MAX: highest used command number
+ */
+enum batadv_nl_commands {
 	BATADV_CMD_UNSPEC,
=2D	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_MESH_INFO,
+	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_HARDIFS,
 	BATADV_CMD_GET_TRANSTABLE_LOCAL,
 	BATADV_CMD_GET_TRANSTABLE_GLOBAL,
@@ -103,9 +157,9 @@ enum {
 	BATADV_CMD_GET_NEIGHBORS,
 	BATADV_CMD_GET_GATEWAYS,
 	BATADV_CMD_GET_BLA_CLAIM,
=2D	__BATADV_CMD_MAX,
+	/* add new commands above here */
+	__BATADV_CMD_AFTER_LAST,
+	BATADV_CMD_MAX = __BATADV_CMD_AFTER_LAST - 1
 };
 
=2D#define BATADV_CMD_MAX (__BATADV_CMD_MAX - 1)
=2D
 #endif /* _UAPI_LINUX_BATMAN_ADV_H_ */
diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index 9abfdbb..0558ed2 100644
=2D-- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -1980,6 +1980,14 @@ next:
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+/**
+ * batadv_iv_ogm_neigh_get_tq_avg - TODO
+ * @neigh_node: TODO
+ * @if_outgoing: TODO
+ * @tq_avg: TODO
+ *
+ * Return: TODO
+ */
 static bool
 batadv_iv_ogm_neigh_get_tq_avg(struct batadv_neigh_node *neigh_node,
 			       struct batadv_hard_iface *if_outgoing,
@@ -1997,6 +2005,19 @@ batadv_iv_ogm_neigh_get_tq_avg(struct batadv_neigh_node *neigh_node,
 	return true;
 }
 
+/**
+ * batadv_iv_ogm_orig_dump_subentry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @orig_node: TODO
+ * @neigh_node: TODO
+ * @best: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 				 struct batadv_priv *bat_priv,
@@ -2045,6 +2066,18 @@ batadv_iv_ogm_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_iv_ogm_orig_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @orig_node: TODO
+ * @sub_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 			      struct batadv_priv *bat_priv,
@@ -2093,6 +2126,19 @@ batadv_iv_ogm_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_iv_ogm_orig_dump_bucket - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @head: TODO
+ * @idx_s: TODO
+ * @sub: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 			       struct batadv_priv *bat_priv,
@@ -2122,6 +2168,13 @@ batadv_iv_ogm_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_iv_ogm_orig_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ */
 static void
 batadv_iv_ogm_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
 			struct batadv_priv *bat_priv,
@@ -2202,6 +2255,15 @@ static void batadv_iv_neigh_print(struct batadv_priv *bat_priv,
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+/**
+ * batadv_iv_ogm_neigh_dump_neigh - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @hardif_neigh: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
 			       struct batadv_hardif_neigh_node *hardif_neigh)
@@ -2232,6 +2294,17 @@ batadv_iv_ogm_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_iv_ogm_neigh_dump_hardif - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @hard_iface: TODO
+ * @idx_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
 				struct batadv_priv *bat_priv,
@@ -2257,6 +2330,13 @@ batadv_iv_ogm_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_iv_ogm_neigh_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ * @bat_priv: TODO
+ * @single_hardif: TODO
+ */
 static void
 batadv_iv_ogm_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
 			 struct batadv_priv *bat_priv,
diff --git a/net/batman-adv/bat_v.c b/net/batman-adv/bat_v.c
index 5daa300..e244b5f 100644
=2D-- a/net/batman-adv/bat_v.c
+++ b/net/batman-adv/bat_v.c
@@ -212,6 +212,15 @@ static void batadv_v_neigh_print(struct batadv_priv *bat_priv,
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+/**
+ * batadv_v_neigh_dump_neigh - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @hardif_neigh: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
 			  struct batadv_hardif_neigh_node *hardif_neigh)
@@ -246,6 +255,17 @@ batadv_v_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_v_neigh_dump_hardif - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @hard_iface: TODO
+ * @idx_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
 			   struct batadv_priv *bat_priv,
@@ -270,6 +290,13 @@ batadv_v_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_v_neigh_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ * @bat_priv: TODO
+ * @single_hardif: TODO
+ */
 static void
 batadv_v_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
 		    struct batadv_priv *bat_priv,
@@ -380,6 +407,19 @@ next:
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+/**
+ * batadv_v_orig_dump_subentry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @orig_node: TODO
+ * @neigh_node: TODO
+ * @best: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 			    struct batadv_priv *bat_priv,
@@ -434,6 +474,18 @@ batadv_v_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_v_orig_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @orig_node: TODO
+ * @sub_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 			 struct batadv_priv *bat_priv,
@@ -473,6 +525,19 @@ batadv_v_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_v_orig_dump_bucket - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @head: TODO
+ * @idx_s: TODO
+ * @sub: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 			  struct batadv_priv *bat_priv,
@@ -501,6 +566,13 @@ batadv_v_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_v_orig_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ */
 static void
 batadv_v_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
 		   struct batadv_priv *bat_priv,
diff --git a/net/batman-adv/gateway_client.c b/net/batman-adv/gateway_client.c
index 7f38aea..dedf89e 100644
=2D-- a/net/batman-adv/gateway_client.c
+++ b/net/batman-adv/gateway_client.c
@@ -670,6 +670,16 @@ out:
 	return 0;
 }
 
+/**
+ * batadv_gw_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @gw_node: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_gw_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 		     struct batadv_priv *bat_priv,
@@ -732,6 +742,13 @@ out:
 	return ret;
 }
 
+/**
+ * batadv_gw_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 int batadv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	struct batadv_hard_iface *primary_if = NULL;
diff --git a/net/batman-adv/main.c b/net/batman-adv/main.c
index 3127d28..7683da4 100644
=2D-- a/net/batman-adv/main.c
+++ b/net/batman-adv/main.c
@@ -615,6 +615,15 @@ int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
 	return 0;
 }
 
+/**
+ * batadv_algo_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_algo_ops: TODO
+ *
+ * Return: TODO
+ */
 static int batadv_algo_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 				  struct batadv_algo_ops *bat_algo_ops)
 {
@@ -636,6 +645,13 @@ static int batadv_algo_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_algo_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 int batadv_algo_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	int portid = NETLINK_CB(cb->skb).portid;
diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c
index 671d5b6..c68497f 100644
=2D-- a/net/batman-adv/netlink.c
+++ b/net/batman-adv/netlink.c
@@ -20,6 +20,7 @@
 
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/genetlink.h>
 #include <linux/if_ether.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
@@ -30,6 +31,8 @@
 #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/batman_adv.h>
 
@@ -49,13 +52,51 @@ struct genl_family batadv_netlink_family = {
 	.netnsok = true,
 };
 
+static 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_ACTIVE]		= { .type = NLA_FLAG },
+	[BATADV_ATTR_ORIG_ADDRESS]	= { .len = ETH_ALEN },
+	[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_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_netlink_mesh_info_put - Fill generic information about mesh interface
+ * @msg: netlink message to be sent back
+ * @soft_iface: interface for which the data should be taken
+ *
+ *  Return: 0 on success, < 0 on error
+ */
 static int
 batadv_netlink_mesh_info_put(struct sk_buff *msg, struct net_device *soft_iface)
 {
=2D	int ret = -ENOBUFS;
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct batadv_hard_iface *primary_if = NULL;
 	struct net_device *hard_iface;
+	int ret = -ENOBUFS;
 
 	if (nla_put_string(msg, BATADV_ATTR_VERSION, BATADV_SOURCE_VERSION) ||
 	    nla_put_string(msg, BATADV_ATTR_ALGO_NAME,
@@ -88,15 +129,22 @@ batadv_netlink_mesh_info_put(struct sk_buff *msg, struct net_device *soft_iface)
 	return ret;
 }
 
+/**
+ * batadv_netlink_mesh_info_put - Handle BATADV_CMD_GET_MESH_INFO
+ * @skb: received netlink message
+ * @info: receiver information
+ *
+ * Return: 0 on success, < 0 on error
+ */
 static int
 batadv_netlink_get_mesh_info(struct sk_buff *skb, struct genl_info *info)
 {
 	struct net *net = genl_info_net(info);
=2D	int ret;
+	struct net_device *soft_iface;
 	struct sk_buff *msg = NULL;
 	void *msg_head;
 	int ifindex;
=2D	struct net_device *soft_iface;
+	int ret;
 
 	if (!info->attrs[BATADV_ATTR_MESH_IFINDEX])
 		return -EINVAL;
@@ -141,6 +189,15 @@ batadv_netlink_get_mesh_info(struct sk_buff *skb, struct genl_info *info)
 	return genlmsg_reply(msg, info);
 }
 
+/**
+ * batadv_netlink_dump_hardif_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @hard_iface: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_netlink_dump_hardif_entry(struct sk_buff *msg, u32 portid, u32 seq,
 				 struct batadv_hard_iface *hard_iface)
@@ -174,6 +231,13 @@ batadv_netlink_dump_hardif_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_netlink_dump_hardifs - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_netlink_dump_hardifs(struct sk_buff *msg, struct netlink_callback *cb)
 {
@@ -224,23 +288,18 @@ batadv_netlink_dump_hardifs(struct sk_buff *msg, struct netlink_callback *cb)
 	return msg->len;
 }
 
=2Dstatic struct nla_policy batadv_netlink_policy[BATADV_ATTR_MAX + 1] = {
=2D	[BATADV_ATTR_MESH_IFINDEX]	= { .type = NLA_U32 },
=2D	[BATADV_ATTR_HARD_IFINDEX]	= { .type = NLA_U32 },
=2D};
=2D
 static struct genl_ops batadv_netlink_ops[] = {
 	{
=2D		.cmd = BATADV_CMD_GET_ROUTING_ALGOS,
+		.cmd = BATADV_CMD_GET_MESH_INFO,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
=2D		.dumpit = batadv_algo_dump,
+		.doit = batadv_netlink_get_mesh_info,
 	},
 	{
=2D		.cmd = BATADV_CMD_GET_MESH_INFO,
+		.cmd = BATADV_CMD_GET_ROUTING_ALGOS,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
=2D		.doit = batadv_netlink_get_mesh_info,
+		.dumpit = batadv_algo_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_HARDIFS,
@@ -286,6 +345,9 @@ static struct genl_ops batadv_netlink_ops[] = {
 	},
 };
 
+/**
+ * batadv_netlink_register - Register batadv genl netlink family
+ */
 void __init batadv_netlink_register(void)
 {
 	int ret;
@@ -296,6 +358,9 @@ void __init batadv_netlink_register(void)
 		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);
diff --git a/net/batman-adv/netlink.h b/net/batman-adv/netlink.h
index ae0eeb9..89b7c5b 100644
=2D-- a/net/batman-adv/netlink.h
+++ b/net/batman-adv/netlink.h
@@ -28,6 +28,13 @@ struct nlmsghdr;
 void batadv_netlink_register(void);
 void batadv_netlink_unregister(void);
 
+/**
+ * batadv_netlink_get_ifindex - TODO
+ * @nlh: TODO
+ * @attrtype: TODO
+ *
+ * Return: TODO
+ */
 static inline int
 batadv_netlink_get_ifindex(const struct nlmsghdr *nlh, int attrtype)
 {
diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c
index 0455e54..71b63e7 100644
=2D-- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@ -1416,8 +1416,7 @@ int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb)
 	int ret;
 	int ifindex, hard_ifindex;
 
=2D	ifindex = batadv_netlink_get_ifindex(cb->nlh,
=2D					     BATADV_ATTR_MESH_IFINDEX);
+	ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
 	if (!ifindex)
 		return -EINVAL;
 
diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index be42b12..6a1eba3 100644
=2D-- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -1063,6 +1063,16 @@ out:
 	return 0;
 }
 
+/**
+ * batadv_tt_local_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @common: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_local_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 			   struct batadv_priv *bat_priv,
@@ -1111,6 +1121,17 @@ batadv_tt_local_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_tt_local_dump_bucket - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @head: TODO
+ * @idx_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_local_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 			    struct batadv_priv *bat_priv,
@@ -1137,6 +1158,13 @@ batadv_tt_local_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_tt_local_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 int batadv_tt_local_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	struct net *net = sock_net(cb->skb->sk);
@@ -1841,6 +1869,17 @@ out:
 	return 0;
 }
 
+/**
+ * batadv_tt_global_dump_subentry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @common: TODO
+ * @orig: TODO
+ * @best: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 			       struct batadv_tt_common_entry *common,
@@ -1890,6 +1929,17 @@ batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_tt_global_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @common: TODO
+ * @sub_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_global_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 			    struct batadv_priv *bat_priv,
@@ -1922,6 +1972,18 @@ batadv_tt_global_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_tt_global_dump_bucket - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @head: TODO
+ * @idx_s: TODO
+ * @sub: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_global_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 			     struct batadv_priv *bat_priv,
@@ -1949,6 +2011,13 @@ batadv_tt_global_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_tt_global_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 int batadv_tt_global_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	struct net *net = sock_net(cb->skb->sk);

=2D-nextPart1849581.vX7EfrdFzp--
This is a multi-part message in MIME format.

[-- Attachment #1.2: Type: text/plain, Size: 1299 bytes --]

On Monday 09 May 2016 20:07:07 Andrew Lunn wrote:
> This patchset completes netns support, by disabling debugfs entries
> when not in the default name space, and correctly handling interface
> stack loops when the parent is in a different name space.
> 
> It additionally adds netlink support for most of the information found
> in debugfs, and is netns awaire.

Attached is a tarball with the v4 version rebased on the two initial patches
from the tp_meter patchset. The patches include many TODOs in the kernel-doc
which should be replaced with actual docs.

The batctl patch was not yet rebased.

I've removed following change in your v4 patchset:

diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c
index 71b63e7..0455e54 100644
--- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@ -1416,7 +1416,8 @@ int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb)
 	int ret;
 	int ifindex, hard_ifindex;
 
-	ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
+	ifindex = batadv_netlink_get_ifindex(cb->nlh,
+					     BATADV_ATTR_MESH_IFINDEX);
 	if (!ifindex)
 		return -EINVAL;

I've also added the diff between your patchset and the one attached tarball. I
hope you can see that nothing evil was done :)

Kind regards,
	Sven

[-- Attachment #1.3: rebased_split_netlink.tar.gz --]
[-- Type: application/x-compressed-tar, Size: 19104 bytes --]

[-- Attachment #1.4: andrew_netlink-ecsv_netlink.diff --]
[-- Type: text/x-patch, Size: 21008 bytes --]

diff --git a/MAINTAINERS b/MAINTAINERS
index 7e47274..ff0322d 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -9,4 +9,5 @@ S:	Maintained
 F:	Documentation/ABI/testing/sysfs-class-net-batman-adv
 F:	Documentation/ABI/testing/sysfs-class-net-mesh
 F:	Documentation/networking/batman-adv.txt
+F:	include/uapi/linux/batman_adv.h
 F:	net/batman-adv/
diff --git a/include/uapi/linux/batman_adv.h b/include/uapi/linux/batman_adv.h
index 6a97a2c..4c8e526 100644
--- a/include/uapi/linux/batman_adv.h
+++ b/include/uapi/linux/batman_adv.h
@@ -56,7 +56,44 @@ enum batadv_tt_client_flags {
 	BATADV_TT_CLIENT_TEMP	 = (1 << 11),
 };
 
-enum {
+/**
+ * enum batadv_nl_attrs - batman-adv netlink attributes
+ *
+ * @BATADV_ATTR_UNSPEC: unspecified attribute to catch errors
+ * @BATADV_ATTR_VERSION: batman-adv version string
+ * @BATADV_ATTR_ALGO_NAME: name of routing algorithm
+ * @BATADV_ATTR_MESH_IFINDEX: index of the batman-adv interface
+ * @BATADV_ATTR_MESH_IFNAME: name of the batman-adv interface
+ * @BATADV_ATTR_MESH_ADDRESS: mac address of the batman-adv interface
+ * @BATADV_ATTR_HARD_IFINDEX: index of the non-batman-adv interface
+ * @BATADV_ATTR_HARD_IFNAME: name of the non-batman-adv interface
+ * @BATADV_ATTR_HARD_ADDRESS: mac address of the non-batman-adv interface
+ * @BATADV_ATTR_ACTIVE: TODO
+ * @BATADV_ATTR_ORIG_ADDRESS: TODO
+ * @BATADV_ATTR_TT_ADDRESS: TODO
+ * @BATADV_ATTR_TT_TTVN: TODO
+ * @BATADV_ATTR_TT_LAST_TTVN: TODO
+ * @BATADV_ATTR_TT_CRC32: TODO
+ * @BATADV_ATTR_TT_VID: TODO
+ * @BATADV_ATTR_TT_FLAGS: TODO
+ * @BATADV_ATTR_FLAG_BEST: TODO
+ * @BATADV_ATTR_LAST_SEEN_MSECS: TODO
+ * @BATADV_ATTR_NEIGH_ADDRESS: TODO
+ * @BATADV_ATTR_TQ: TODO
+ * @BATADV_ATTR_THROUGHPUT: TODO
+ * @BATADV_ATTR_BANDWIDTH_UP: TODO
+ * @BATADV_ATTR_BANDWIDTH_DOWN: TODO
+ * @BATADV_ATTR_ROUTER: TODO
+ * @BATADV_ATTR_BLA_OWN: TODO
+ * @BATADV_ATTR_BLA_ADDRESS: TODO
+ * @BATADV_ATTR_BLA_VID: TODO
+ * @BATADV_ATTR_BLA_BACKBONE: TODO
+ * @BATADV_ATTR_BLA_CRC: TODO
+ * @__BATADV_ATTR_AFTER_LAST: internal use
+ * @NUM_BATADV_ATTR: total number of batadv_nl_attrs available
+ * @BATADV_ATTR_MAX: highest attribute number currently defined
+ */
+enum batadv_nl_attrs {
 	BATADV_ATTR_UNSPEC,
 	BATADV_ATTR_VERSION,
 	BATADV_ATTR_ALGO_NAME,
@@ -87,15 +124,32 @@ enum {
 	BATADV_ATTR_BLA_VID,
 	BATADV_ATTR_BLA_BACKBONE,
 	BATADV_ATTR_BLA_CRC,
-	__BATADV_ATTR_MAX,
+	/* add attributes above here, update the policy in netlink.c */
+	__BATADV_ATTR_AFTER_LAST,
+	NUM_BATADV_ATTR = __BATADV_ATTR_AFTER_LAST,
+	BATADV_ATTR_MAX = __BATADV_ATTR_AFTER_LAST - 1
 };
 
-#define BATADV_ATTR_MAX (__BATADV_ATTR_MAX - 1)
-
-enum {
+/**
+ * enum batadv_nl_commands - supported batman-adv netlink commands
+ *
+ * @BATADV_CMD_UNSPEC: unspecified command to catch errors
+ * @BATADV_CMD_GET_MESH_INFO: Query basic information about batman-adv device
+ * @BATADV_CMD_GET_ROUTING_ALGOS: TODO
+ * @BATADV_CMD_GET_HARDIFS: TODO
+ * @BATADV_CMD_GET_TRANSTABLE_LOCAL: TODO
+ * @BATADV_CMD_GET_TRANSTABLE_GLOBAL: TODO
+ * @BATADV_CMD_GET_ORIGINATORS: TODO
+ * @BATADV_CMD_GET_NEIGHBORS: TODO
+ * @BATADV_CMD_GET_GATEWAYS: TODO
+ * @BATADV_CMD_GET_BLA_CLAIM: TODO
+ * @__BATADV_CMD_AFTER_LAST: internal use
+ * @BATADV_CMD_MAX: highest used command number
+ */
+enum batadv_nl_commands {
 	BATADV_CMD_UNSPEC,
-	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_MESH_INFO,
+	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_HARDIFS,
 	BATADV_CMD_GET_TRANSTABLE_LOCAL,
 	BATADV_CMD_GET_TRANSTABLE_GLOBAL,
@@ -103,9 +157,9 @@ enum {
 	BATADV_CMD_GET_NEIGHBORS,
 	BATADV_CMD_GET_GATEWAYS,
 	BATADV_CMD_GET_BLA_CLAIM,
-	__BATADV_CMD_MAX,
+	/* add new commands above here */
+	__BATADV_CMD_AFTER_LAST,
+	BATADV_CMD_MAX = __BATADV_CMD_AFTER_LAST - 1
 };
 
-#define BATADV_CMD_MAX (__BATADV_CMD_MAX - 1)
-
 #endif /* _UAPI_LINUX_BATMAN_ADV_H_ */
diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index 9abfdbb..0558ed2 100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -1980,6 +1980,14 @@ next:
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+/**
+ * batadv_iv_ogm_neigh_get_tq_avg - TODO
+ * @neigh_node: TODO
+ * @if_outgoing: TODO
+ * @tq_avg: TODO
+ *
+ * Return: TODO
+ */
 static bool
 batadv_iv_ogm_neigh_get_tq_avg(struct batadv_neigh_node *neigh_node,
 			       struct batadv_hard_iface *if_outgoing,
@@ -1997,6 +2005,19 @@ batadv_iv_ogm_neigh_get_tq_avg(struct batadv_neigh_node *neigh_node,
 	return true;
 }
 
+/**
+ * batadv_iv_ogm_orig_dump_subentry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @orig_node: TODO
+ * @neigh_node: TODO
+ * @best: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 				 struct batadv_priv *bat_priv,
@@ -2045,6 +2066,18 @@ batadv_iv_ogm_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_iv_ogm_orig_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @orig_node: TODO
+ * @sub_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 			      struct batadv_priv *bat_priv,
@@ -2093,6 +2126,19 @@ batadv_iv_ogm_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_iv_ogm_orig_dump_bucket - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @head: TODO
+ * @idx_s: TODO
+ * @sub: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 			       struct batadv_priv *bat_priv,
@@ -2122,6 +2168,13 @@ batadv_iv_ogm_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_iv_ogm_orig_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ */
 static void
 batadv_iv_ogm_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
 			struct batadv_priv *bat_priv,
@@ -2202,6 +2255,15 @@ static void batadv_iv_neigh_print(struct batadv_priv *bat_priv,
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+/**
+ * batadv_iv_ogm_neigh_dump_neigh - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @hardif_neigh: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
 			       struct batadv_hardif_neigh_node *hardif_neigh)
@@ -2232,6 +2294,17 @@ batadv_iv_ogm_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_iv_ogm_neigh_dump_hardif - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @hard_iface: TODO
+ * @idx_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_iv_ogm_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
 				struct batadv_priv *bat_priv,
@@ -2257,6 +2330,13 @@ batadv_iv_ogm_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_iv_ogm_neigh_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ * @bat_priv: TODO
+ * @single_hardif: TODO
+ */
 static void
 batadv_iv_ogm_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
 			 struct batadv_priv *bat_priv,
diff --git a/net/batman-adv/bat_v.c b/net/batman-adv/bat_v.c
index 5daa300..e244b5f 100644
--- a/net/batman-adv/bat_v.c
+++ b/net/batman-adv/bat_v.c
@@ -212,6 +212,15 @@ static void batadv_v_neigh_print(struct batadv_priv *bat_priv,
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+/**
+ * batadv_v_neigh_dump_neigh - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @hardif_neigh: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
 			  struct batadv_hardif_neigh_node *hardif_neigh)
@@ -246,6 +255,17 @@ batadv_v_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_v_neigh_dump_hardif - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @hard_iface: TODO
+ * @idx_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
 			   struct batadv_priv *bat_priv,
@@ -270,6 +290,13 @@ batadv_v_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_v_neigh_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ * @bat_priv: TODO
+ * @single_hardif: TODO
+ */
 static void
 batadv_v_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb,
 		    struct batadv_priv *bat_priv,
@@ -380,6 +407,19 @@ next:
 		seq_puts(seq, "No batman nodes in range ...\n");
 }
 
+/**
+ * batadv_v_orig_dump_subentry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @orig_node: TODO
+ * @neigh_node: TODO
+ * @best: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 			    struct batadv_priv *bat_priv,
@@ -434,6 +474,18 @@ batadv_v_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_v_orig_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @orig_node: TODO
+ * @sub_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 			 struct batadv_priv *bat_priv,
@@ -473,6 +525,19 @@ batadv_v_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_v_orig_dump_bucket - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ * @head: TODO
+ * @idx_s: TODO
+ * @sub: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_v_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 			  struct batadv_priv *bat_priv,
@@ -501,6 +566,13 @@ batadv_v_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_v_orig_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ * @bat_priv: TODO
+ * @if_outgoing: TODO
+ */
 static void
 batadv_v_orig_dump(struct sk_buff *msg, struct netlink_callback *cb,
 		   struct batadv_priv *bat_priv,
diff --git a/net/batman-adv/gateway_client.c b/net/batman-adv/gateway_client.c
index 7f38aea..dedf89e 100644
--- a/net/batman-adv/gateway_client.c
+++ b/net/batman-adv/gateway_client.c
@@ -670,6 +670,16 @@ out:
 	return 0;
 }
 
+/**
+ * batadv_gw_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @gw_node: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_gw_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 		     struct batadv_priv *bat_priv,
@@ -732,6 +742,13 @@ out:
 	return ret;
 }
 
+/**
+ * batadv_gw_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 int batadv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	struct batadv_hard_iface *primary_if = NULL;
diff --git a/net/batman-adv/main.c b/net/batman-adv/main.c
index 3127d28..7683da4 100644
--- a/net/batman-adv/main.c
+++ b/net/batman-adv/main.c
@@ -615,6 +615,15 @@ int batadv_algo_seq_print_text(struct seq_file *seq, void *offset)
 	return 0;
 }
 
+/**
+ * batadv_algo_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_algo_ops: TODO
+ *
+ * Return: TODO
+ */
 static int batadv_algo_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 				  struct batadv_algo_ops *bat_algo_ops)
 {
@@ -636,6 +645,13 @@ static int batadv_algo_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_algo_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 int batadv_algo_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	int portid = NETLINK_CB(cb->skb).portid;
diff --git a/net/batman-adv/netlink.c b/net/batman-adv/netlink.c
index 671d5b6..c68497f 100644
--- a/net/batman-adv/netlink.c
+++ b/net/batman-adv/netlink.c
@@ -20,6 +20,7 @@
 
 #include <linux/errno.h>
 #include <linux/fs.h>
+#include <linux/genetlink.h>
 #include <linux/if_ether.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
@@ -30,6 +31,8 @@
 #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/batman_adv.h>
 
@@ -49,13 +52,51 @@ struct genl_family batadv_netlink_family = {
 	.netnsok = true,
 };
 
+static 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_ACTIVE]		= { .type = NLA_FLAG },
+	[BATADV_ATTR_ORIG_ADDRESS]	= { .len = ETH_ALEN },
+	[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_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_netlink_mesh_info_put - Fill generic information about mesh interface
+ * @msg: netlink message to be sent back
+ * @soft_iface: interface for which the data should be taken
+ *
+ *  Return: 0 on success, < 0 on error
+ */
 static int
 batadv_netlink_mesh_info_put(struct sk_buff *msg, struct net_device *soft_iface)
 {
-	int ret = -ENOBUFS;
 	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
 	struct batadv_hard_iface *primary_if = NULL;
 	struct net_device *hard_iface;
+	int ret = -ENOBUFS;
 
 	if (nla_put_string(msg, BATADV_ATTR_VERSION, BATADV_SOURCE_VERSION) ||
 	    nla_put_string(msg, BATADV_ATTR_ALGO_NAME,
@@ -88,15 +129,22 @@ batadv_netlink_mesh_info_put(struct sk_buff *msg, struct net_device *soft_iface)
 	return ret;
 }
 
+/**
+ * batadv_netlink_mesh_info_put - Handle BATADV_CMD_GET_MESH_INFO
+ * @skb: received netlink message
+ * @info: receiver information
+ *
+ * Return: 0 on success, < 0 on error
+ */
 static int
 batadv_netlink_get_mesh_info(struct sk_buff *skb, struct genl_info *info)
 {
 	struct net *net = genl_info_net(info);
-	int ret;
+	struct net_device *soft_iface;
 	struct sk_buff *msg = NULL;
 	void *msg_head;
 	int ifindex;
-	struct net_device *soft_iface;
+	int ret;
 
 	if (!info->attrs[BATADV_ATTR_MESH_IFINDEX])
 		return -EINVAL;
@@ -141,6 +189,15 @@ batadv_netlink_get_mesh_info(struct sk_buff *skb, struct genl_info *info)
 	return genlmsg_reply(msg, info);
 }
 
+/**
+ * batadv_netlink_dump_hardif_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @hard_iface: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_netlink_dump_hardif_entry(struct sk_buff *msg, u32 portid, u32 seq,
 				 struct batadv_hard_iface *hard_iface)
@@ -174,6 +231,13 @@ batadv_netlink_dump_hardif_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_netlink_dump_hardifs - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_netlink_dump_hardifs(struct sk_buff *msg, struct netlink_callback *cb)
 {
@@ -224,23 +288,18 @@ batadv_netlink_dump_hardifs(struct sk_buff *msg, struct netlink_callback *cb)
 	return msg->len;
 }
 
-static struct nla_policy batadv_netlink_policy[BATADV_ATTR_MAX + 1] = {
-	[BATADV_ATTR_MESH_IFINDEX]	= { .type = NLA_U32 },
-	[BATADV_ATTR_HARD_IFINDEX]	= { .type = NLA_U32 },
-};
-
 static struct genl_ops batadv_netlink_ops[] = {
 	{
-		.cmd = BATADV_CMD_GET_ROUTING_ALGOS,
+		.cmd = BATADV_CMD_GET_MESH_INFO,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
-		.dumpit = batadv_algo_dump,
+		.doit = batadv_netlink_get_mesh_info,
 	},
 	{
-		.cmd = BATADV_CMD_GET_MESH_INFO,
+		.cmd = BATADV_CMD_GET_ROUTING_ALGOS,
 		.flags = GENL_ADMIN_PERM,
 		.policy = batadv_netlink_policy,
-		.doit = batadv_netlink_get_mesh_info,
+		.dumpit = batadv_algo_dump,
 	},
 	{
 		.cmd = BATADV_CMD_GET_HARDIFS,
@@ -286,6 +345,9 @@ static struct genl_ops batadv_netlink_ops[] = {
 	},
 };
 
+/**
+ * batadv_netlink_register - Register batadv genl netlink family
+ */
 void __init batadv_netlink_register(void)
 {
 	int ret;
@@ -296,6 +358,9 @@ void __init batadv_netlink_register(void)
 		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);
diff --git a/net/batman-adv/netlink.h b/net/batman-adv/netlink.h
index ae0eeb9..89b7c5b 100644
--- a/net/batman-adv/netlink.h
+++ b/net/batman-adv/netlink.h
@@ -28,6 +28,13 @@ struct nlmsghdr;
 void batadv_netlink_register(void);
 void batadv_netlink_unregister(void);
 
+/**
+ * batadv_netlink_get_ifindex - TODO
+ * @nlh: TODO
+ * @attrtype: TODO
+ *
+ * Return: TODO
+ */
 static inline int
 batadv_netlink_get_ifindex(const struct nlmsghdr *nlh, int attrtype)
 {
diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c
index 0455e54..71b63e7 100644
--- a/net/batman-adv/originator.c
+++ b/net/batman-adv/originator.c
@@ -1416,8 +1416,7 @@ int batadv_orig_dump(struct sk_buff *msg, struct netlink_callback *cb)
 	int ret;
 	int ifindex, hard_ifindex;
 
-	ifindex = batadv_netlink_get_ifindex(cb->nlh,
-					     BATADV_ATTR_MESH_IFINDEX);
+	ifindex = batadv_netlink_get_ifindex(cb->nlh, BATADV_ATTR_MESH_IFINDEX);
 	if (!ifindex)
 		return -EINVAL;
 
diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c
index be42b12..6a1eba3 100644
--- a/net/batman-adv/translation-table.c
+++ b/net/batman-adv/translation-table.c
@@ -1063,6 +1063,16 @@ out:
 	return 0;
 }
 
+/**
+ * batadv_tt_local_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @common: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_local_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 			   struct batadv_priv *bat_priv,
@@ -1111,6 +1121,17 @@ batadv_tt_local_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_tt_local_dump_bucket - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @head: TODO
+ * @idx_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_local_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 			    struct batadv_priv *bat_priv,
@@ -1137,6 +1158,13 @@ batadv_tt_local_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_tt_local_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 int batadv_tt_local_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	struct net *net = sock_net(cb->skb->sk);
@@ -1841,6 +1869,17 @@ out:
 	return 0;
 }
 
+/**
+ * batadv_tt_global_dump_subentry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @common: TODO
+ * @orig: TODO
+ * @best: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 			       struct batadv_tt_common_entry *common,
@@ -1890,6 +1929,17 @@ batadv_tt_global_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq,
 	return -EMSGSIZE;
 }
 
+/**
+ * batadv_tt_global_dump_entry - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @common: TODO
+ * @sub_s: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_global_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 			    struct batadv_priv *bat_priv,
@@ -1922,6 +1972,18 @@ batadv_tt_global_dump_entry(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_tt_global_dump_bucket - TODO
+ * @msg: TODO
+ * @portid: TODO
+ * @seq: TODO
+ * @bat_priv: TODO
+ * @head: TODO
+ * @idx_s: TODO
+ * @sub: TODO
+ *
+ * Return: TODO
+ */
 static int
 batadv_tt_global_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 			     struct batadv_priv *bat_priv,
@@ -1949,6 +2011,13 @@ batadv_tt_global_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq,
 	return 0;
 }
 
+/**
+ * batadv_tt_global_dump - TODO
+ * @msg: TODO
+ * @cb: TODO
+ *
+ * Return: TODO
+ */
 int batadv_tt_global_dump(struct sk_buff *msg, struct netlink_callback *cb)
 {
 	struct net *net = sock_net(cb->skb->sk);

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

Re: [B.A.T.M.A.N.] [PATCHv4 00/12] netns and netlink support

[Sven Eckelmann]

[-- Attachment #1.1: Type: text/plain, Size: 23044 bytes --]

=2D-nextPart1707506.UTlYUNyO3a
Content-Transfer-Encoding: 7Bit
Content-Type: text/plain; charset="us-ascii"

On Monday 09 May 2016 20:29:21 Sven Eckelmann wrote:
> On Monday 09 May 2016 20:07:07 Andrew Lunn wrote:
> > This patchset completes netns support, by disabling debugfs entries
> > when not in the default name space, and correctly handling interface
> > stack loops when the parent is in a different name space.
> > 
> > It additionally adds netlink support for most of the information found
> > in debugfs, and is netns awaire.
> 
> Attached is a tarball with the v4 version rebased on the two initial patches
> from the tp_meter patchset. The patches include many TODOs in the kernel-doc
> which should be replaced with actual docs.
> 
> The batctl patch was not yet rebased.

Just tried it and it is not really a big thing to rebase batctl. I have again
taken the initial two patches of the tp_meter patchset.

I hope this helps to reduce the conflicts (even when not resolving it
completely) between the tp_meter and the netlink patchset.

Kind regards,
	Sven
=2D-nextPart1707506.UTlYUNyO3a
Content-Disposition: attachment; filename="andrew_netlink-ecsv_netlink-batctl.diff"
Content-Transfer-Encoding: 7Bit
Content-Type: text/x-patch; charset="UTF-8"; name="andrew_netlink-ecsv_netlink-batctl.diff"

diff --git a/Makefile b/Makefile
index 60795f7..3fa21f4 100755
=2D-- a/Makefile
+++ b/Makefile
@@ -24,7 +24,20 @@ export CONFIG_BATCTL_BISECT=n
 
 # batctl build
 BINARY_NAME = batctl
=2DOBJ = main.o bat-hosts.o functions.o sys.o debug.o ping.o traceroute.o tcpdump.o  hash.o debugfs.o ioctl.o list-batman.o translate.o netlink.o
+OBJ += bat-hosts.o
+OBJ += debugfs.o
+OBJ += debug.o
+OBJ += functions.o
+OBJ += hash.o
+OBJ += ioctl.o
+OBJ += list-batman.o
+OBJ += main.o
+OBJ += netlink.o
+OBJ += ping.o
+OBJ += sys.o
+OBJ += tcpdump.o
+OBJ += traceroute.o
+OBJ += translate.o
 OBJ_BISECT = bisect_iv.o
 MANPAGE = man/batctl.8
 
diff --git a/batman_adv.h b/batman_adv.h
index 6a97a2c..4c8e526 100644
=2D-- a/batman_adv.h
+++ b/batman_adv.h
@@ -56,7 +56,44 @@ enum batadv_tt_client_flags {
 	BATADV_TT_CLIENT_TEMP	 = (1 << 11),
 };
 
=2Denum {
+/**
+ * enum batadv_nl_attrs - batman-adv netlink attributes
+ *
+ * @BATADV_ATTR_UNSPEC: unspecified attribute to catch errors
+ * @BATADV_ATTR_VERSION: batman-adv version string
+ * @BATADV_ATTR_ALGO_NAME: name of routing algorithm
+ * @BATADV_ATTR_MESH_IFINDEX: index of the batman-adv interface
+ * @BATADV_ATTR_MESH_IFNAME: name of the batman-adv interface
+ * @BATADV_ATTR_MESH_ADDRESS: mac address of the batman-adv interface
+ * @BATADV_ATTR_HARD_IFINDEX: index of the non-batman-adv interface
+ * @BATADV_ATTR_HARD_IFNAME: name of the non-batman-adv interface
+ * @BATADV_ATTR_HARD_ADDRESS: mac address of the non-batman-adv interface
+ * @BATADV_ATTR_ACTIVE: TODO
+ * @BATADV_ATTR_ORIG_ADDRESS: TODO
+ * @BATADV_ATTR_TT_ADDRESS: TODO
+ * @BATADV_ATTR_TT_TTVN: TODO
+ * @BATADV_ATTR_TT_LAST_TTVN: TODO
+ * @BATADV_ATTR_TT_CRC32: TODO
+ * @BATADV_ATTR_TT_VID: TODO
+ * @BATADV_ATTR_TT_FLAGS: TODO
+ * @BATADV_ATTR_FLAG_BEST: TODO
+ * @BATADV_ATTR_LAST_SEEN_MSECS: TODO
+ * @BATADV_ATTR_NEIGH_ADDRESS: TODO
+ * @BATADV_ATTR_TQ: TODO
+ * @BATADV_ATTR_THROUGHPUT: TODO
+ * @BATADV_ATTR_BANDWIDTH_UP: TODO
+ * @BATADV_ATTR_BANDWIDTH_DOWN: TODO
+ * @BATADV_ATTR_ROUTER: TODO
+ * @BATADV_ATTR_BLA_OWN: TODO
+ * @BATADV_ATTR_BLA_ADDRESS: TODO
+ * @BATADV_ATTR_BLA_VID: TODO
+ * @BATADV_ATTR_BLA_BACKBONE: TODO
+ * @BATADV_ATTR_BLA_CRC: TODO
+ * @__BATADV_ATTR_AFTER_LAST: internal use
+ * @NUM_BATADV_ATTR: total number of batadv_nl_attrs available
+ * @BATADV_ATTR_MAX: highest attribute number currently defined
+ */
+enum batadv_nl_attrs {
 	BATADV_ATTR_UNSPEC,
 	BATADV_ATTR_VERSION,
 	BATADV_ATTR_ALGO_NAME,
@@ -87,15 +124,32 @@ enum {
 	BATADV_ATTR_BLA_VID,
 	BATADV_ATTR_BLA_BACKBONE,
 	BATADV_ATTR_BLA_CRC,
=2D	__BATADV_ATTR_MAX,
+	/* add attributes above here, update the policy in netlink.c */
+	__BATADV_ATTR_AFTER_LAST,
+	NUM_BATADV_ATTR = __BATADV_ATTR_AFTER_LAST,
+	BATADV_ATTR_MAX = __BATADV_ATTR_AFTER_LAST - 1
 };
 
=2D#define BATADV_ATTR_MAX (__BATADV_ATTR_MAX - 1)
=2D
=2Denum {
+/**
+ * enum batadv_nl_commands - supported batman-adv netlink commands
+ *
+ * @BATADV_CMD_UNSPEC: unspecified command to catch errors
+ * @BATADV_CMD_GET_MESH_INFO: Query basic information about batman-adv device
+ * @BATADV_CMD_GET_ROUTING_ALGOS: TODO
+ * @BATADV_CMD_GET_HARDIFS: TODO
+ * @BATADV_CMD_GET_TRANSTABLE_LOCAL: TODO
+ * @BATADV_CMD_GET_TRANSTABLE_GLOBAL: TODO
+ * @BATADV_CMD_GET_ORIGINATORS: TODO
+ * @BATADV_CMD_GET_NEIGHBORS: TODO
+ * @BATADV_CMD_GET_GATEWAYS: TODO
+ * @BATADV_CMD_GET_BLA_CLAIM: TODO
+ * @__BATADV_CMD_AFTER_LAST: internal use
+ * @BATADV_CMD_MAX: highest used command number
+ */
+enum batadv_nl_commands {
 	BATADV_CMD_UNSPEC,
=2D	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_MESH_INFO,
+	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_HARDIFS,
 	BATADV_CMD_GET_TRANSTABLE_LOCAL,
 	BATADV_CMD_GET_TRANSTABLE_GLOBAL,
@@ -103,9 +157,9 @@ enum {
 	BATADV_CMD_GET_NEIGHBORS,
 	BATADV_CMD_GET_GATEWAYS,
 	BATADV_CMD_GET_BLA_CLAIM,
=2D	__BATADV_CMD_MAX,
+	/* add new commands above here */
+	__BATADV_CMD_AFTER_LAST,
+	BATADV_CMD_MAX = __BATADV_CMD_AFTER_LAST - 1
 };
 
=2D#define BATADV_CMD_MAX (__BATADV_CMD_MAX - 1)
=2D
 #endif /* _UAPI_LINUX_BATMAN_ADV_H_ */
diff --git a/netlink.c b/netlink.c
index e09166c..de2fd8a 100644
=2D-- a/netlink.c
+++ b/netlink.c
@@ -1,3 +1,27 @@
+/*
+ * Copyright (C) 2009-2016  B.A.T.M.A.N. contributors:
+ *
+ * Andrew Lunn <andrew@lunn.ch>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA
+ *
+ */
+
+#include "netlink.h"
+#include "main.h"
+
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
@@ -23,7 +47,7 @@ struct print_opts {
 	float watch_interval;
 };
 
=2Dstatic struct nla_policy policy[BATADV_ATTR_MAX+1] = {
+static 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 },
@@ -145,7 +169,7 @@ static int info_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
=2D		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -247,7 +271,7 @@ static int routing_algos_callback(struct nl_msg *msg, void *arg __unused)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
=2D		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -336,7 +360,7 @@ static int originators_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
=2D		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -470,7 +494,7 @@ static int neighbors_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
=2D		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -561,7 +585,7 @@ static int transglobal_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
=2D		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -657,7 +681,7 @@ static int translocal_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
=2D		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -757,7 +781,7 @@ static int gateways_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
=2D		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -836,7 +860,7 @@ static int bla_claim_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
=2D		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}

=2D-nextPart1707506.UTlYUNyO3a
Content-Disposition: attachment; filename="rebased_split_netlink-batctl.tar.gz"
Content-Transfer-Encoding: base64
Content-Type: application/x-compressed-tar; name="rebased_split_netlink-batctl.tar.gz"
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=

=2D-nextPart1707506.UTlYUNyO3a--
This is a multi-part message in MIME format.

[-- Attachment #1.2: Type: text/plain, Size: 963 bytes --]

On Monday 09 May 2016 20:29:21 Sven Eckelmann wrote:
> On Monday 09 May 2016 20:07:07 Andrew Lunn wrote:
> > This patchset completes netns support, by disabling debugfs entries
> > when not in the default name space, and correctly handling interface
> > stack loops when the parent is in a different name space.
> > 
> > It additionally adds netlink support for most of the information found
> > in debugfs, and is netns awaire.
> 
> Attached is a tarball with the v4 version rebased on the two initial patches
> from the tp_meter patchset. The patches include many TODOs in the kernel-doc
> which should be replaced with actual docs.
> 
> The batctl patch was not yet rebased.

Just tried it and it is not really a big thing to rebase batctl. I have again
taken the initial two patches of the tp_meter patchset.

I hope this helps to reduce the conflicts (even when not resolving it
completely) between the tp_meter and the netlink patchset.

Kind regards,
	Sven

[-- Attachment #1.3: andrew_netlink-ecsv_netlink-batctl.diff --]
[-- Type: text/x-patch, Size: 8053 bytes --]

diff --git a/Makefile b/Makefile
index 60795f7..3fa21f4 100755
--- a/Makefile
+++ b/Makefile
@@ -24,7 +24,20 @@ export CONFIG_BATCTL_BISECT=n
 
 # batctl build
 BINARY_NAME = batctl
-OBJ = main.o bat-hosts.o functions.o sys.o debug.o ping.o traceroute.o tcpdump.o  hash.o debugfs.o ioctl.o list-batman.o translate.o netlink.o
+OBJ += bat-hosts.o
+OBJ += debugfs.o
+OBJ += debug.o
+OBJ += functions.o
+OBJ += hash.o
+OBJ += ioctl.o
+OBJ += list-batman.o
+OBJ += main.o
+OBJ += netlink.o
+OBJ += ping.o
+OBJ += sys.o
+OBJ += tcpdump.o
+OBJ += traceroute.o
+OBJ += translate.o
 OBJ_BISECT = bisect_iv.o
 MANPAGE = man/batctl.8
 
diff --git a/batman_adv.h b/batman_adv.h
index 6a97a2c..4c8e526 100644
--- a/batman_adv.h
+++ b/batman_adv.h
@@ -56,7 +56,44 @@ enum batadv_tt_client_flags {
 	BATADV_TT_CLIENT_TEMP	 = (1 << 11),
 };
 
-enum {
+/**
+ * enum batadv_nl_attrs - batman-adv netlink attributes
+ *
+ * @BATADV_ATTR_UNSPEC: unspecified attribute to catch errors
+ * @BATADV_ATTR_VERSION: batman-adv version string
+ * @BATADV_ATTR_ALGO_NAME: name of routing algorithm
+ * @BATADV_ATTR_MESH_IFINDEX: index of the batman-adv interface
+ * @BATADV_ATTR_MESH_IFNAME: name of the batman-adv interface
+ * @BATADV_ATTR_MESH_ADDRESS: mac address of the batman-adv interface
+ * @BATADV_ATTR_HARD_IFINDEX: index of the non-batman-adv interface
+ * @BATADV_ATTR_HARD_IFNAME: name of the non-batman-adv interface
+ * @BATADV_ATTR_HARD_ADDRESS: mac address of the non-batman-adv interface
+ * @BATADV_ATTR_ACTIVE: TODO
+ * @BATADV_ATTR_ORIG_ADDRESS: TODO
+ * @BATADV_ATTR_TT_ADDRESS: TODO
+ * @BATADV_ATTR_TT_TTVN: TODO
+ * @BATADV_ATTR_TT_LAST_TTVN: TODO
+ * @BATADV_ATTR_TT_CRC32: TODO
+ * @BATADV_ATTR_TT_VID: TODO
+ * @BATADV_ATTR_TT_FLAGS: TODO
+ * @BATADV_ATTR_FLAG_BEST: TODO
+ * @BATADV_ATTR_LAST_SEEN_MSECS: TODO
+ * @BATADV_ATTR_NEIGH_ADDRESS: TODO
+ * @BATADV_ATTR_TQ: TODO
+ * @BATADV_ATTR_THROUGHPUT: TODO
+ * @BATADV_ATTR_BANDWIDTH_UP: TODO
+ * @BATADV_ATTR_BANDWIDTH_DOWN: TODO
+ * @BATADV_ATTR_ROUTER: TODO
+ * @BATADV_ATTR_BLA_OWN: TODO
+ * @BATADV_ATTR_BLA_ADDRESS: TODO
+ * @BATADV_ATTR_BLA_VID: TODO
+ * @BATADV_ATTR_BLA_BACKBONE: TODO
+ * @BATADV_ATTR_BLA_CRC: TODO
+ * @__BATADV_ATTR_AFTER_LAST: internal use
+ * @NUM_BATADV_ATTR: total number of batadv_nl_attrs available
+ * @BATADV_ATTR_MAX: highest attribute number currently defined
+ */
+enum batadv_nl_attrs {
 	BATADV_ATTR_UNSPEC,
 	BATADV_ATTR_VERSION,
 	BATADV_ATTR_ALGO_NAME,
@@ -87,15 +124,32 @@ enum {
 	BATADV_ATTR_BLA_VID,
 	BATADV_ATTR_BLA_BACKBONE,
 	BATADV_ATTR_BLA_CRC,
-	__BATADV_ATTR_MAX,
+	/* add attributes above here, update the policy in netlink.c */
+	__BATADV_ATTR_AFTER_LAST,
+	NUM_BATADV_ATTR = __BATADV_ATTR_AFTER_LAST,
+	BATADV_ATTR_MAX = __BATADV_ATTR_AFTER_LAST - 1
 };
 
-#define BATADV_ATTR_MAX (__BATADV_ATTR_MAX - 1)
-
-enum {
+/**
+ * enum batadv_nl_commands - supported batman-adv netlink commands
+ *
+ * @BATADV_CMD_UNSPEC: unspecified command to catch errors
+ * @BATADV_CMD_GET_MESH_INFO: Query basic information about batman-adv device
+ * @BATADV_CMD_GET_ROUTING_ALGOS: TODO
+ * @BATADV_CMD_GET_HARDIFS: TODO
+ * @BATADV_CMD_GET_TRANSTABLE_LOCAL: TODO
+ * @BATADV_CMD_GET_TRANSTABLE_GLOBAL: TODO
+ * @BATADV_CMD_GET_ORIGINATORS: TODO
+ * @BATADV_CMD_GET_NEIGHBORS: TODO
+ * @BATADV_CMD_GET_GATEWAYS: TODO
+ * @BATADV_CMD_GET_BLA_CLAIM: TODO
+ * @__BATADV_CMD_AFTER_LAST: internal use
+ * @BATADV_CMD_MAX: highest used command number
+ */
+enum batadv_nl_commands {
 	BATADV_CMD_UNSPEC,
-	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_MESH_INFO,
+	BATADV_CMD_GET_ROUTING_ALGOS,
 	BATADV_CMD_GET_HARDIFS,
 	BATADV_CMD_GET_TRANSTABLE_LOCAL,
 	BATADV_CMD_GET_TRANSTABLE_GLOBAL,
@@ -103,9 +157,9 @@ enum {
 	BATADV_CMD_GET_NEIGHBORS,
 	BATADV_CMD_GET_GATEWAYS,
 	BATADV_CMD_GET_BLA_CLAIM,
-	__BATADV_CMD_MAX,
+	/* add new commands above here */
+	__BATADV_CMD_AFTER_LAST,
+	BATADV_CMD_MAX = __BATADV_CMD_AFTER_LAST - 1
 };
 
-#define BATADV_CMD_MAX (__BATADV_CMD_MAX - 1)
-
 #endif /* _UAPI_LINUX_BATMAN_ADV_H_ */
diff --git a/netlink.c b/netlink.c
index e09166c..de2fd8a 100644
--- a/netlink.c
+++ b/netlink.c
@@ -1,3 +1,27 @@
+/*
+ * Copyright (C) 2009-2016  B.A.T.M.A.N. contributors:
+ *
+ * Andrew Lunn <andrew@lunn.ch>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA
+ *
+ */
+
+#include "netlink.h"
+#include "main.h"
+
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
@@ -23,7 +47,7 @@ struct print_opts {
 	float watch_interval;
 };
 
-static struct nla_policy policy[BATADV_ATTR_MAX+1] = {
+static 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 },
@@ -145,7 +169,7 @@ static int info_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
-		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -247,7 +271,7 @@ static int routing_algos_callback(struct nl_msg *msg, void *arg __unused)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
-		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -336,7 +360,7 @@ static int originators_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
-		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -470,7 +494,7 @@ static int neighbors_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
-		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -561,7 +585,7 @@ static int transglobal_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
-		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -657,7 +681,7 @@ static int translocal_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
-		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -757,7 +781,7 @@ static int gateways_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
-		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}
@@ -836,7 +860,7 @@ static int bla_claim_callback(struct nl_msg *msg, void *arg)
 		return NL_OK;
 
 	if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
-		      genlmsg_len(ghdr), policy)) {
+		      genlmsg_len(ghdr), batadv_netlink_policy)) {
 		fputs("Received invalid data from kernel.\n", stderr);
 		exit(1);
 	}

[-- Attachment #1.4: rebased_split_netlink-batctl.tar.gz --]
[-- Type: application/x-compressed-tar, Size: 9860 bytes --]

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

Re: [B.A.T.M.A.N.] [PATCHv4 00/12] netns and netlink support

[Andrew Lunn]

> I hope this helps to reduce the conflicts (even when not resolving it
> completely) between the tp_meter and the netlink patchset.

Hi Sven

Do you want to take over my patches and merge them all into one set?

   Andrew

Re: [B.A.T.M.A.N.] [PATCHv4 00/12] netns and netlink support

[Sven Eckelmann]

[-- Attachment #1: Type: text/plain, Size: 837 bytes --]

On Monday 09 May 2016 21:06:08 Andrew Lunn wrote:
> > I hope this helps to reduce the conflicts (even when not resolving it
> > completely) between the tp_meter and the netlink patchset.
> 
> Hi Sven
> 
> Do you want to take over my patches and merge them all into one set?

No, this is the last thing I want to do :)

I only want to get the "big" conflicts solved and mark the parts which most
likely will needs to be changed before Marek will accept them.

I will have not much time in the next days to do any private work on it. So it
most likely not the best idea to give me the patchset with a lot of TODOs in
it ;)

I will try to poke Antonio and Marek some more so we get a common starting 
point (the two patches from batctl/batman-adv) which we then can use prepare 
our patchsets with a lot less conflicts.

Kind regards,
	Sven

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

Re: [B.A.T.M.A.N.] [PATCHv4 00/12] netns and netlink support

[Sven Eckelmann]

[-- Attachment #1: Type: text/plain, Size: 1599 bytes --]

On Tuesday 10 May 2016 09:00:49 Sven Eckelmann wrote:
> On Monday 09 May 2016 21:06:08 Andrew Lunn wrote:
> > > I hope this helps to reduce the conflicts (even when not resolving it
> > > completely) between the tp_meter and the netlink patchset.
> > 
> > Hi Sven
> > 
> > Do you want to take over my patches and merge them all into one set?
> 
> No, this is the last thing I want to do :)
> 
> I only want to get the "big" conflicts solved and mark the parts which most
> likely will needs to be changed before Marek will accept them.
> 
> I will have not much time in the next days to do any private work on it. So it
> most likely not the best idea to give me the patchset with a lot of TODOs in
> it ;)
> 
> I will try to poke Antonio and Marek some more so we get a common starting 
> point (the two patches from batctl/batman-adv) which we then can use prepare 
> our patchsets with a lot less conflicts.

Some reports which I forgot to mention yesterday and which I've just remembered:


bracket_align master ./net/batman-adv/bat_iv_ogm.c
--------------------------------------------------

    Found wrong alignment at ./net/batman-adv/bat_iv_ogm.c:2371, was 37 but expected 61
    Found wrong alignment at ./net/batman-adv/bat_iv_ogm.c:2372, was 37 but expected 61


checkpatch master ./net/batman-adv/bat_v.c
------------------------------------------

    CHECK: Please don't use multiple blank lines
    #450: FILE: ./net/batman-adv/bat_v.c:450:
    +
    +
    
    total: 0 errors, 0 warnings, 1 checks, 732 lines checked

Kind regards,
	Sven

[-- Attachment #2: This is a digitally signed message part. --]
[-- Type: application/pgp-signature, Size: 819 bytes --]