Difuse/routing
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #495 from ecsv/batadv-2019.3

Browse source 
batman-adv 2019.3
This commit is contained in:
Simon Wunderlich 2019-08-02 09:53:03 +02:00 committed by GitHub
commit ecb7132f01
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 58 additions and 1077 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
alfred/Makefile
View file

@ -8,9 +8,9 @@
include $(TOPDIR)/rules.mk
PKG_NAME:=alfred
PKG_VERSION:=2019.2
PKG_VERSION:=2019.3
PKG_RELEASE:=0
PKG_HASH:=b656f0e9a97a99c7531b6d49ebfd663451c16cdd275bbf7d48ff8daed3880bf2
PKG_HASH:=a4c37920de497701680abb55c49cdcd11e4e7135e0e7e79259c35492a3df4766
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz
PKG_SOURCE_URL:=https://downloads.open-mesh.org/batman/releases/batman-adv-$(PKG_VERSION)

21
alfred/patches/0001-alfred-vis-Add-missing-include-for-ifinfomsg.patch Normal file
View file

@ -0,0 +1,21 @@
From: Sven Eckelmann <sven@narfation.org>
Date: Thu, 1 Aug 2019 15:54:32 +0200
Subject: alfred: vis: Add missing include for ifinfomsg
Fixes: 0fc6e6674428 ("alfred: vis: Retrieve hardif status via generic netlink")
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Origin: upstream, https://git.open-mesh.org/alfred.git/commit/ce26453bd72829ac9561acd8d3a06a3937341687
diff --git a/vis/vis.c b/vis/vis.c
index 947456343125458845f26dc38b53f18d6fd42d75..8df3056612d5da3678603a6e6430923c0c86cde0 100644
--- a/vis/vis.c
+++ b/vis/vis.c
@@ -10,6 +10,7 @@
#include <dirent.h>
#include <errno.h>
#include <getopt.h>
+#include <linux/rtnetlink.h>
#include <net/if.h>
#include <netinet/in.h>
#include <signal.h>

6
batctl/Makefile
View file

@ -9,9 +9,9 @@ include $(TOPDIR)/rules.mk
PKG_NAME:=batctl
PKG_VERSION:=2019.2
PKG_RELEASE:=1
PKG_HASH:=fb656208ff7d4cd8b1b422f60c9e6d8747302a347cbf6c199d7afa9b80f80ea3
PKG_VERSION:=2019.3
PKG_RELEASE:=0
PKG_HASH:=2bd93fa14925a8dc63a67e64266c8ccd2fa3ac44b10253d93e6f8a630350070c
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz
PKG_SOURCE_URL:=https://downloads.open-mesh.org/batman/releases/batman-adv-$(PKG_VERSION)

324
batctl/patches/0001-batctl-Make-vlan-setting-explicit.patch
View file

@ -1,324 +0,0 @@
From: Sven Eckelmann <sven@narfation.org>
Date: Thu, 13 Jun 2019 21:12:14 +0200
Subject: batctl: Make vlan setting explicit
The requirement to have a VLAN master device on top of the batadv mesh
interface is artificially limiting the capabilities of batctl. Not all
master devices in linux which register a VLAN are from type "vlan" and are
only registering a single VLAN.
For example VLAN aware bridges can create multiple VLANs. These require
that the VLAN is identified using the VID and not the vlan device.
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Forwarded: https://patchwork.open-mesh.org/patch/17947/
diff --git a/ap_isolation.c b/ap_isolation.c
index 71dcd00eac845d488c4969b17e1339f181c6c913..7c34649225dcc9cc557cc5bb4cbfa2343f8c0763 100644
--- a/ap_isolation.c
+++ b/ap_isolation.c
@@ -81,3 +81,8 @@ COMMAND_NAMED(SUBCOMMAND, ap_isolation, "ap", handle_sys_setting,
COMMAND_FLAG_MESH_IFACE | COMMAND_FLAG_NETLINK,
&batctl_settings_ap_isolation,
"[0|1] \tdisplay or modify ap_isolation setting");
+
+COMMAND_NAMED(SUBCOMMAND_VID, ap_isolation, "ap", handle_sys_setting,
+ COMMAND_FLAG_MESH_IFACE | COMMAND_FLAG_NETLINK,
+ &batctl_settings_ap_isolation,
+ "[0|1] \tdisplay or modify ap_isolation setting for vlan device or id");
diff --git a/main.c b/main.c
index 278683c6080e3ff4a9f3225931d0c5eb44f89595..6ca13ac0ec4c82ee969be04737a339fd702b52bd 100644
--- a/main.c
+++ b/main.c
@@ -28,48 +28,75 @@ extern const struct command *__stop___command[];
static void print_usage(void)
{
- enum command_type type[] = {
- SUBCOMMAND,
- DEBUGTABLE,
+ struct {
+ const char *label;
+ uint32_t types;
+ } type[] = {
+ {
+ .label = "commands:\n",
+ .types = BIT(SUBCOMMAND) |
+ BIT(SUBCOMMAND_VID),
+ },
+ {
+ .label = "debug tables: \tdisplay the corresponding debug table\n",
+ .types = BIT(DEBUGTABLE),
+ },
+ };
+ const char *default_prefixes[] = {
+ "",
+ NULL,
+ };
+ const char *vlan_prefixes[] = {
+ "vlan <vdev> ",
+ "vid <vid> ",
+ NULL,
};
const struct command **p;
- char buf[32];
+ const char **prefixes;
+ const char **prefix;
+ char buf[64];
size_t i;
fprintf(stderr, "Usage: batctl [options] command|debug table [parameters]\n");
fprintf(stderr, "options:\n");
- fprintf(stderr, " \t-m mesh interface or VLAN created on top of a mesh interface (default 'bat0')\n");
+ fprintf(stderr, " \t-m mesh interface (default 'bat0')\n");
fprintf(stderr, " \t-h print this help (or 'batctl <command|debug table> -h' for the parameter help)\n");
fprintf(stderr, " \t-v print version\n");
for (i = 0; i < sizeof(type) / sizeof(*type); i++) {
fprintf(stderr, "\n");
- switch (type[i]) {
- case SUBCOMMAND:
- fprintf(stderr, "commands:\n");
- break;
- case DEBUGTABLE:
- fprintf(stderr, "debug tables: \tdisplay the corresponding debug table\n");
- break;
- }
+ fprintf(stderr, "%s", type[i].label);
for (p = __start___command; p < __stop___command; p++) {
const struct command *cmd = *p;
- if (cmd->type != type[i])
+ if (!(BIT(cmd->type) & type[i].types))
continue;
if (!cmd->usage)
continue;
- if (strcmp(cmd->name, cmd->abbr) == 0)
- snprintf(buf, sizeof(buf), "%s", cmd->name);
- else
- snprintf(buf, sizeof(buf), "%s|%s", cmd->name,
- cmd->abbr);
+ switch (cmd->type) {
+ case SUBCOMMAND_VID:
+ prefixes = vlan_prefixes;
+ break;
+ default:
+ prefixes = default_prefixes;
+ break;
+ }
- fprintf(stderr, " \t%-27s%s\n", buf, cmd->usage);
+ for (prefix = &prefixes[0]; *prefix; prefix++) {
+ if (strcmp(cmd->name, cmd->abbr) == 0)
+ snprintf(buf, sizeof(buf), "%s%s",
+ *prefix, cmd->name);
+ else
+ snprintf(buf, sizeof(buf), "%s%s|%s",
+ *prefix, cmd->name, cmd->abbr);
+
+ fprintf(stderr, " \t%-35s%s\n", buf,
+ cmd->usage);
+ }
}
}
}
@@ -93,13 +120,19 @@ static void version(void)
exit(EXIT_SUCCESS);
}
-static const struct command *find_command(const char *name)
+static const struct command *find_command(struct state *state, const char *name)
{
const struct command **p;
for (p = __start___command; p < __stop___command; p++) {
const struct command *cmd = *p;
+ if (state->vid >= 0 && cmd->type != SUBCOMMAND_VID)
+ continue;
+
+ if (state->vid < 0 && cmd->type == SUBCOMMAND_VID)
+ continue;
+
if (strcmp(cmd->name, name) == 0)
return cmd;
@@ -110,6 +143,51 @@ static const struct command *find_command(const char *name)
return NULL;
}
+static int parse_dev_args(struct state *state, int argc, char *argv[])
+{
+ unsigned long vid;
+ char *endptr;
+
+ /* not enough arguments to parse */
+ if (argc < 2) {
+ translate_mesh_iface(state);
+ return 0;
+ }
+
+ if (strcmp(argv[0], "vid") == 0) {
+ if (argv[1] == '\0') {
+ fprintf(stderr, "Error - unparsable vid\n");
+ return -EINVAL;
+ }
+
+ vid = strtoul(argv[1], &endptr, 0);
+ if (!endptr || *endptr != '\0') {
+ fprintf(stderr, "Error - unparsable vid\n");
+ return -EINVAL;
+ }
+
+ if (vid > 4095) {
+ fprintf(stderr, "Error - too large vid (max 4095)\n");
+ return -ERANGE;
+ }
+
+ /* get mesh interface and overwrite vid afterwards */
+ translate_mesh_iface(state);
+ state->vid = vid;
+
+ return 2;
+ } else if (strcmp(argv[0], "vlan") == 0) {
+ state->arg_iface = argv[1];
+ translate_mesh_iface(state);
+
+ return 2;
+ } else {
+ /* parse vlan as part of -m parameter */
+ translate_mesh_iface(state);
+ return 0;
+ }
+}
+
int main(int argc, char **argv)
{
const struct command *cmd;
@@ -117,6 +195,7 @@ int main(int argc, char **argv)
.arg_iface = mesh_dfl_iface,
.cmd = NULL,
};
+ int dev_arguments;
int opt;
int ret;
@@ -152,7 +231,15 @@ int main(int argc, char **argv)
argc -= optind;
optind = 0;
- cmd = find_command(argv[0]);
+ /* parse arguments to identify vlan, ... */
+ dev_arguments = parse_dev_args(&state, argc, argv);
+ if (dev_arguments < 0)
+ goto err;
+
+ argv += dev_arguments;
+ argc -= dev_arguments;
+
+ cmd = find_command(&state, argv[0]);
if (!cmd) {
fprintf(stderr,
"Error - no valid command or debug table specified: %s\n",
@@ -162,8 +249,6 @@ int main(int argc, char **argv)
state.cmd = cmd;
- translate_mesh_iface(&state);
-
if (cmd->flags & COMMAND_FLAG_MESH_IFACE &&
check_mesh_iface(&state) < 0) {
fprintf(stderr,
diff --git a/main.h b/main.h
index 1a4701513c49ad8974b9c9189619f5dde622acd4..1d952610aefb8367bd52e24bea8c04c3d70b94ea 100644
--- a/main.h
+++ b/main.h
@@ -58,6 +58,7 @@ enum command_flags {
enum command_type {
SUBCOMMAND,
+ SUBCOMMAND_VID,
DEBUGTABLE,
};
@@ -84,7 +85,7 @@ struct command {
};
#define COMMAND_NAMED(_type, _name, _abbr, _handler, _flags, _arg, _usage) \
- static const struct command command_ ## _name = { \
+ static const struct command command_ ## _name ## _ ## _type = { \
.type = (_type), \
.name = (#_name), \
.abbr = _abbr, \
@@ -93,8 +94,8 @@ struct command {
.arg = (_arg), \
.usage = (_usage), \
}; \
- static const struct command *__command_ ## _name \
- __attribute__((__used__)) __attribute__ ((__section__ ("__command"))) = &command_ ## _name
+ static const struct command *__command_ ## _name ## _ ## _type \
+ __attribute__((__used__)) __attribute__ ((__section__ ("__command"))) = &command_ ## _name ## _ ## _type
#define COMMAND(_type, _handler, _abbr, _flags, _arg, _usage) \
COMMAND_NAMED(_type, _handler, _abbr, _handler, _flags, _arg, _usage)
diff --git a/man/batctl.8 b/man/batctl.8
index 0b430313075b5a7a4c796eba0867954e10061002..acb4288c4e6f59b322d20631ef8e3aee6f2215e5 100644
--- a/man/batctl.8
+++ b/man/batctl.8
@@ -68,7 +68,7 @@ free all attached interfaces and remove batman-adv interface.
If no parameter is given the current originator interval setting is displayed otherwise the parameter is used to set the
originator interval. The interval is in units of milliseconds.
.br
-.IP "\fBap_isolation\fP|\fBap\fP [\fB0\fP|\fB1\fP]"
+.IP "[\fBvlan <vdev>\fP|\fBvid <vid>\fP] \fBap_isolation\fP|\fBap\fP [\fB0\fP|\fB1\fP]"
If no parameter is given the current ap isolation setting is displayed. Otherwise the parameter is used to enable or
disable ap isolation. This command can be used in conjunction with "\-m" option to target per VLAN configurations.
.br
diff --git a/sys.c b/sys.c
index 39123db87d391b8898b7454eba7708515bfb3c78..f19719cfad61f36f2a5c1078305de83eb5be142a 100644
--- a/sys.c
+++ b/sys.c
@@ -141,9 +141,35 @@ int sys_simple_print_boolean(struct nl_msg *msg, void *arg,
static void settings_usage(struct state *state)
{
- fprintf(stderr, "Usage: batctl [options] %s|%s [parameters] %s\n",
- state->cmd->name, state->cmd->abbr,
- state->cmd->usage ? state->cmd->usage : "");
+ const char *default_prefixes[] = {
+ "",
+ NULL,
+ };
+ const char *vlan_prefixes[] = {
+ "vlan <vdev> ",
+ "vid <vid> ",
+ NULL,
+ };
+ const char *linestart = "Usage:";
+ const char **prefixes;
+ const char **prefix;
+
+ switch (state->cmd->type) {
+ case SUBCOMMAND_VID:
+ prefixes = vlan_prefixes;
+ break;
+ default:
+ prefixes = default_prefixes;
+ break;
+ }
+
+ for (prefix = &prefixes[0]; *prefix; prefix++) {
+ fprintf(stderr, "%s batctl [options] %s%s|%s [parameters] %s\n",
+ linestart, *prefix, state->cmd->name, state->cmd->abbr,
+ state->cmd->usage ? state->cmd->usage : "");
+
+ linestart = " ";
+ }
fprintf(stderr, "parameters:\n");
fprintf(stderr, " \t -h print this help\n");

183
batctl/patches/0002-batctl-Integrate-hardif-setting-framework.patch
View file

@ -1,183 +0,0 @@
From: Sven Eckelmann <sven@narfation.org>
Date: Thu, 13 Jun 2019 21:12:15 +0200
Subject: batctl: Integrate hardif setting framework
batctl currently supports settings which are either mesh interface or vlan
specific. But B.A.T.M.A.N. V introduced two additional settings which are
hard (slave) interface specific.
To support these, an additional command prefix called hardif is implemented
for some sysfs commands:
$ batctl -m bat0 hardif eth0 ...
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Forwarded: https://patchwork.open-mesh.org/patch/17948/
diff --git a/main.c b/main.c
index 6ca13ac0ec4c82ee969be04737a339fd702b52bd..c806dbf4373fd082ff368cba391bdf14eebf4eae 100644
--- a/main.c
+++ b/main.c
@@ -35,7 +35,8 @@ static void print_usage(void)
{
.label = "commands:\n",
.types = BIT(SUBCOMMAND) |
- BIT(SUBCOMMAND_VID),
+ BIT(SUBCOMMAND_VID) |
+ BIT(SUBCOMMAND_HIF),
},
{
.label = "debug tables: \tdisplay the corresponding debug table\n",
@@ -51,6 +52,10 @@ static void print_usage(void)
"vid <vid> ",
NULL,
};
+ const char *hardif_prefixes[] = {
+ "hardif <netdev> ",
+ NULL,
+ };
const struct command **p;
const char **prefixes;
const char **prefix;
@@ -81,6 +86,9 @@ static void print_usage(void)
case SUBCOMMAND_VID:
prefixes = vlan_prefixes;
break;
+ case SUBCOMMAND_HIF:
+ prefixes = hardif_prefixes;
+ break;
default:
prefixes = default_prefixes;
break;
@@ -133,6 +141,12 @@ static const struct command *find_command(struct state *state, const char *name)
if (state->vid < 0 && cmd->type == SUBCOMMAND_VID)
continue;
+ if (state->hif > 0 && cmd->type != SUBCOMMAND_HIF)
+ continue;
+
+ if (state->hif == 0 && cmd->type == SUBCOMMAND_HIF)
+ continue;
+
if (strcmp(cmd->name, name) == 0)
return cmd;
@@ -180,6 +194,18 @@ static int parse_dev_args(struct state *state, int argc, char *argv[])
state->arg_iface = argv[1];
translate_mesh_iface(state);
+ return 2;
+ } else if (strcmp(argv[0], "hardif") == 0) {
+ state->hif = if_nametoindex(argv[1]);
+ if (state->hif == 0) {
+ fprintf(stderr, "Error - hard interface not found\n");
+ return -ENODEV;
+ }
+
+ snprintf(state->hard_iface, sizeof(state->hard_iface), "%s",
+ argv[1]);
+
+ translate_mesh_iface(state);
return 2;
} else {
/* parse vlan as part of -m parameter */
@@ -193,6 +219,7 @@ int main(int argc, char **argv)
const struct command *cmd;
struct state state = {
.arg_iface = mesh_dfl_iface,
+ .hif = 0,
.cmd = NULL,
};
int dev_arguments;
diff --git a/main.h b/main.h
index 1d952610aefb8367bd52e24bea8c04c3d70b94ea..a27d8486ef689206b27b1b50cb017b1b740e91c9 100644
--- a/main.h
+++ b/main.h
@@ -59,6 +59,7 @@ enum command_flags {
enum command_type {
SUBCOMMAND,
SUBCOMMAND_VID,
+ SUBCOMMAND_HIF,
DEBUGTABLE,
};
@@ -66,6 +67,8 @@ struct state {
char *arg_iface;
char mesh_iface[IF_NAMESIZE];
unsigned int mesh_ifindex;
+ char hard_iface[IF_NAMESIZE];
+ unsigned int hif;
int vid;
const struct command *cmd;
diff --git a/sys.c b/sys.c
index f19719cfad61f36f2a5c1078305de83eb5be142a..fd34b2fa3bcf168a32bd53fc0df3f35d5532433f 100644
--- a/sys.c
+++ b/sys.c
@@ -150,6 +150,10 @@ static void settings_usage(struct state *state)
"vid <vid> ",
NULL,
};
+ const char *hardif_prefixes[] = {
+ "hardif <netdev> ",
+ NULL,
+ };
const char *linestart = "Usage:";
const char **prefixes;
const char **prefix;
@@ -158,6 +162,9 @@ static void settings_usage(struct state *state)
case SUBCOMMAND_VID:
prefixes = vlan_prefixes;
break;
+ case SUBCOMMAND_HIF:
+ prefixes = hardif_prefixes;
+ break;
default:
prefixes = default_prefixes;
break;
@@ -259,15 +266,23 @@ int handle_sys_setting(struct state *state, int argc, char **argv)
return EXIT_FAILURE;
}
- /* if the specified interface is a VLAN then change the path to point
- * to the proper "vlan%{vid}" subfolder in the sysfs tree.
- */
- if (state->vid >= 0)
+ if (state->hif > 0) {
+ /* if a hard interface was specified then change the path to
+ * point to the proper ${hardif}/batman-adv path in the sysfs
+ * tree.
+ */
+ snprintf(path_buff, PATH_BUFF_LEN, SYS_HARDIF_PATH,
+ state->hard_iface);
+ } else if (state->vid >= 0) {
+ /* if the specified interface is a VLAN then change the path to
+ * point to the proper "vlan%{vid}" subfolder in the sysfs tree.
+ */
snprintf(path_buff, PATH_BUFF_LEN, SYS_VLAN_PATH,
state->mesh_iface, state->vid);
- else
+ } else {
snprintf(path_buff, PATH_BUFF_LEN, SYS_BATIF_PATH_FMT,
state->mesh_iface);
+ }
if (argc == 1) {
res = sys_read_setting(state, path_buff, settings->sysfs_name);
diff --git a/sys.h b/sys.h
index d4f2fcf542bc66b2b1c6ec55a9ac16e10fdc5cac..b6f0f9043a9af8e3c4d4f8bf7e4af4cab0aa5df9 100644
--- a/sys.h
+++ b/sys.h
@@ -21,8 +21,9 @@
#define SYS_BATIF_PATH_FMT "/sys/class/net/%s/mesh/"
#define SYS_IFACE_PATH "/sys/class/net"
#define SYS_IFACE_DIR SYS_IFACE_PATH"/%s/"
-#define SYS_MESH_IFACE_FMT SYS_IFACE_PATH"/%s/batman_adv/mesh_iface"
-#define SYS_IFACE_STATUS_FMT SYS_IFACE_PATH"/%s/batman_adv/iface_status"
+#define SYS_HARDIF_PATH SYS_IFACE_DIR "batman_adv/"
+#define SYS_MESH_IFACE_FMT SYS_HARDIF_PATH "mesh_iface"
+#define SYS_IFACE_STATUS_FMT SYS_HARDIF_PATH "iface_status"
#define SYS_VLAN_PATH SYS_IFACE_PATH"/%s/mesh/vlan%d/"
#define SYS_ROUTING_ALGO_FMT SYS_IFACE_PATH"/%s/mesh/routing_algo"
#define VLAN_ID_MAX_LEN 4

183
batctl/patches/0003-batctl-Add-elp_interval-setting-command.patch
View file

@ -1,183 +0,0 @@
From: Sven Eckelmann <sven@narfation.org>
Date: Thu, 13 Jun 2019 21:12:16 +0200
Subject: batctl: Add elp_interval setting command
B.A.T.M.A.N. V introduced a hard interface specific setting called
elp_interval. It defines the interval in milliseconds in which batman-adv
emits probing packets for neighbor sensing (ELP).
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Forwarded: https://patchwork.open-mesh.org/patch/17949/
diff --git a/Makefile b/Makefile
index b7bd545e92963c62128efe60c0dc401bdd9fa023..f071da20f866bff6c162d697d2e43fa9d68ee08d 100755
--- a/Makefile
+++ b/Makefile
@@ -45,6 +45,7 @@ $(eval $(call add_command,bridge_loop_avoidance,y))
$(eval $(call add_command,claimtable,y))
$(eval $(call add_command,dat_cache,y))
$(eval $(call add_command,distributed_arp_table,y))
+$(eval $(call add_command,elp_interval,y))
$(eval $(call add_command,event,y))
$(eval $(call add_command,fragmentation,y))
$(eval $(call add_command,gateways,y))
diff --git a/README.rst b/README.rst
index bc54412bc77dae1889d4f05298c34efc1966776b..92983aa6030e2a890283bca448b9203cd4d56b51 100644
--- a/README.rst
+++ b/README.rst
@@ -386,6 +386,22 @@ Example::
1000
+batctl elp interval
+===================
+
+display or modify the elp interval in ms for hard interface
+
+Usage::
+
+ batctl hardif $hardif elp_interval|et [interval]
+
+Example::
+
+ $ batctl hardif eth0 elp_interval 200
+ $ batctl hardif eth0 elp_interval
+ 200
+
+
batctl loglevel
===============
diff --git a/elp_interval.c b/elp_interval.c
new file mode 100644
index 0000000000000000000000000000000000000000..0a5e98923a622f52e523696b1ec1bfb856eeca9f
--- /dev/null
+++ b/elp_interval.c
@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (C) 2009-2019 B.A.T.M.A.N. contributors:
+ *
+ * Marek Lindner <mareklindner@neomailbox.ch>
+ *
+ * License-Filename: LICENSES/preferred/GPL-2.0
+ */
+
+#include <errno.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "main.h"
+#include "sys.h"
+
+static struct elp_interval_data {
+ uint32_t elp_interval;
+} elp_interval;
+
+static int parse_elp_interval(struct state *state, int argc, char *argv[])
+{
+ struct settings_data *settings = state->cmd->arg;
+ struct elp_interval_data *data = settings->data;
+ char *endptr;
+
+ if (argc != 2) {
+ fprintf(stderr, "Error - incorrect number of arguments (expected 1)\n");
+ return -EINVAL;
+ }
+
+ data->elp_interval = strtoul(argv[1], &endptr, 0);
+ if (!endptr || *endptr != '\0') {
+ fprintf(stderr, "Error - the supplied argument is invalid: %s\n", argv[1]);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int print_elp_interval(struct nl_msg *msg, void *arg)
+{
+ struct nlattr *attrs[BATADV_ATTR_MAX + 1];
+ struct nlmsghdr *nlh = nlmsg_hdr(msg);
+ struct genlmsghdr *ghdr;
+ int *result = arg;
+
+ if (!genlmsg_valid_hdr(nlh, 0))
+ return NL_OK;
+
+ ghdr = nlmsg_data(nlh);
+
+ if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
+ genlmsg_len(ghdr), batadv_netlink_policy)) {
+ return NL_OK;
+ }
+
+ if (!attrs[BATADV_ATTR_ELP_INTERVAL])
+ return NL_OK;
+
+ printf("%u\n", nla_get_u32(attrs[BATADV_ATTR_ELP_INTERVAL]));
+
+ *result = 0;
+ return NL_STOP;
+}
+
+static int get_attrs_elp_interval(struct nl_msg *msg, void *arg)
+{
+ struct state *state = arg;
+
+ nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, state->hif);
+
+ return 0;
+}
+
+static int get_elp_interval(struct state *state)
+{
+ return sys_simple_nlquery(state, BATADV_CMD_GET_HARDIF,
+ get_attrs_elp_interval, print_elp_interval);
+}
+
+static int set_attrs_elp_interval(struct nl_msg *msg, void *arg)
+{
+ struct state *state = arg;
+ struct settings_data *settings = state->cmd->arg;
+ struct elp_interval_data *data = settings->data;
+
+ nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, state->hif);
+ nla_put_u32(msg, BATADV_ATTR_ELP_INTERVAL, data->elp_interval);
+
+ return 0;
+}
+
+static int set_elp_interval(struct state *state)
+{
+ return sys_simple_nlquery(state, BATADV_CMD_SET_HARDIF,
+ set_attrs_elp_interval, NULL);
+}
+
+static struct settings_data batctl_settings_elp_interval = {
+ .sysfs_name = "elp_interval",
+ .data = &elp_interval,
+ .parse = parse_elp_interval,
+ .netlink_get = get_elp_interval,
+ .netlink_set = set_elp_interval,
+};
+
+COMMAND_NAMED(SUBCOMMAND_HIF, elp_interval, "et", handle_sys_setting,
+ COMMAND_FLAG_MESH_IFACE | COMMAND_FLAG_NETLINK,
+ &batctl_settings_elp_interval,
+ "[interval] \tdisplay or modify elp_interval setting");
diff --git a/man/batctl.8 b/man/batctl.8
index acb4288c4e6f59b322d20631ef8e3aee6f2215e5..690da023fd1ac6f51915a9167e92030a650fe1bd 100644
--- a/man/batctl.8
+++ b/man/batctl.8
@@ -93,6 +93,10 @@ the bonding mode.
batctl will monitor for events from the netlink kernel interface of batman-adv. The local timestamp of the event will be printed
when parameter \fB\-t\fP is specified. Parameter \fB\-r\fP will do the same but with relative timestamps.
.br
+.IP "\fBhardif <hardif>\fP \fBelp_interval\fP|\fBet\fP [\fBinterval\fP]"
+If no parameter is given the current ELP interval setting of the hard interface is displayed otherwise the parameter is used to set the
+ELP interval. The interval is in units of milliseconds.
+.br
.IP "\fBfragmentation\fP|\fBf\fP [\fB0\fP|\fB1\fP]"
If no parameter is given the current fragmentation mode setting is displayed. Otherwise the parameter is used to enable or
disable fragmentation.

189
batctl/patches/0004-batctl-Add-throughput_override-setting-command.patch
View file

@ -1,189 +0,0 @@
From: Sven Eckelmann <sven@narfation.org>
Date: Thu, 13 Jun 2019 21:12:17 +0200
Subject: batctl: Add throughput_override setting command
B.A.T.M.A.N. V introduced a hard interface specific setting called
throughput. It defines the throughput value to be used by B.A.T.M.A.N. V
when estimating the link throughput using this interface. If the value is
set to 0 then batman-adv will try to estimate the throughput by itself.
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Forwarded: https://patchwork.open-mesh.org/patch/17950/
diff --git a/Makefile b/Makefile
index f071da20f866bff6c162d697d2e43fa9d68ee08d..e3747a2a28eb34323e34a1e22f5507dd1d7cd0f6 100755
--- a/Makefile
+++ b/Makefile
@@ -67,6 +67,7 @@ $(eval $(call add_command,ping,y))
$(eval $(call add_command,routing_algo,y))
$(eval $(call add_command,statistics,y))
$(eval $(call add_command,tcpdump,y))
+$(eval $(call add_command,throughput_override,y))
$(eval $(call add_command,throughputmeter,y))
$(eval $(call add_command,traceroute,y))
$(eval $(call add_command,transglobal,y))
diff --git a/README.rst b/README.rst
index 92983aa6030e2a890283bca448b9203cd4d56b51..128f539852fa085d023fb6d26ae436e76b617bb6 100644
--- a/README.rst
+++ b/README.rst
@@ -402,6 +402,23 @@ Example::
200
+batctl throughput override
+==========================
+
+display or modify the throughput override in kbit/s for hard interface
+
+Usage::
+
+ batctl hardif $hardif throughput_override|to [kbit]
+
+Example::
+
+ $ batctl hardif eth0 throughput_override 15000
+ $ batctl hardif eth0 throughput_override 15mbit
+ $ batctl hardif eth0 throughput_override
+ 15.0 MBit
+
+
batctl loglevel
===============
diff --git a/man/batctl.8 b/man/batctl.8
index 690da023fd1ac6f51915a9167e92030a650fe1bd..b8218963712bbf0cc9470459896fc904cd393748 100644
--- a/man/batctl.8
+++ b/man/batctl.8
@@ -203,6 +203,12 @@ supported routing algorithms are displayed.
Otherwise the parameter is used to select the routing algorithm for the following
batX interface to be created.
.br
+.IP "\fBhardif <hardif>\fP \fBthroughput_override|to\fP [\fBbandwidth\fP]\fP"
+If no parameter is given the current througput override is displayed otherwise
+the parameter is used to set the throughput override for the specified hard
+interface.
+Just enter any number (optionally followed by "kbit" or "mbit").
+.br
.IP "\fBisolation_mark\fP|\fBmark\fP"
If no parameter is given the current isolation mark value is displayed.
Otherwise the parameter is used to set or unset the isolation mark used by the
diff --git a/throughput_override.c b/throughput_override.c
new file mode 100644
index 0000000000000000000000000000000000000000..28a6588b9417cca213ebde3545a3eb425592ad89
--- /dev/null
+++ b/throughput_override.c
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (C) 2009-2019 B.A.T.M.A.N. contributors:
+ *
+ * Marek Lindner <mareklindner@neomailbox.ch>
+ *
+ * License-Filename: LICENSES/preferred/GPL-2.0
+ */
+
+#include <errno.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "functions.h"
+#include "main.h"
+#include "sys.h"
+
+static struct throughput_override_data {
+ uint32_t throughput_override;
+} throughput_override;
+
+static int parse_throughput_override(struct state *state, int argc, char *argv[])
+{
+ struct settings_data *settings = state->cmd->arg;
+ struct throughput_override_data *data = settings->data;
+ bool ret;
+
+ if (argc != 2) {
+ fprintf(stderr, "Error - incorrect number of arguments (expected 1)\n");
+ return -EINVAL;
+ }
+
+ ret = parse_throughput(argv[1], "throughput override",
+ &data->throughput_override);
+ if (!ret)
+ return -EINVAL;
+
+ return 0;
+}
+
+static int print_throughput_override(struct nl_msg *msg, void *arg)
+{
+ struct nlattr *attrs[BATADV_ATTR_MAX + 1];
+ struct nlmsghdr *nlh = nlmsg_hdr(msg);
+ struct genlmsghdr *ghdr;
+ int *result = arg;
+ uint32_t mbit;
+
+ if (!genlmsg_valid_hdr(nlh, 0))
+ return NL_OK;
+
+ ghdr = nlmsg_data(nlh);
+
+ if (nla_parse(attrs, BATADV_ATTR_MAX, genlmsg_attrdata(ghdr, 0),
+ genlmsg_len(ghdr), batadv_netlink_policy)) {
+ return NL_OK;
+ }
+
+ if (!attrs[BATADV_ATTR_THROUGHPUT_OVERRIDE])
+ return NL_OK;
+
+ mbit = nla_get_u32(attrs[BATADV_ATTR_THROUGHPUT_OVERRIDE]);
+ printf("%u.%u MBit\n", mbit / 10, mbit % 10);
+
+ *result = 0;
+ return NL_STOP;
+}
+
+static int get_attrs_elp_isolation(struct nl_msg *msg, void *arg)
+{
+ struct state *state = arg;
+
+ nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, state->hif);
+
+ return 0;
+}
+
+static int get_throughput_override(struct state *state)
+{
+ return sys_simple_nlquery(state, BATADV_CMD_GET_HARDIF,
+ get_attrs_elp_isolation, print_throughput_override);
+}
+
+static int set_attrs_throughput_override(struct nl_msg *msg, void *arg)
+{
+ struct state *state = arg;
+ struct settings_data *settings = state->cmd->arg;
+ struct throughput_override_data *data = settings->data;
+
+ nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, state->hif);
+ nla_put_u32(msg, BATADV_ATTR_THROUGHPUT_OVERRIDE, data->throughput_override);
+
+ return 0;
+}
+
+static int set_throughput_override(struct state *state)
+{
+ return sys_simple_nlquery(state, BATADV_CMD_SET_HARDIF,
+ set_attrs_throughput_override, NULL);
+}
+
+static struct settings_data batctl_settings_throughput_override = {
+ .sysfs_name = "throughput_override",
+ .data = &throughput_override,
+ .parse = parse_throughput_override,
+ .netlink_get = get_throughput_override,
+ .netlink_set = set_throughput_override,
+};
+
+COMMAND_NAMED(SUBCOMMAND_HIF, throughput_override, "to", handle_sys_setting,
+ COMMAND_FLAG_MESH_IFACE | COMMAND_FLAG_NETLINK,
+ &batctl_settings_throughput_override,
+ "[mbit] \tdisplay or modify throughput_override setting");

6
batman-adv/Makefile
View file

@ -9,9 +9,9 @@ include $(TOPDIR)/rules.mk
PKG_NAME:=batman-adv
PKG_VERSION:=2019.2
PKG_RELEASE:=4
PKG_HASH:=70c3f6a6cf88d2b25681a76768a52ed92d9fe992ba8e358368b6a8088757adc8
PKG_VERSION:=2019.3
PKG_RELEASE:=0
PKG_HASH:=3454dc8bd6cb264e2decda1b99ef3f837535ed33802abc6c39551c181d3984ce
PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.gz
PKG_SOURCE_URL:=https://downloads.open-mesh.org/batman/releases/batman-adv-$(PKG_VERSION)

40
batman-adv/files/lib/netifd/proto/batadv.sh
View file

@ -72,42 +72,42 @@ proto_batadv_setup() {
set_default routing_algo 'BATMAN_IV'
batctl routing_algo "$routing_algo"
batctl -m "$iface" interface create
batctl meshif "$iface" interface create
[ -n "$aggregated_ogms" ] && batctl -m "$iface" aggregation "$aggregated_ogms"
[ -n "$ap_isolation" ] && batctl -m "$iface" ap_isolation "$ap_isolation"
[ -n "$bonding" ] && batctl -m "$iface" bonding "$bonding"
[ -n "$bridge_loop_avoidance" ] && batctl -m "$iface" bridge_loop_avoidance "$bridge_loop_avoidance" 2>&-
[ -n "$distributed_arp_table" ] && batctl -m "$iface" distributed_arp_table "$distributed_arp_table" 2>&-
[ -n "$fragmentation" ] && batctl -m "$iface" fragmentation "$fragmentation"
[ -n "$aggregated_ogms" ] && batctl meshif "$iface" aggregation "$aggregated_ogms"
[ -n "$ap_isolation" ] && batctl meshif "$iface" ap_isolation "$ap_isolation"
[ -n "$bonding" ] && batctl meshif "$iface" bonding "$bonding"
[ -n "$bridge_loop_avoidance" ] && batctl meshif "$iface" bridge_loop_avoidance "$bridge_loop_avoidance" 2>&-
[ -n "$distributed_arp_table" ] && batctl meshif "$iface" distributed_arp_table "$distributed_arp_table" 2>&-
[ -n "$fragmentation" ] && batctl meshif "$iface" fragmentation "$fragmentation"
case "$gw_mode" in
server)
if [ -n "$gw_bandwidth" ]; then
batctl -m "$iface" gw_mode "server" "$gw_bandwidth"
batctl meshif "$iface" gw_mode "server" "$gw_bandwidth"
else
batctl -m "$iface" gw_mode "server"
batctl meshif "$iface" gw_mode "server"
fi
;;
client)
if [ -n "$gw_sel_class" ]; then
batctl -m "$iface" gw_mode "client" "$gw_sel_class"
batctl meshif "$iface" gw_mode "client" "$gw_sel_class"
else
batctl -m "$iface" gw_mode "client"
batctl meshif "$iface" gw_mode "client"
fi
;;
*)
batctl -m "$iface" gw_mode "off"
batctl meshif "$iface" gw_mode "off"
;;
esac
[ -n "$hop_penalty" ] && batctl -m "$iface" hop_penalty "$hop_penalty"
[ -n "$isolation_mark" ] && batctl -m "$iface" isolation_mark "$isolation_mark"
[ -n "$multicast_fanout" ] && batctl -m "$iface" multicast_fanout "$multicast_fanout"
[ -n "$multicast_mode" ] && batctl -m "$iface" multicast_mode "$multicast_mode" 2>&-
[ -n "$network_coding" ] && batctl -m "$iface" network_coding "$network_coding" 2>&-
[ -n "$log_level" ] && batctl -m "$iface" loglevel "$log_level" 2>&-
[ -n "$orig_interval" ] && batctl -m "$iface" orig_interval "$orig_interval"
[ -n "$hop_penalty" ] && batctl meshif "$iface" hop_penalty "$hop_penalty"
[ -n "$isolation_mark" ] && batctl meshif "$iface" isolation_mark "$isolation_mark"
[ -n "$multicast_fanout" ] && batctl meshif "$iface" multicast_fanout "$multicast_fanout"
[ -n "$multicast_mode" ] && batctl meshif "$iface" multicast_mode "$multicast_mode" 2>&-
[ -n "$network_coding" ] && batctl meshif "$iface" network_coding "$network_coding" 2>&-
[ -n "$log_level" ] && batctl meshif "$iface" loglevel "$log_level" 2>&-
[ -n "$orig_interval" ] && batctl meshif "$iface" orig_interval "$orig_interval"
proto_init_update "$iface" 1
proto_send_update "$config"
@ -117,7 +117,7 @@ proto_batadv_teardown() {
local config="$1"
local iface="$config"
batctl -m "$iface" interface destroy
batctl meshif "$iface" interface destroy
}
add_protocol batadv

8
batman-adv/files/lib/netifd/proto/batadv_hardif.sh
View file

@ -26,10 +26,10 @@ proto_batadv_hardif_setup() {
( proto_add_host_dependency "$config" '' "$master" )
batctl -m "$master" interface -M add "$iface"
batctl meshif "$master" interface -M add "$iface"
[ -n "$elp_interval" ] && batctl -m "$master" hardif "$iface" elp_interval "$elp_interval"
[ -n "$throughput_override" ] && batctl -m "$master" hardif "$iface" throughput_override "$throughput_override"
[ -n "$elp_interval" ] && batctl hardif "$iface" elp_interval "$elp_interval"
[ -n "$throughput_override" ] && batctl hardif "$iface" throughput_override "$throughput_override"
proto_init_update "$iface" 1
proto_send_update "$config"
@ -43,7 +43,7 @@ proto_batadv_hardif_teardown() {
json_get_vars master
batctl -m "$master" interface -M del "$iface" || true
batctl meshif "$master" interface -M del "$iface" || true
}
add_protocol batadv_hardif

2
batman-adv/files/lib/netifd/proto/batadv_vlan.sh
View file

@ -17,7 +17,7 @@ proto_batadv_vlan_setup() {
json_get_vars ap_isolation
[ -n "$ap_isolation" ] && batctl -m "$iface" ap_isolation "$ap_isolation"
[ -n "$ap_isolation" ] && batctl vlan "$iface" ap_isolation "$ap_isolation"
proto_init_update "$iface" 1
proto_send_update "$config"
}

77
batman-adv/patches/0001-batman-adv-Fix-duplicated-OGMs-on-NETDEV_UP.patch
View file

@ -1,77 +0,0 @@
From: Sven Eckelmann <sven@narfation.org>
Date: Sun, 2 Jun 2019 10:57:31 +0200
Subject: batman-adv: Fix duplicated OGMs on NETDEV_UP
The state of slave interfaces are handled differently depending on whether
the interface is up or not. All active interfaces (IFF_UP) will transmit
OGMs. But for B.A.T.M.A.N. IV, also non-active interfaces are scheduling
(low TTL) OGMs on active interfaces. The code which setups and schedules
the OGMs must therefore already be called when the interfaces gets added as
slave interface and the transmit function must then check whether it has to
send out the OGM or not on the specific slave interface.
But the commit 0d8468553c3c ("batman-adv: remove ogm_emit and ogm_schedule
API calls") moved the setup code from the enable function to the activate
function. The latter is called either when the added slave was already up
when batadv_hardif_enable_interface processed the new interface or when a
NETDEV_UP event was received for this slave interfac. As result, each
NETDEV_UP would schedule a new OGM worker for the interface and thus OGMs
would be send a lot more than expected.
Fixes: 0d8468553c3c ("batman-adv: remove ogm_emit and ogm_schedule API calls")
Reported-by: Linus Lüssing <linus.luessing@c0d3.blue>
Signed-off-by: Sven Eckelmann <sven@narfation.org>
Origin: upstream, https://git.open-mesh.org/batman-adv.git/commit/c92331e0df3c0c5645ee5a897eb018c5da5e4aa5
diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c
index bd4138ddf7e09a0020d9842d603dc98f21e225c7..240ed70912d6a014c0a48280741989133034396c 100644
--- a/net/batman-adv/bat_iv_ogm.c
+++ b/net/batman-adv/bat_iv_ogm.c
@@ -2337,7 +2337,7 @@ batadv_iv_ogm_neigh_is_sob(struct batadv_neigh_node *neigh1,
return ret;
}
-static void batadv_iv_iface_activate(struct batadv_hard_iface *hard_iface)
+static void batadv_iv_iface_enabled(struct batadv_hard_iface *hard_iface)
{
/* begin scheduling originator messages on that interface */
batadv_iv_ogm_schedule(hard_iface);
@@ -2683,8 +2683,8 @@ static void batadv_iv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb,
static struct batadv_algo_ops batadv_batman_iv __read_mostly = {
.name = "BATMAN_IV",
.iface = {
- .activate = batadv_iv_iface_activate,
.enable = batadv_iv_ogm_iface_enable,
+ .enabled = batadv_iv_iface_enabled,
.disable = batadv_iv_ogm_iface_disable,
.update_mac = batadv_iv_ogm_iface_update_mac,
.primary_set = batadv_iv_ogm_primary_iface_set,
diff --git a/net/batman-adv/hard-interface.c b/net/batman-adv/hard-interface.c
index 79d1731b83066c60f9aef958d2bc343233bce67a..3719cfd026f04093f5d86ffe1b41a41849b2af62 100644
--- a/net/batman-adv/hard-interface.c
+++ b/net/batman-adv/hard-interface.c
@@ -795,6 +795,9 @@ int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface,
batadv_hardif_recalc_extra_skbroom(soft_iface);
+ if (bat_priv->algo_ops->iface.enabled)
+ bat_priv->algo_ops->iface.enabled(hard_iface);
+
out:
return 0;
diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h
index 74b644738a36bfe063eef6df016278b45a1a0256..e0b25104cbfa9f715df364658621c29faa7ad637 100644
--- a/net/batman-adv/types.h
+++ b/net/batman-adv/types.h
@@ -2129,6 +2129,9 @@ struct batadv_algo_iface_ops {
/** @enable: init routing info when hard-interface is enabled */
int (*enable)(struct batadv_hard_iface *hard_iface);
+ /** @enabled: notification when hard-interface was enabled (optional) */
+ void (*enabled)(struct batadv_hard_iface *hard_iface);
+
/** @disable: de-init routing info when hard-interface is disabled */
void (*disable)(struct batadv_hard_iface *hard_iface);

92
batman-adv/src/compat-hacks.h
View file

@ -5,24 +5,7 @@
#include <linux/version.h> /* LINUX_VERSION_CODE */
#include <linux/types.h>
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 1, 0)
#define dev_get_iflink(_net_dev) ((_net_dev)->iflink)
#endif /* < KERNEL_VERSION(4, 1, 0) */
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 5, 0)
#include <linux/netdevice.h>
#define netdev_master_upper_dev_link(dev, upper_dev, upper_priv, upper_info, extack) ({\
BUILD_BUG_ON(upper_priv != NULL); \
BUILD_BUG_ON(upper_info != NULL); \
BUILD_BUG_ON(extack != NULL); \
netdev_master_upper_dev_link(dev, upper_dev); \
})
#elif LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)
#include <linux/netdevice.h>
@ -31,27 +14,10 @@
netdev_master_upper_dev_link(dev, upper_dev, upper_priv, upper_info); \
})
#endif /* < KERNEL_VERSION(4, 5, 0) */
#endif /* < KERNEL_VERSION(4, 15, 0) */
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 0, 0)
/* wild hack for batadv_getlink_net only */
#define get_link_net get_xstats_size || 1 ? fallback_net : (struct net*)netdev->rtnl_link_ops->get_xstats_size
#endif /* < KERNEL_VERSION(4, 0, 0) */
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 2, 0)
struct sk_buff *skb_checksum_trimmed(struct sk_buff *skb,
unsigned int transport_len,
__sum16(*skb_chkf)(struct sk_buff *skb));
int ip_mc_check_igmp(struct sk_buff *skb);
int ipv6_mc_check_mld(struct sk_buff *skb);
#elif LINUX_VERSION_CODE < KERNEL_VERSION(5, 1, 0)
#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 1, 0)
#include_next <linux/igmp.h>
#include_next <net/addrconf.h>
@ -86,57 +52,7 @@ static inline int batadv_ip_mc_check_igmp2(struct sk_buff *skb,
#define ip_mc_check_igmp(...) \
ip_mc_check_igmp_get(__VA_ARGS__, batadv_ip_mc_check_igmp2, batadv_ip_mc_check_igmp1)(__VA_ARGS__)
#endif /* < KERNEL_VERSION(4, 2, 0) */
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 3, 0)
#define IFF_NO_QUEUE 0; dev->tx_queue_len = 0
static inline bool hlist_fake(struct hlist_node *h)
{
return h->pprev == &h->next;
}
#endif /* < KERNEL_VERSION(4, 3, 0) */
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0)
#include <linux/ethtool.h>
#define ethtool_link_ksettings batadv_ethtool_link_ksettings
struct batadv_ethtool_link_ksettings {
struct {
__u32 speed;
__u8 duplex;
__u8 autoneg;
} base;
};
#define __ethtool_get_link_ksettings(__dev, __link_settings) \
batadv_ethtool_get_link_ksettings(__dev, __link_settings)
static inline int
batadv_ethtool_get_link_ksettings(struct net_device *dev,
struct ethtool_link_ksettings *link_ksettings)
{
struct ethtool_cmd cmd;
int ret;
memset(&cmd, 0, sizeof(cmd));
ret = __ethtool_get_settings(dev, &cmd);
if (ret != 0)
return ret;
link_ksettings->base.duplex = cmd.duplex;
link_ksettings->base.speed = ethtool_cmd_speed(&cmd);
link_ksettings->base.autoneg = cmd.autoneg;
return 0;
}
#endif /* < KERNEL_VERSION(4, 6, 0) */
#endif /* < KERNEL_VERSION(5, 1, 0) */
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0)