* [B.A.T.M.A.N.] [PATCHv2 1/7] batman-adv: Return reason for failure in batadv_check_unicast_packet()
2012-12-14 6:32 [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Martin Hundebøll
@ 2012-12-14 6:32 ` Martin Hundebøll
2012-12-15 8:10 ` Marek Lindner
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 2/7] batman-adv: Add the initial code for network coding Martin Hundebøll
` (6 subsequent siblings)
7 siblings, 1 reply; 14+ messages in thread
From: Martin Hundebøll @ 2012-12-14 6:32 UTC (permalink / raw)
To: b.a.t.m.a.n; +Cc: Martin Hundebøll
For network coding it is needed to know if a packet has another host as
destination as the packet should be buffered for decoding. To avoid
double checking the destination, the behaviour of
batadv_check_unicast_packet() is changed to return a value based on the
reason to drop the packet, which will be used in later patches for
network coding.
Signed-off-by: Martin Hundebøll <martin@hundeboll.net>
---
routing.c | 16 +++++++++++++---
1 file changed, 13 insertions(+), 3 deletions(-)
diff --git a/routing.c b/routing.c
index 1aa1722..0cea96b 100644
--- a/routing.c
+++ b/routing.c
@@ -552,6 +552,16 @@ batadv_find_ifalter_router(struct batadv_orig_node *primary_orig,
return router;
}
+/**
+ * batadv_check_unicast_packet - Check for malformed unicast packets
+ * @skb: packet to check
+ * @hdr_size: size of header to pull
+ *
+ * Check for short header and bad addresses in given packet. Returns negative
+ * value when check fails and 0 otherwise. The negative value depends on the
+ * reason: -1 for bad header, -2 for broadcast destination, -3 for broadcast
+ * source, and -4 for non-local (other host) destination.
+ */
static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size)
{
struct ethhdr *ethhdr;
@@ -564,15 +574,15 @@ static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size)
/* packet with unicast indication but broadcast recipient */
if (is_broadcast_ether_addr(ethhdr->h_dest))
- return -1;
+ return -2;
/* packet with broadcast sender address */
if (is_broadcast_ether_addr(ethhdr->h_source))
- return -1;
+ return -3;
/* not for me */
if (!batadv_is_my_mac(ethhdr->h_dest))
- return -1;
+ return -4;
return 0;
}
--
1.8.0.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [B.A.T.M.A.N.] [PATCHv2 1/7] batman-adv: Return reason for failure in batadv_check_unicast_packet()
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 1/7] batman-adv: Return reason for failure in batadv_check_unicast_packet() Martin Hundebøll
@ 2012-12-15 8:10 ` Marek Lindner
2012-12-15 12:39 ` Antonio Quartulli
0 siblings, 1 reply; 14+ messages in thread
From: Marek Lindner @ 2012-12-15 8:10 UTC (permalink / raw)
To: The list for a Better Approach To Mobile Ad-hoc Networking
On Friday, December 14, 2012 14:32:46 Martin Hundebøll wrote:
> static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size)
> {
> struct ethhdr *ethhdr;
> @@ -564,15 +574,15 @@ static int batadv_check_unicast_packet(struct sk_buff
> *skb, int hdr_size)
>
> /* packet with unicast indication but broadcast recipient */
> if (is_broadcast_ether_addr(ethhdr->h_dest))
> - return -1;
> + return -2;
>
> /* packet with broadcast sender address */
> if (is_broadcast_ether_addr(ethhdr->h_source))
> - return -1;
> + return -3;
>
> /* not for me */
> if (!batadv_is_my_mac(ethhdr->h_dest))
> - return -1;
> + return -4;
>
> return 0;
> }
Returning meaningless numbers isn't the way to go. Either we make our own
defines or we re-use our E***** friends.
By the way, I suggest to send this patch separately. It increases the chance
of getting merged faster and reduces your patchset.
Cheers,
Marek
^ permalink raw reply [flat|nested] 14+ messages in thread* Re: [B.A.T.M.A.N.] [PATCHv2 1/7] batman-adv: Return reason for failure in batadv_check_unicast_packet()
2012-12-15 8:10 ` Marek Lindner
@ 2012-12-15 12:39 ` Antonio Quartulli
0 siblings, 0 replies; 14+ messages in thread
From: Antonio Quartulli @ 2012-12-15 12:39 UTC (permalink / raw)
To: The list for a Better Approach To Mobile Ad-hoc Networking
[-- Attachment #1: Type: text/plain, Size: 1634 bytes --]
On Sat, Dec 15, 2012 at 04:10:17PM +0800, Marek Lindner wrote:
> On Friday, December 14, 2012 14:32:46 Martin Hundebøll wrote:
> > static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size)
> > {
> > struct ethhdr *ethhdr;
> > @@ -564,15 +574,15 @@ static int batadv_check_unicast_packet(struct sk_buff
> > *skb, int hdr_size)
> >
> > /* packet with unicast indication but broadcast recipient */
> > if (is_broadcast_ether_addr(ethhdr->h_dest))
> > - return -1;
> > + return -2;
> >
> > /* packet with broadcast sender address */
> > if (is_broadcast_ether_addr(ethhdr->h_source))
> > - return -1;
> > + return -3;
> >
> > /* not for me */
> > if (!batadv_is_my_mac(ethhdr->h_dest))
> > - return -1;
> > + return -4;
> >
> > return 0;
> > }
>
> Returning meaningless numbers isn't the way to go. Either we make our own
> defines or we re-use our E***** friends.
If I am not mistaken you only use "-4" in your network coding code. Maybe you
want to reduce this distinction to two cases only?
e.g.
* -EINVAL : incorrect header or bad fields (-1, -2, -3)..the packet is not valid
in the end
* something else for your case..what about -EREMOTE ?
>
> By the way, I suggest to send this patch separately. It increases the chance
> of getting merged faster and reduces your patchset.
I agree on this. It would simplify your daily rebasing task. And when/if you do
so, remember to change the commit message: networking does not exist yet.
Cheers,
--
Antonio Quartulli
..each of us alone is worth nothing..
Ernesto "Che" Guevara
[-- Attachment #2: Type: application/pgp-signature, Size: 836 bytes --]
^ permalink raw reply [flat|nested] 14+ messages in thread
* [B.A.T.M.A.N.] [PATCHv2 2/7] batman-adv: Add the initial code for network coding.
2012-12-14 6:32 [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Martin Hundebøll
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 1/7] batman-adv: Return reason for failure in batadv_check_unicast_packet() Martin Hundebøll
@ 2012-12-14 6:32 ` Martin Hundebøll
2012-12-15 13:15 ` Antonio Quartulli
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 3/7] batman-adv: Detect coding nodes and remove these after timeout Martin Hundebøll
` (5 subsequent siblings)
7 siblings, 1 reply; 14+ messages in thread
From: Martin Hundebøll @ 2012-12-14 6:32 UTC (permalink / raw)
To: b.a.t.m.a.n; +Cc: Martin Hundebøll
Network coding exploits the 802.11 shared medium to allow multiple
packets to be sent in a single transmission. In brief, a relay can XOR
two packets, and send the coded packet to two destinations. The
receivers can decode one of the original packets by XOR'ing the coded
packet with the other original packet. This will lead to increased
throughput in topologies where two packets cross one relay.
In a simple topology with three nodes, it takes four transmissions
without network coding to get one packet from Node A to Node B and one
from Node B to Node A:
1. Node A ---- p1 ---> Node R Node B
2. Node A Node R <--- p2 ---- Node B
3. Node A <--- p2 ---- Node R Node B
4. Node A Node R ---- p1 ---> Node B
With network coding, the relay only needs one transmission, which saves
us one slot of valuable airtime:
1. Node A ---- p1 ---> Node R Node B
2. Node A Node R <--- p2 ---- Node B
3. Node A <- p1 x p2 - Node R - p1 x p2 -> Node B
The same principle holds for a topology including five nodes. Here the
packets from Node A and Node B are overheard by Node C and Node D,
respectively. This allows Node R to send a network coded packet to save
one transmission:
Node A Node B
| \ / |
| p1 p2 |
| \ / |
p1 > Node R < p2
| |
| / \ |
| p1 x p2 p1 x p2 |
v / \ v
/ \
Node C < > Node D
More information is available on the open-mesh.org wiki[1].
This patch adds the initial code to support network coding in
batman-adv. It sets up a worker thread to do house keeping and adds a
sysfs file to enable/disable network coding. The feature is disabled by
default, as it requires a wifi-driver with working promiscuous mode, and
also because it adds a small delay at each hop.
[1] http://www.open-mesh.org/projects/batman-adv/wiki/Catwoman
Signed-off-by: Martin Hundebøll <martin@hundeboll.net>
---
Makefile | 2 ++
Makefile.kbuild | 1 +
gen-compat-autoconf.sh | 1 +
main.c | 6 ++++
main.h | 4 ++-
network-coding.c | 81 ++++++++++++++++++++++++++++++++++++++++++++++++++
network-coding.h | 48 ++++++++++++++++++++++++++++++
soft-interface.c | 3 ++
sysfs-class-net-mesh | 8 +++++
sysfs.c | 6 ++++
types.h | 17 +++++++++++
11 files changed, 176 insertions(+), 1 deletion(-)
create mode 100644 network-coding.c
create mode 100644 network-coding.h
diff --git a/Makefile b/Makefile
index 4d70e40..d41f947 100644
--- a/Makefile
+++ b/Makefile
@@ -25,6 +25,8 @@ export CONFIG_BATMAN_ADV_DEBUG=n
export CONFIG_BATMAN_ADV_BLA=y
# B.A.T.M.A.N. distributed ARP table:
export CONFIG_BATMAN_ADV_DAT=y
+# B.A.T.M.A.N network coding (catwoman):
+export CONFIG_BATMAN_ADV_NC=n
PWD:=$(shell pwd)
KERNELPATH ?= /lib/modules/$(shell uname -r)/build
diff --git a/Makefile.kbuild b/Makefile.kbuild
index e45e3b4..4b8f192 100644
--- a/Makefile.kbuild
+++ b/Makefile.kbuild
@@ -30,6 +30,7 @@ batman-adv-y += hard-interface.o
batman-adv-y += hash.o
batman-adv-y += icmp_socket.o
batman-adv-y += main.o
+batman-adv-$(CONFIG_BATMAN_ADV_NC) += network-coding.o
batman-adv-y += originator.o
batman-adv-y += ring_buffer.o
batman-adv-y += routing.o
diff --git a/gen-compat-autoconf.sh b/gen-compat-autoconf.sh
index 7ea42aa..78573e4 100755
--- a/gen-compat-autoconf.sh
+++ b/gen-compat-autoconf.sh
@@ -39,6 +39,7 @@ gen_config() {
gen_config 'CONFIG_BATMAN_ADV_DEBUG' ${CONFIG_BATMAN_ADV_DEBUG:="n"} >> "${TMP}"
gen_config 'CONFIG_BATMAN_ADV_BLA' ${CONFIG_BATMAN_ADV_BLA:="y"} >> "${TMP}"
gen_config 'CONFIG_BATMAN_ADV_DAT' ${CONFIG_BATMAN_ADV_DAT:="y"} >> "${TMP}"
+gen_config 'CONFIG_BATMAN_ADV_NC' ${CONFIG_BATMAN_ADV_NC:="n"} >> "${TMP}"
# only regenerate compat-autoconf.h when config was changed
diff "${TMP}" "${TARGET}" > /dev/null 2>&1 || cp "${TMP}" "${TARGET}"
diff --git a/main.c b/main.c
index f65a222..f08c057 100644
--- a/main.c
+++ b/main.c
@@ -35,6 +35,7 @@
#include "vis.h"
#include "hash.h"
#include "bat_algo.h"
+#include "network-coding.h"
/* List manipulations on hardif_list have to be rtnl_lock()'ed,
@@ -135,6 +136,10 @@ int batadv_mesh_init(struct net_device *soft_iface)
if (ret < 0)
goto err;
+ ret = batadv_nc_init(bat_priv);
+ if (ret < 0)
+ goto err;
+
atomic_set(&bat_priv->gw.reselect, 0);
atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE);
@@ -157,6 +162,7 @@ void batadv_mesh_free(struct net_device *soft_iface)
batadv_gw_node_purge(bat_priv);
batadv_originator_free(bat_priv);
+ batadv_nc_free(bat_priv);
batadv_tt_free(bat_priv);
diff --git a/main.h b/main.h
index 2032de2..ee09f0f 100644
--- a/main.h
+++ b/main.h
@@ -185,6 +185,7 @@ __be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr);
* @BATADV_DBG_TT: translation table messages
* @BATADV_DBG_BLA: bridge loop avoidance messages
* @BATADV_DBG_DAT: ARP snooping and DAT related messages
+ * @BATADV_DBG_NC: network coding related messages
* @BATADV_DBG_ALL: the union of all the above log levels
*/
enum batadv_dbg_level {
@@ -193,7 +194,8 @@ enum batadv_dbg_level {
BATADV_DBG_TT = BIT(2),
BATADV_DBG_BLA = BIT(3),
BATADV_DBG_DAT = BIT(4),
- BATADV_DBG_ALL = 31,
+ BATADV_DBG_NC = BIT(5),
+ BATADV_DBG_ALL = 63,
};
#ifdef CONFIG_BATMAN_ADV_DEBUG
diff --git a/network-coding.c b/network-coding.c
new file mode 100644
index 0000000..4f0409d
--- /dev/null
+++ b/network-coding.c
@@ -0,0 +1,81 @@
+/* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
+ *
+ * Martin Hundebøll, Jeppe Ledet-Pedersen
+ *
+ * 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 "main.h"
+#include "network-coding.h"
+
+static void batadv_nc_worker(struct work_struct *work);
+
+/**
+ * batadv_nc_start_timer - initialise the nc periodic worker
+ * @bat_priv: the bat priv with all the soft interface information
+ */
+static void batadv_nc_start_timer(struct batadv_priv *bat_priv)
+{
+ queue_delayed_work(batadv_event_workqueue, &bat_priv->nc.work,
+ msecs_to_jiffies(10));
+}
+
+/**
+ * batadv_nc_init - initialise coding hash table and start house keeping
+ * @bat_priv: the bat priv with all the soft interface information
+ */
+int batadv_nc_init(struct batadv_priv *bat_priv)
+{
+ INIT_DELAYED_WORK(&bat_priv->nc.work, batadv_nc_worker);
+ batadv_nc_start_timer(bat_priv);
+
+ return 0;
+}
+
+/**
+ * batadv_nc_init_bat_priv - initialise the nc specific bat_priv variables
+ * @bat_priv: the bat priv with all the soft interface information
+ */
+void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
+{
+ atomic_set(&bat_priv->network_coding, 1);
+}
+
+/**
+ * batadv_nc_worker - periodic task for house keeping related to network coding
+ * @work: kernel work struct
+ */
+static void batadv_nc_worker(struct work_struct *work)
+{
+ struct delayed_work *delayed_work;
+ struct batadv_priv_nc *priv_nc;
+ struct batadv_priv *bat_priv;
+
+ delayed_work = container_of(work, struct delayed_work, work);
+ priv_nc = container_of(delayed_work, struct batadv_priv_nc, work);
+ bat_priv = container_of(priv_nc, struct batadv_priv, nc);
+
+ /* Schedule a new check */
+ batadv_nc_start_timer(bat_priv);
+}
+
+/**
+ * batadv_nc_free - clean up network coding memory
+ * @bat_priv: the bat priv with all the soft interface information
+ */
+void batadv_nc_free(struct batadv_priv *bat_priv)
+{
+ cancel_delayed_work_sync(&bat_priv->nc.work);
+}
diff --git a/network-coding.h b/network-coding.h
new file mode 100644
index 0000000..b805899
--- /dev/null
+++ b/network-coding.h
@@ -0,0 +1,48 @@
+/* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
+ *
+ * Martin Hundebøll, Jeppe Ledet-Pedersen
+ *
+ * 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
+ */
+
+#ifndef _NET_BATMAN_ADV_NETWORK_CODING_H
+#define _NET_BATMAN_ADV_NETWORK_CODING_H
+
+#ifdef CONFIG_BATMAN_ADV_NC
+
+int batadv_nc_init(struct batadv_priv *bat_priv);
+void batadv_nc_free(struct batadv_priv *bat_priv);
+void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv);
+
+#else /* ifdef CONFIG_BATMAN_ADV_NC */
+
+static inline int batadv_nc_init(struct batadv_priv *bat_priv)
+{
+ return 0;
+}
+
+static inline void batadv_nc_free(struct batadv_priv *bat_priv)
+{
+ return;
+}
+
+static inline void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
+{
+ return;
+}
+
+#endif /* ifdef CONFIG_BATMAN_ADV_NC */
+
+#endif /* _NET_BATMAN_ADV_NETWORK_CODING_H */
diff --git a/soft-interface.c b/soft-interface.c
index fcf8acc..69ad5e2 100644
--- a/soft-interface.c
+++ b/soft-interface.c
@@ -37,6 +37,7 @@
#include <linux/if_ether.h>
#include "unicast.h"
#include "bridge_loop_avoidance.h"
+#include "network-coding.h"
static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
@@ -515,6 +516,8 @@ struct net_device *batadv_softif_create(const char *name)
if (ret < 0)
goto unreg_soft_iface;
+ batadv_nc_init_bat_priv(bat_priv);
+
ret = batadv_sysfs_add_meshif(soft_iface);
if (ret < 0)
goto unreg_soft_iface;
diff --git a/sysfs-class-net-mesh b/sysfs-class-net-mesh
index bc41da6..bdcd8b4 100644
--- a/sysfs-class-net-mesh
+++ b/sysfs-class-net-mesh
@@ -67,6 +67,14 @@ Description:
Defines the penalty which will be applied to an
originator message's tq-field on every hop.
+What: /sys/class/net/<mesh_iface>/mesh/network_coding
+Date: Nov 2012
+Contact: Martin Hundeboll <martin@hundeboll.net>
+Description:
+ Controls whether Network Coding (using some magic
+ to send fewer wifi packets but still the same
+ content) is enabled or not.
+
What: /sys/class/net/<mesh_iface>/mesh/orig_interval
Date: May 2010
Contact: Marek Lindner <lindner_marek@yahoo.de>
diff --git a/sysfs.c b/sysfs.c
index 84a55cb..e48a62b 100644
--- a/sysfs.c
+++ b/sysfs.c
@@ -442,6 +442,9 @@ static BATADV_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, batadv_show_gw_bwidth,
#ifdef CONFIG_BATMAN_ADV_DEBUG
BATADV_ATTR_SIF_UINT(log_level, S_IRUGO | S_IWUSR, 0, BATADV_DBG_ALL, NULL);
#endif
+#ifdef CONFIG_BATMAN_ADV_NC
+BATADV_ATTR_SIF_BOOL(network_coding, S_IRUGO | S_IWUSR, NULL);
+#endif
static struct batadv_attribute *batadv_mesh_attrs[] = {
&batadv_attr_aggregated_ogms,
@@ -464,6 +467,9 @@ static struct batadv_attribute *batadv_mesh_attrs[] = {
#ifdef CONFIG_BATMAN_ADV_DEBUG
&batadv_attr_log_level,
#endif
+#ifdef CONFIG_BATMAN_ADV_NC
+ &batadv_attr_network_coding,
+#endif
NULL,
};
diff --git a/types.h b/types.h
index ae9ac9a..5451fc8 100644
--- a/types.h
+++ b/types.h
@@ -265,6 +265,19 @@ struct batadv_priv_dat {
};
#endif
+/**
+ * struct batadv_priv_nc - per mesh interface network coding private data
+ * @work: work queue callback item for cleanup
+ */
+struct batadv_priv_nc {
+ struct delayed_work work;
+};
+
+/**
+ * struct batadv_priv - per mesh interface private data
+ * @network_coding: enable/disable network coding
+ * @batadv_priv_nc: network coding private data
+ */
struct batadv_priv {
atomic_t mesh_state;
struct net_device_stats stats;
@@ -308,6 +321,10 @@ struct batadv_priv {
#ifdef CONFIG_BATMAN_ADV_DAT
struct batadv_priv_dat dat;
#endif
+#ifdef CONFIG_BATMAN_ADV_NC
+ atomic_t network_coding; /* boolean */
+ struct batadv_priv_nc nc;
+#endif /* CONFIG_BATMAN_ADV_NC */
};
struct batadv_socket_client {
--
1.8.0.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [B.A.T.M.A.N.] [PATCHv2 3/7] batman-adv: Detect coding nodes and remove these after timeout
2012-12-14 6:32 [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Martin Hundebøll
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 1/7] batman-adv: Return reason for failure in batadv_check_unicast_packet() Martin Hundebøll
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 2/7] batman-adv: Add the initial code for network coding Martin Hundebøll
@ 2012-12-14 6:32 ` Martin Hundebøll
2012-12-18 22:54 ` Antonio Quartulli
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 4/7] batman-adv: Buffer unicast packets before forward Martin Hundebøll
` (4 subsequent siblings)
7 siblings, 1 reply; 14+ messages in thread
From: Martin Hundebøll @ 2012-12-14 6:32 UTC (permalink / raw)
To: b.a.t.m.a.n; +Cc: Martin Hundebøll
To use network coding efficiently, a relay must know when neighbor nodes
are likely to have enough information to be able to decode a network
coded packet. This is detected by using OGMs from batman-adv to discover
when one neighbor is in range of another neighbor. The relay check the
TLL to detect when an OGM is forwarded from one neighbor by another
neighbor, and thereby knows that the two neighbors are in range and thus
overhear packets sent by each other.
This information is saved in the orig_node struct to be used when
searching for coding opportunities. Two lists are added to the
orig_node struct: One for neighbors that can hear the orig_node
(outgoing nc_nodes) and one for neighbors that the orig_node can hear
(incoming nc_nodes).
Information about nc_nodes is kept for 10 seconds and is available
through debugfs in batman_adv/nc_nodes to use when debugging network
coding.
Signed-off-by: Martin Hundebøll <martin@hundeboll.net>
---
bat_iv_ogm.c | 5 +
debugfs.c | 18 +++
main.h | 2 +
network-coding.c | 416 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
network-coding.h | 47 +++++++
originator.c | 6 +
types.h | 27 ++++
7 files changed, 521 insertions(+)
diff --git a/bat_iv_ogm.c b/bat_iv_ogm.c
index 662743e..4431fd2 100644
--- a/bat_iv_ogm.c
+++ b/bat_iv_ogm.c
@@ -27,6 +27,7 @@
#include "hard-interface.h"
#include "send.h"
#include "bat_algo.h"
+#include "network-coding.h"
static struct batadv_neigh_node *
batadv_iv_ogm_neigh_new(struct batadv_hard_iface *hard_iface,
@@ -1194,6 +1195,10 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
if (!orig_neigh_node)
goto out;
+ /* Update nc_nodes of the originator */
+ batadv_nc_update_nc_node(bat_priv, orig_node, orig_neigh_node,
+ batadv_ogm_packet, is_single_hop_neigh);
+
orig_neigh_router = batadv_orig_node_get_router(orig_neigh_node);
/* drop packet if sender is not a direct neighbor and if we
diff --git a/debugfs.c b/debugfs.c
index 6f58ddd..02581b3 100644
--- a/debugfs.c
+++ b/debugfs.c
@@ -32,6 +32,7 @@
#include "icmp_socket.h"
#include "bridge_loop_avoidance.h"
#include "distributed-arp-table.h"
+#include "network-coding.h"
static struct dentry *batadv_debugfs;
@@ -311,6 +312,14 @@ struct batadv_debuginfo {
const struct file_operations fops;
};
+#ifdef CONFIG_BATMAN_ADV_NC
+static int batadv_nc_nodes_open(struct inode *inode, struct file *file)
+{
+ struct net_device *net_dev = (struct net_device *)inode->i_private;
+ return single_open(file, batadv_nc_nodes_seq_print_text, net_dev);
+}
+#endif
+
#define BATADV_DEBUGINFO(_name, _mode, _open) \
struct batadv_debuginfo batadv_debuginfo_##_name = { \
.attr = { .name = __stringify(_name), \
@@ -349,6 +358,9 @@ static BATADV_DEBUGINFO(dat_cache, S_IRUGO, batadv_dat_cache_open);
static BATADV_DEBUGINFO(transtable_local, S_IRUGO,
batadv_transtable_local_open);
static BATADV_DEBUGINFO(vis_data, S_IRUGO, batadv_vis_data_open);
+#ifdef CONFIG_BATMAN_ADV_NC
+static BATADV_DEBUGINFO(nc_nodes, S_IRUGO, batadv_nc_nodes_open);
+#endif
static struct batadv_debuginfo *batadv_mesh_debuginfos[] = {
&batadv_debuginfo_originators,
@@ -363,6 +375,9 @@ static struct batadv_debuginfo *batadv_mesh_debuginfos[] = {
#endif
&batadv_debuginfo_transtable_local,
&batadv_debuginfo_vis_data,
+#ifdef CONFIG_BATMAN_ADV_NC
+ &batadv_debuginfo_nc_nodes,
+#endif
NULL,
};
@@ -434,6 +449,9 @@ int batadv_debugfs_add_meshif(struct net_device *dev)
}
}
+ if (batadv_nc_init_debugfs(bat_priv) < 0)
+ goto rem_attr;
+
return 0;
rem_attr:
debugfs_remove_recursive(bat_priv->debug_dir);
diff --git a/main.h b/main.h
index ee09f0f..44945dc 100644
--- a/main.h
+++ b/main.h
@@ -103,6 +103,8 @@
#define BATADV_RESET_PROTECTION_MS 30000
#define BATADV_EXPECTED_SEQNO_RANGE 65536
+#define BATADV_NC_NODE_TIMEOUT 10000 /* Milliseconds */
+
enum batadv_mesh_state {
BATADV_MESH_INACTIVE,
BATADV_MESH_ACTIVE,
diff --git a/network-coding.c b/network-coding.c
index 4f0409d..e3d9f01 100644
--- a/network-coding.c
+++ b/network-coding.c
@@ -17,8 +17,12 @@
* 02110-1301, USA
*/
+#include <linux/debugfs.h>
+
#include "main.h"
#include "network-coding.h"
+#include "originator.h"
+#include "hard-interface.h"
static void batadv_nc_worker(struct work_struct *work);
@@ -51,6 +55,152 @@ int batadv_nc_init(struct batadv_priv *bat_priv)
void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
{
atomic_set(&bat_priv->network_coding, 1);
+ bat_priv->nc.min_tq = 200;
+}
+
+/**
+ * batadv_nc_init_orig - initialise the nc fields of an orig_node
+ * @orig_node: the orig_node which is going to be initialised
+ */
+void batadv_nc_init_orig(struct batadv_orig_node *orig_node)
+{
+ INIT_LIST_HEAD(&orig_node->in_coding_list);
+ INIT_LIST_HEAD(&orig_node->out_coding_list);
+ spin_lock_init(&orig_node->in_coding_list_lock);
+ spin_lock_init(&orig_node->out_coding_list_lock);
+}
+
+/**
+ * batadv_nc_node_free_rcu - rcu callback to free an nc node and remove
+ * its refcount on the orig_node
+ * @rcu: rcu pointer of the nc node
+ */
+static void batadv_nc_node_free_rcu(struct rcu_head *rcu)
+{
+ struct batadv_nc_node *nc_node;
+
+ nc_node = container_of(rcu, struct batadv_nc_node, rcu);
+ batadv_orig_node_free_ref(nc_node->orig_node);
+ kfree(nc_node);
+}
+
+/**
+ * batadv_nc_node_free_ref - decrements the nc node refcounter and possibly
+ * frees it
+ * @nc_node: the nc node to free
+ */
+static void batadv_nc_node_free_ref(struct batadv_nc_node *nc_node)
+{
+ if (atomic_dec_and_test(&nc_node->refcount))
+ call_rcu(&nc_node->rcu, batadv_nc_node_free_rcu);
+}
+
+/**
+ * batadv_nc_to_purge_nc_node - checks whether an nc node has to be purged
+ * @bat_priv: the bat priv with all the soft interface information
+ * @nc_node: the nc node to check
+ *
+ * Returns true if the entry has to be purged now, false otherwise
+ */
+static bool batadv_nc_to_purge_nc_node(struct batadv_priv *bat_priv,
+ struct batadv_nc_node *nc_node)
+{
+ if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
+ return true;
+
+ return batadv_has_timed_out(nc_node->last_seen, BATADV_NC_NODE_TIMEOUT);
+}
+
+/**
+ * batadv_nc_purge_orig_nc_nodes - go through list of nc nodes and purge stale
+ * entries
+ * @bat_priv: the bat priv with all the soft interface information
+ * @list: list of nc nodes
+ * @lock: nc node list lock
+ * @to_purge: function in charge to decide whether an entry has to be purged or
+ * not. This function takes the nc node as argument and has to return
+ * a boolean value: true is the entry has to be deleted, false
+ * otherwise
+ */
+static void
+batadv_nc_purge_orig_nc_nodes(struct batadv_priv *bat_priv,
+ struct list_head *list,
+ spinlock_t *lock,
+ bool (*to_purge)(struct batadv_priv *,
+ struct batadv_nc_node *))
+{
+ struct batadv_nc_node *nc_node, *nc_node_tmp;
+
+ /* For each nc_node in list */
+ spin_lock_bh(lock);
+ list_for_each_entry_safe(nc_node, nc_node_tmp, list, list) {
+ /* if an helper function has been passed as parameter,
+ * ask it if the entry has to be purged or not
+ */
+ if (to_purge && !to_purge(bat_priv, nc_node))
+ continue;
+
+ batadv_dbg(BATADV_DBG_NC, bat_priv,
+ "Removing nc_node %pM -> %pM\n",
+ nc_node->addr, nc_node->orig_node->orig);
+ list_del_rcu(&nc_node->list);
+ batadv_nc_node_free_ref(nc_node);
+ }
+ spin_unlock_bh(lock);
+}
+
+/**
+ * batadv_nc_purge_orig - purges all nc node data attached of the given
+ * originator
+ * @bat_priv: the bat priv with all the soft interface information
+ * @orig_node: orig_node with the nc node entries to be purged
+ * @to_purge: function in charge to decide whether an entry has to be purged or
+ * not. This function takes the nc node as argument and has to return
+ * a boolean value: true is the entry has to be deleted, false
+ * otherwise
+ */
+void batadv_nc_purge_orig(struct batadv_priv *bat_priv,
+ struct batadv_orig_node *orig_node,
+ bool (*to_purge)(struct batadv_priv *,
+ struct batadv_nc_node *))
+{
+ /* Check ingoing nc_node's of this orig_node */
+ batadv_nc_purge_orig_nc_nodes(bat_priv, &orig_node->in_coding_list,
+ &orig_node->in_coding_list_lock,
+ to_purge);
+
+ /* Check outgoing nc_node's of this orig_node */
+ batadv_nc_purge_orig_nc_nodes(bat_priv, &orig_node->out_coding_list,
+ &orig_node->out_coding_list_lock,
+ to_purge);
+}
+
+/**
+ * batadv_nc_purge_orig_hash - traverse entire originator hash to check if they
+ * have timed out nc nodes
+ * @bat_priv: the bat priv with all the soft interface information
+ */
+static void batadv_nc_purge_orig_hash(struct batadv_priv *bat_priv)
+{
+ struct batadv_hashtable *hash = bat_priv->orig_hash;
+ struct hlist_node *node;
+ struct hlist_head *head;
+ struct batadv_orig_node *orig_node;
+ uint32_t i;
+
+ if (!hash)
+ return;
+
+ /* For each orig_node */
+ for (i = 0; i < hash->size; i++) {
+ head = &hash->table[i];
+
+ rcu_read_lock();
+ hlist_for_each_entry_rcu(orig_node, node, head, hash_entry)
+ batadv_nc_purge_orig(bat_priv, orig_node,
+ batadv_nc_to_purge_nc_node);
+ rcu_read_unlock();
+ }
}
/**
@@ -67,11 +217,197 @@ static void batadv_nc_worker(struct work_struct *work)
priv_nc = container_of(delayed_work, struct batadv_priv_nc, work);
bat_priv = container_of(priv_nc, struct batadv_priv, nc);
+ batadv_nc_purge_orig_hash(bat_priv);
+
/* Schedule a new check */
batadv_nc_start_timer(bat_priv);
}
/**
+ * batadv_can_nc_with_orig - checks whether the given orig node is suitable for
+ * coding or not
+ * @bat_priv: the bat priv with all the soft interface information
+ * @orig_node: neighboring orig node which may be used as nc candidate
+ * @ogm_packet: incoming ogm packet also used for the checks
+ *
+ * Returns true if:
+ * 1) The OGM must have the most recent sequence number.
+ * 2) The TTL must be incremented by one and only one.
+ * 3) The OGM must be received from the first hop from orig_node.
+ * 4) The TQ value of the OGM must be above bat_priv->nc.min_tq.
+ */
+static bool batadv_can_nc_with_orig(struct batadv_priv *bat_priv,
+ struct batadv_orig_node *orig_node,
+ struct batadv_ogm_packet *ogm_packet)
+{
+ if (orig_node->last_real_seqno != ogm_packet->seqno)
+ return false;
+ if (orig_node->last_ttl != ogm_packet->header.ttl + 1)
+ return false;
+ if (!batadv_compare_eth(ogm_packet->orig, ogm_packet->prev_sender))
+ return false;
+ if (ogm_packet->tq < bat_priv->nc.min_tq)
+ return false;
+
+ return true;
+}
+
+/**
+ * batadv_nc_find_nc_node - search for an existing nc node and return it
+ * @orig_node: orig node originating the ogm packet
+ * @orig_neigh_node: neighboring orig node from which we received the ogm packet
+ * (can be equal to orig_node)
+ * @in_coding: traverse incoming or outgoing network coding list
+ *
+ * Returns the nc_node if found, NULL otherwise.
+ */
+static struct batadv_nc_node
+*batadv_nc_find_nc_node(struct batadv_orig_node *orig_node,
+ struct batadv_orig_node *orig_neigh_node,
+ bool in_coding)
+{
+ struct batadv_nc_node *nc_node, *nc_node_out = NULL;
+ struct list_head *list;
+
+ if (in_coding)
+ list = &orig_neigh_node->in_coding_list;
+ else
+ list = &orig_neigh_node->out_coding_list;
+
+ /* Traverse list of nc_nodes to orig_node */
+ rcu_read_lock();
+ list_for_each_entry_rcu(nc_node, list, list) {
+ if (!batadv_compare_eth(nc_node->addr, orig_node->orig))
+ continue;
+
+ if (!atomic_inc_not_zero(&nc_node->refcount))
+ continue;
+
+ /* Found a match */
+ nc_node_out = nc_node;
+ break;
+ }
+ rcu_read_unlock();
+
+ return nc_node_out;
+}
+
+/**
+ * batadv_nc_get_nc_node - retrieves an nc node or creates the entry if it was
+ * not found
+ * @bat_priv: the bat priv with all the soft interface information
+ * @orig_node: orig node originating the ogm packet
+ * @orig_neigh_node: neighboring orig node from which we received the ogm packet
+ * (can be equal to orig_node)
+ * @in_coding: traverse incoming or outgoing network coding list
+ *
+ * Returns the nc_node if found or created, NULL in case of an error.
+ */
+static struct batadv_nc_node
+*batadv_nc_get_nc_node(struct batadv_priv *bat_priv,
+ struct batadv_orig_node *orig_node,
+ struct batadv_orig_node *orig_neigh_node,
+ bool in_coding)
+{
+ struct batadv_nc_node *nc_node;
+ spinlock_t *lock; /* Used to lock list selected by "int in_coding" */
+ struct list_head *list;
+
+ /* Check if nc_node is already added */
+ nc_node = batadv_nc_find_nc_node(orig_node, orig_neigh_node, in_coding);
+
+ /* Node found */
+ if (nc_node)
+ return nc_node;
+
+ nc_node = kzalloc(sizeof(*nc_node), GFP_ATOMIC);
+ if (!nc_node)
+ return NULL;
+
+ if (!atomic_inc_not_zero(&orig_neigh_node->refcount))
+ goto free;
+
+ /* Initialize nc_node */
+ INIT_LIST_HEAD(&nc_node->list);
+ memcpy(nc_node->addr, orig_node->orig, ETH_ALEN);
+ nc_node->orig_node = orig_neigh_node;
+ atomic_set(&nc_node->refcount, 2);
+
+ /* Select ingoing or outgoing coding node */
+ if (in_coding) {
+ lock = &orig_neigh_node->in_coding_list_lock;
+ list = &orig_neigh_node->in_coding_list;
+ } else {
+ lock = &orig_neigh_node->out_coding_list_lock;
+ list = &orig_neigh_node->out_coding_list;
+ }
+
+ batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_node %pM -> %pM\n",
+ nc_node->addr, nc_node->orig_node->orig);
+
+ /* Add nc_node to orig_node */
+ spin_lock_bh(lock);
+ list_add_tail_rcu(&nc_node->list, list);
+ spin_unlock_bh(lock);
+
+ return nc_node;
+
+free:
+ kfree(nc_node);
+ return NULL;
+}
+
+/**
+ * batadv_nc_update_nc_node - updates stored incoming and outgoing nc node structs
+ * (best called on incoming OGMs)
+ * @bat_priv: the bat priv with all the soft interface information
+ * @orig_node: orig node originating the ogm packet
+ * @orig_neigh_node: neighboring orig node from which we received the ogm packet
+ * (can be equal to orig_node)
+ * @ogm_packet: incoming ogm packet
+ * @is_single_hop_neigh: orig_node is a single hop neighbor
+ */
+void batadv_nc_update_nc_node(struct batadv_priv *bat_priv,
+ struct batadv_orig_node *orig_node,
+ struct batadv_orig_node *orig_neigh_node,
+ struct batadv_ogm_packet *ogm_packet,
+ int is_single_hop_neigh)
+{
+ struct batadv_nc_node *in_nc_node = NULL, *out_nc_node = NULL;
+
+ /* Check if network coding is enabled */
+ if (!atomic_read(&bat_priv->network_coding))
+ goto out;
+
+ /* accept ogms from 'good' neighbors and single hop neighbors */
+ if (!batadv_can_nc_with_orig(bat_priv, orig_node, ogm_packet) &&
+ !is_single_hop_neigh)
+ goto out;
+
+ /* Add orig_node as in_nc_node on hop */
+ in_nc_node = batadv_nc_get_nc_node(bat_priv, orig_node,
+ orig_neigh_node, true);
+ if (!in_nc_node)
+ goto out;
+
+ in_nc_node->last_seen = jiffies;
+
+ /* Add hop as out_nc_node on orig_node */
+ out_nc_node = batadv_nc_get_nc_node(bat_priv, orig_neigh_node,
+ orig_node, false);
+ if (!out_nc_node)
+ goto out;
+
+ out_nc_node->last_seen = jiffies;
+
+out:
+ if (in_nc_node)
+ batadv_nc_node_free_ref(in_nc_node);
+ if (out_nc_node)
+ batadv_nc_node_free_ref(out_nc_node);
+}
+
+/**
* batadv_nc_free - clean up network coding memory
* @bat_priv: the bat priv with all the soft interface information
*/
@@ -79,3 +415,83 @@ void batadv_nc_free(struct batadv_priv *bat_priv)
{
cancel_delayed_work_sync(&bat_priv->nc.work);
}
+
+/**
+ * batadv_nc_nodes_seq_print_text - print the nc node information
+ * @seq: seq file to print on
+ * @offset: not used
+ */
+int batadv_nc_nodes_seq_print_text(struct seq_file *seq, void *offset)
+{
+ struct net_device *net_dev = (struct net_device *)seq->private;
+ struct batadv_priv *bat_priv = netdev_priv(net_dev);
+ struct batadv_hashtable *hash = bat_priv->orig_hash;
+ struct batadv_hard_iface *primary_if;
+ struct hlist_node *node;
+ struct hlist_head *head;
+ struct batadv_orig_node *orig_node;
+ struct batadv_nc_node *nc_node;
+ int i;
+
+ primary_if = batadv_seq_print_text_primary_if_get(seq);
+ if (!primary_if)
+ goto out;
+
+ /* Traverse list of originators */
+ for (i = 0; i < hash->size; i++) {
+ head = &hash->table[i];
+
+ /* For each orig_node in this bin */
+ rcu_read_lock();
+ hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) {
+ seq_printf(seq, "Node: %pM\n", orig_node->orig);
+
+ seq_printf(seq, " Ingoing: ");
+ /* For each in_nc_node to this orig_node */
+ list_for_each_entry_rcu(nc_node,
+ &orig_node->in_coding_list,
+ list)
+ seq_printf(seq, "%pM ",
+ nc_node->addr);
+ seq_printf(seq, "\n");
+
+ seq_printf(seq, " Outgoing: ");
+ /* For out_nc_node to this orig_node */
+ list_for_each_entry_rcu(nc_node,
+ &orig_node->out_coding_list,
+ list)
+ seq_printf(seq, "%pM ",
+ nc_node->addr);
+ seq_printf(seq, "\n\n");
+ }
+ rcu_read_unlock();
+ }
+
+out:
+ if (primary_if)
+ batadv_hardif_free_ref(primary_if);
+ return 0;
+}
+
+/**
+ * batadv_nc_init_debugfs - create nc folder and related files in debugfs
+ * @bat_priv: the bat priv with all the soft interface information
+ */
+int batadv_nc_init_debugfs(struct batadv_priv *bat_priv)
+{
+ struct dentry *nc_dir, *file;
+
+ nc_dir = debugfs_create_dir("nc", bat_priv->debug_dir);
+ if (!nc_dir)
+ goto out;
+
+ file = debugfs_create_u8("min_tq", S_IRUGO | S_IWUSR, nc_dir,
+ &bat_priv->nc.min_tq);
+ if (!file)
+ goto out;
+
+ return 0;
+
+out:
+ return -ENOMEM;
+}
diff --git a/network-coding.h b/network-coding.h
index b805899..56dadfd 100644
--- a/network-coding.h
+++ b/network-coding.h
@@ -24,7 +24,19 @@
int batadv_nc_init(struct batadv_priv *bat_priv);
void batadv_nc_free(struct batadv_priv *bat_priv);
+void batadv_nc_update_nc_node(struct batadv_priv *bat_priv,
+ struct batadv_orig_node *orig_node,
+ struct batadv_orig_node *orig_neigh_node,
+ struct batadv_ogm_packet *ogm_packet,
+ int is_single_hop_neigh);
+void batadv_nc_purge_orig(struct batadv_priv *bat_priv,
+ struct batadv_orig_node *orig_node,
+ bool (*to_purge)(struct batadv_priv *,
+ struct batadv_nc_node *));
void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv);
+void batadv_nc_init_orig(struct batadv_orig_node *orig_node);
+int batadv_nc_nodes_seq_print_text(struct seq_file *seq, void *offset);
+int batadv_nc_init_debugfs(struct batadv_priv *bat_priv);
#else /* ifdef CONFIG_BATMAN_ADV_NC */
@@ -38,11 +50,46 @@ static inline void batadv_nc_free(struct batadv_priv *bat_priv)
return;
}
+static inline void
+batadv_nc_update_nc_node(struct batadv_priv *bat_priv,
+ struct batadv_orig_node *orig_node,
+ struct batadv_orig_node *orig_neigh_node,
+ struct batadv_ogm_packet *ogm_packet,
+ int is_single_hop_neigh)
+{
+ return;
+}
+
+static inline void
+batadv_nc_purge_orig(struct batadv_priv *bat_priv,
+ struct batadv_orig_node *orig_node,
+ bool (*to_purge)(struct batadv_priv *,
+ struct batadv_nc_node *))
+{
+ return;
+}
+
static inline void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
{
return;
}
+static inline void batadv_nc_init_orig(struct batadv_orig_node *orig_node)
+{
+ return;
+}
+
+static inline int batadv_nc_nodes_seq_print_text(struct seq_file *seq,
+ void *offset)
+{
+ return 0;
+}
+
+static inline int batadv_nc_init_debugfs(struct batadv_priv *bat_priv)
+{
+ return 0;
+}
+
#endif /* ifdef CONFIG_BATMAN_ADV_NC */
#endif /* _NET_BATMAN_ADV_NETWORK_CODING_H */
diff --git a/originator.c b/originator.c
index 8c32cf1..5d56ce6 100644
--- a/originator.c
+++ b/originator.c
@@ -28,6 +28,7 @@
#include "unicast.h"
#include "soft-interface.h"
#include "bridge_loop_avoidance.h"
+#include "network-coding.h"
static void batadv_purge_orig(struct work_struct *work);
@@ -139,6 +140,9 @@ static void batadv_orig_node_free_rcu(struct rcu_head *rcu)
spin_unlock_bh(&orig_node->neigh_list_lock);
+ /* Free nc_nodes */
+ batadv_nc_purge_orig(orig_node->bat_priv, orig_node, NULL);
+
batadv_frag_list_free(&orig_node->frag_list);
batadv_tt_global_del_orig(orig_node->bat_priv, orig_node,
"originator timed out");
@@ -217,6 +221,8 @@ struct batadv_orig_node *batadv_get_orig_node(struct batadv_priv *bat_priv,
spin_lock_init(&orig_node->neigh_list_lock);
spin_lock_init(&orig_node->tt_buff_lock);
+ batadv_nc_init_orig(orig_node);
+
/* extra reference for return */
atomic_set(&orig_node->refcount, 2);
diff --git a/types.h b/types.h
index 5451fc8..beb84f4 100644
--- a/types.h
+++ b/types.h
@@ -122,6 +122,12 @@ struct batadv_orig_node {
spinlock_t tt_list_lock; /* protects tt_list */
atomic_t bond_candidates;
struct list_head bond_list;
+#ifdef CONFIG_BATMAN_ADV_NC
+ struct list_head in_coding_list;
+ struct list_head out_coding_list;
+ spinlock_t in_coding_list_lock; /* Protects in_coding_list */
+ spinlock_t out_coding_list_lock; /* Protects out_coding_list */
+#endif
};
struct batadv_gw_node {
@@ -268,9 +274,12 @@ struct batadv_priv_dat {
/**
* struct batadv_priv_nc - per mesh interface network coding private data
* @work: work queue callback item for cleanup
+ * @min_tq: only consider neighbors for encoding if neigh_tq > min_tq
*/
struct batadv_priv_nc {
struct delayed_work work;
+ struct dentry *debug_dir;
+ u8 min_tq;
};
/**
@@ -414,6 +423,24 @@ struct batadv_tt_roam_node {
struct list_head list;
};
+/**
+ * struct batadv_nc_node - network coding node
+ * @list: next and prev pointer for the list handling
+ * @addr: the node's mac address
+ * @refcount: number of contexts the object is used by
+ * @rcu: struct used for freeing in an RCU-safe manner
+ * @orig_node: pointer to corresponding orig node struct
+ * @last_seen: timestamp of last ogm received from this node
+ */
+struct batadv_nc_node {
+ struct list_head list;
+ uint8_t addr[ETH_ALEN];
+ atomic_t refcount;
+ struct rcu_head rcu;
+ struct batadv_orig_node *orig_node;
+ unsigned long last_seen;
+};
+
/* forw_packet - structure for forw_list maintaining packets to be
* send/forwarded
*/
--
1.8.0.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [B.A.T.M.A.N.] [PATCHv2 3/7] batman-adv: Detect coding nodes and remove these after timeout
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 3/7] batman-adv: Detect coding nodes and remove these after timeout Martin Hundebøll
@ 2012-12-18 22:54 ` Antonio Quartulli
0 siblings, 0 replies; 14+ messages in thread
From: Antonio Quartulli @ 2012-12-18 22:54 UTC (permalink / raw)
To: The list for a Better Approach To Mobile Ad-hoc Networking
Cc: Martin Hundebøll
[-- Attachment #1: Type: text/plain, Size: 2190 bytes --]
On Fri, Dec 14, 2012 at 07:32:48 +0100, Martin Hundebøll wrote:
[...]
> +/**
> + * batadv_nc_purge_orig_nc_nodes - go through list of nc nodes and purge stale
> + * entries
> + * @bat_priv: the bat priv with all the soft interface information
> + * @list: list of nc nodes
> + * @lock: nc node list lock
> + * @to_purge: function in charge to decide whether an entry has to be purged or
> + * not. This function takes the nc node as argument and has to return
> + * a boolean value: true is the entry has to be deleted, false
typo here? is -> if ?
> + * otherwise
> + */
> +static void
> +batadv_nc_purge_orig_nc_nodes(struct batadv_priv *bat_priv,
> + struct list_head *list,
> + spinlock_t *lock,
> + bool (*to_purge)(struct batadv_priv *,
> + struct batadv_nc_node *))
[...]
> /**
> + * batadv_can_nc_with_orig - checks whether the given orig node is suitable for
> + * coding or not
> + * @bat_priv: the bat priv with all the soft interface information
> + * @orig_node: neighboring orig node which may be used as nc candidate
> + * @ogm_packet: incoming ogm packet also used for the checks
> + *
> + * Returns true if:
> + * 1) The OGM must have the most recent sequence number.
> + * 2) The TTL must be incremented by one and only one.
mh..should be decremented here? or maybe I misunderstood the condition.
> + * 3) The OGM must be received from the first hop from orig_node.
> + * 4) The TQ value of the OGM must be above bat_priv->nc.min_tq.
> + */
> +static bool batadv_can_nc_with_orig(struct batadv_priv *bat_priv,
> + struct batadv_orig_node *orig_node,
> + struct batadv_ogm_packet *ogm_packet)
> +{
> + if (orig_node->last_real_seqno != ogm_packet->seqno)
> + return false;
> + if (orig_node->last_ttl != ogm_packet->header.ttl + 1)
> + return false;
> + if (!batadv_compare_eth(ogm_packet->orig, ogm_packet->prev_sender))
> + return false;
> + if (ogm_packet->tq < bat_priv->nc.min_tq)
> + return false;
> +
> + return true;
> +}
Cheers,
--
Antonio Quartulli
..each of us alone is worth nothing..
Ernesto "Che" Guevara
[-- Attachment #2: Type: application/pgp-signature, Size: 836 bytes --]
^ permalink raw reply [flat|nested] 14+ messages in thread
* [B.A.T.M.A.N.] [PATCHv2 4/7] batman-adv: Buffer unicast packets before forward.
2012-12-14 6:32 [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Martin Hundebøll
` (2 preceding siblings ...)
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 3/7] batman-adv: Detect coding nodes and remove these after timeout Martin Hundebøll
@ 2012-12-14 6:32 ` Martin Hundebøll
2012-12-18 22:54 ` Antonio Quartulli
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 5/7] batman-adv: Code and transmit packets if possible Martin Hundebøll
` (3 subsequent siblings)
7 siblings, 1 reply; 14+ messages in thread
From: Martin Hundebøll @ 2012-12-14 6:32 UTC (permalink / raw)
To: b.a.t.m.a.n; +Cc: Martin Hundebøll
Two be able to network code two packets, one packet must be buffered
until the next is available. This is done in a "coding buffer", which is
essentially a hash table with lists of packets. Each entry in the hash
table corresponds to a specific src-dst pair, which has a linked list of
packets that are buffered.
This patch adds skbs to the buffer just before forwarding them. The
buffer is traversed every 10 ms, where timed skbs are removed from the
buffer and transmitted. To allow experiments with the network coding
scheme, the timeout is tunable through a file in debugfs.
Signed-off-by: Martin Hundebøll <martin@hundeboll.net>
---
compat.c | 10 ++
compat.h | 1 +
main.h | 1 +
network-coding.c | 492 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
network-coding.h | 10 ++
routing.c | 18 +-
types.h | 49 ++++++
7 files changed, 574 insertions(+), 7 deletions(-)
diff --git a/compat.c b/compat.c
index c8006c6..5664d90 100644
--- a/compat.c
+++ b/compat.c
@@ -74,4 +74,14 @@ void batadv_free_rcu_dat_entry(struct rcu_head *rcu)
}
#endif
+#ifdef CONFIG_BATMAN_ADV_NC
+void batadv_free_rcu_nc_path(struct rcu_head *rcu)
+{
+ struct batadv_nc_path *nc_path;
+
+ nc_path = container_of(rcu, struct batadv_nc_path, rcu);
+ kfree(nc_path);
+}
+#endif
+
#endif /* < KERNEL_VERSION(3, 0, 0) */
diff --git a/compat.h b/compat.h
index 07ac401..3c7ad44 100644
--- a/compat.h
+++ b/compat.h
@@ -145,6 +145,7 @@ void batadv_free_rcu_neigh_node(struct rcu_head *rcu);
void batadv_free_rcu_tt_local_entry(struct rcu_head *rcu);
void batadv_free_rcu_backbone_gw(struct rcu_head *rcu);
void batadv_free_rcu_dat_entry(struct rcu_head *rcu);
+void batadv_free_rcu_nc_path(struct rcu_head *rcu);
static inline void skb_reset_mac_len(struct sk_buff *skb)
{
diff --git a/main.h b/main.h
index 44945dc..9fd81b8 100644
--- a/main.h
+++ b/main.h
@@ -104,6 +104,7 @@
#define BATADV_EXPECTED_SEQNO_RANGE 65536
#define BATADV_NC_NODE_TIMEOUT 10000 /* Milliseconds */
+#define BATADV_NC_PATH_TIMEOUT 10000 /* Milliseconds */
enum batadv_mesh_state {
BATADV_MESH_INACTIVE,
diff --git a/network-coding.c b/network-coding.c
index e3d9f01..2388176 100644
--- a/network-coding.c
+++ b/network-coding.c
@@ -20,10 +20,14 @@
#include <linux/debugfs.h>
#include "main.h"
+#include "hash.h"
#include "network-coding.h"
+#include "send.h"
#include "originator.h"
#include "hard-interface.h"
+static struct lock_class_key batadv_nc_coding_hash_lock_class_key;
+
static void batadv_nc_worker(struct work_struct *work);
/**
@@ -42,10 +46,25 @@ static void batadv_nc_start_timer(struct batadv_priv *bat_priv)
*/
int batadv_nc_init(struct batadv_priv *bat_priv)
{
+ bat_priv->nc.timestamp_fwd_flush = jiffies;
+
+ if (bat_priv->nc.coding_hash)
+ return 0;
+
+ bat_priv->nc.coding_hash = batadv_hash_new(128);
+ if (!bat_priv->nc.coding_hash)
+ goto err;
+
+ batadv_hash_set_lock_class(bat_priv->nc.coding_hash,
+ &batadv_nc_coding_hash_lock_class_key);
+
INIT_DELAYED_WORK(&bat_priv->nc.work, batadv_nc_worker);
batadv_nc_start_timer(bat_priv);
return 0;
+
+err:
+ return -ENOMEM;
}
/**
@@ -56,6 +75,7 @@ void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
{
atomic_set(&bat_priv->network_coding, 1);
bat_priv->nc.min_tq = 200;
+ bat_priv->nc.max_fwd_delay = 10;
}
/**
@@ -96,6 +116,30 @@ static void batadv_nc_node_free_ref(struct batadv_nc_node *nc_node)
}
/**
+ * batadv_nc_path_free_ref - decrements the nc path refcounter and possibly
+ * frees it
+ * @nc_path: the nc node to free
+ */
+static void batadv_nc_path_free_ref(struct batadv_nc_path *nc_path)
+{
+ if (atomic_dec_and_test(&nc_path->refcount))
+ kfree_rcu(nc_path, rcu);
+}
+
+/**
+ * batadv_nc_packet_free - frees nc packet
+ * @nc_packet: the nc packet to free
+ */
+static void batadv_nc_packet_free(struct batadv_nc_packet *nc_packet)
+{
+ if (nc_packet->skb)
+ kfree_skb(nc_packet->skb);
+
+ batadv_nc_path_free_ref(nc_packet->nc_path);
+ kfree(nc_packet);
+}
+
+/**
* batadv_nc_to_purge_nc_node - checks whether an nc node has to be purged
* @bat_priv: the bat priv with all the soft interface information
* @nc_node: the nc node to check
@@ -112,6 +156,26 @@ static bool batadv_nc_to_purge_nc_node(struct batadv_priv *bat_priv,
}
/**
+ * batadv_nc_to_purge_nc_path_coding - checks whether an nc path has timed out
+ * @bat_priv: the bat priv with all the soft interface information
+ * @nc_path: the nc path to check
+ *
+ * Returns true if the entry has to be purged now, false otherwise
+ */
+static bool batadv_nc_to_purge_nc_path_coding(struct batadv_priv *bat_priv,
+ struct batadv_nc_path *nc_path)
+{
+ if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
+ return true;
+
+ /* purge the path when no packets has been added for 10 times the
+ * max_fwd_delay time
+ */
+ return batadv_has_timed_out(nc_path->last_valid,
+ bat_priv->nc.max_fwd_delay * 10);
+}
+
+/**
* batadv_nc_purge_orig_nc_nodes - go through list of nc nodes and purge stale
* entries
* @bat_priv: the bat priv with all the soft interface information
@@ -204,6 +268,267 @@ static void batadv_nc_purge_orig_hash(struct batadv_priv *bat_priv)
}
/**
+ * batadv_nc_purge_paths - traverse all nc paths part of the hash and remove
+ * unused ones
+ * @bat_priv: the bat priv with all the soft interface information
+ * @hash: hash table containing the nc paths to check
+ * @to_purge: function in charge to decide whether an entry has to be purged or
+ * not. This function takes the nc node as argument and has to return
+ * a boolean value: true is the entry has to be deleted, false
+ * otherwise
+ */
+static void batadv_nc_purge_paths(struct batadv_priv *bat_priv,
+ struct batadv_hashtable *hash,
+ bool (*to_purge)(struct batadv_priv *,
+ struct batadv_nc_path *))
+{
+ struct hlist_head *head;
+ struct hlist_node *node, *node_tmp;
+ struct batadv_nc_path *nc_path;
+ spinlock_t *lock; /* Protects lists in hash */
+ uint32_t i;
+
+ for (i = 0; i < hash->size; i++) {
+ head = &hash->table[i];
+ lock = &hash->list_locks[i];
+
+ /* For each nc_path in this bin */
+ spin_lock_bh(lock);
+ hlist_for_each_entry_safe(nc_path, node, node_tmp,
+ head, hash_entry) {
+
+ /* if an helper function has been passed as parameter,
+ * ask it if the entry has to be purged or not
+ */
+ if (to_purge && !to_purge(bat_priv, nc_path))
+ continue;
+
+ /* purging an non-empty nc_path should never happen, but
+ * is observed under high CPU load. Delay the purging
+ * until next iteration to allow the packet_list to be
+ * emptied first.
+ */
+ if (!unlikely(list_empty(&nc_path->packet_list))) {
+ net_ratelimited_function(printk,
+ KERN_WARNING
+ "Skipping free of non-empty nc_path (%pM -> %pM)!\n",
+ nc_path->prev_hop,
+ nc_path->next_hop);
+ continue;
+ }
+
+ /* nc_path is unused, so remove it */
+ batadv_dbg(BATADV_DBG_NC, bat_priv,
+ "Remove nc_path %pM -> %pM\n",
+ nc_path->prev_hop, nc_path->next_hop);
+ hlist_del_rcu(node);
+ batadv_nc_path_free_ref(nc_path);
+ }
+ spin_unlock_bh(lock);
+ }
+}
+
+/**
+ * batadv_nc_hash_key_gen - computes the nc_path hash key
+ * @key: buffer to hold the final hash key
+ * @src: source ethernet mac address going into the hash key
+ * @dst: destination ethernet mac address going into the hash key
+ */
+static void batadv_nc_hash_key_gen(struct batadv_nc_path *key,
+ const char *src,
+ const char *dst)
+{
+ memcpy(key->prev_hop, src, sizeof(key->prev_hop));
+ memcpy(key->next_hop, dst, sizeof(key->next_hop));
+}
+
+/**
+ * batadv_nc_hash_choose - compute the hash value for an nc path
+ * @data: data to hash
+ * @size: size of the hash table
+ *
+ * Returns the selected index in the hash table for the given data.
+ */
+static uint32_t batadv_nc_hash_choose(const void *data, uint32_t size)
+{
+ const struct batadv_nc_path *nc_path = data;
+ uint32_t hash = 0;
+
+ hash = batadv_hash_bytes(hash, &nc_path->prev_hop,
+ sizeof(nc_path->prev_hop));
+ hash = batadv_hash_bytes(hash, &nc_path->next_hop,
+ sizeof(nc_path->next_hop));
+
+ hash += (hash << 3);
+ hash ^= (hash >> 11);
+ hash += (hash << 15);
+
+ return hash % size;
+}
+
+/**
+ * batadv_nc_hash_compare - comparing function used in the network coding hash
+ * tables
+ * @node: node in the local table
+ * @data2: second object to compare the node to
+ *
+ * Returns 1 if the two entry are the same, 0 otherwise
+ */
+static int batadv_nc_hash_compare(const struct hlist_node *node,
+ const void *data2)
+{
+ const struct batadv_nc_path *nc_path1, *nc_path2;
+
+ nc_path1 = container_of(node, struct batadv_nc_path, hash_entry);
+ nc_path2 = data2;
+
+ /* Return 1 if the two keys are identical */
+ if (memcmp(nc_path1->prev_hop, nc_path2->prev_hop,
+ sizeof(nc_path1->prev_hop)) != 0)
+ return 0;
+
+ if (memcmp(nc_path1->next_hop, nc_path2->next_hop,
+ sizeof(nc_path1->next_hop)) != 0)
+ return 0;
+
+ return 1;
+}
+
+/**
+ * batadv_nc_hash_find - search for an existing nc path and return it
+ * @hash: hash table containing the nc path
+ * @data: search key
+ *
+ * Returns the nc_path if found, NULL otherwise.
+ */
+static struct batadv_nc_path *
+batadv_nc_hash_find(struct batadv_hashtable *hash,
+ void *data)
+{
+ struct hlist_head *head;
+ struct hlist_node *node;
+ struct batadv_nc_path *nc_path, *nc_path_tmp = NULL;
+ int index;
+
+ if (!hash)
+ return NULL;
+
+ index = batadv_nc_hash_choose(data, hash->size);
+ head = &hash->table[index];
+
+ rcu_read_lock();
+ hlist_for_each_entry_rcu(nc_path, node, head, hash_entry) {
+ if (!batadv_nc_hash_compare(node, data))
+ continue;
+
+ if (!atomic_inc_not_zero(&nc_path->refcount))
+ continue;
+
+ nc_path_tmp = nc_path;
+ break;
+ }
+ rcu_read_unlock();
+
+ return nc_path_tmp;
+}
+
+/**
+ * batadv_nc_send_packet - send non-coded packet and free nc_packet struct
+ * @nc_packet: the nc packet to send
+ */
+static void batadv_nc_send_packet(struct batadv_nc_packet *nc_packet)
+{
+ batadv_send_skb_packet(nc_packet->skb,
+ nc_packet->neigh_node->if_incoming,
+ nc_packet->nc_path->next_hop);
+ nc_packet->skb = NULL;
+ batadv_nc_packet_free(nc_packet);
+}
+
+/**
+ * batadv_nc_fwd_flush - Checks the timestamp of the given nc packet.
+ * @bat_priv: the bat priv with all the soft interface information
+ * @nc_path: the nc path the packet belongs to
+ * @nc_packet: the nc packet to be checked
+ *
+ * Checks whether the given nc packet has hit its forward timeout. If so, the
+ * packet is no longer delayed, immediately sent and the entry deleted from the
+ * queue. Has to be called with the appropriate locks.
+ *
+ * Returns false as soon as the entry in the fifo queue has not been timed out
+ * yet and true otherwise.
+ */
+static bool batadv_nc_fwd_flush(struct batadv_priv *bat_priv,
+ struct batadv_nc_path *nc_path,
+ struct batadv_nc_packet *nc_packet)
+{
+ unsigned long timeout = bat_priv->nc.max_fwd_delay;
+
+ /* Packets are added to tail, so the remaining packets did not time
+ * out and we can stop processing the current queue
+ */
+ if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
+ !batadv_has_timed_out(nc_packet->timestamp, timeout))
+ return false;
+
+ /* Send packet */
+ batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
+ batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
+ nc_packet->skb->len + ETH_HLEN);
+ list_del(&nc_packet->list);
+ batadv_nc_send_packet(nc_packet);
+
+ return true;
+}
+
+/**
+ * batadv_nc_process_nc_paths - traverse given nc packet pool and free timed out
+ * nc packets
+ * @bat_priv: the bat priv with all the soft interface information
+ * @hash: to be processed hash table
+ * @process_fn: Function called to process given nc packet. Should return true
+ * to encourage this function to proceed with the next packet.
+ * Otherwise the rest of the current queue is skipped.
+ */
+static void
+batadv_nc_process_nc_paths(struct batadv_priv *bat_priv,
+ struct batadv_hashtable *hash,
+ bool (*process_fn)(struct batadv_priv *,
+ struct batadv_nc_path *,
+ struct batadv_nc_packet *))
+{
+ struct hlist_node *node;
+ struct hlist_head *head;
+ struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
+ struct batadv_nc_path *nc_path;
+ bool ret;
+ int i;
+
+ if (!hash)
+ return;
+
+ /* Loop hash table bins */
+ for (i = 0; i < hash->size; i++) {
+ head = &hash->table[i];
+
+ /* Loop coding paths */
+ rcu_read_lock();
+ hlist_for_each_entry_rcu(nc_path, node, head, hash_entry) {
+ /* Loop packets */
+ spin_lock_bh(&nc_path->packet_list_lock);
+ list_for_each_entry_safe(nc_packet, nc_packet_tmp,
+ &nc_path->packet_list, list) {
+ ret = process_fn(bat_priv, nc_path, nc_packet);
+ if (!ret)
+ break;
+ }
+ spin_unlock_bh(&nc_path->packet_list_lock);
+ }
+ rcu_read_unlock();
+ }
+}
+
+/**
* batadv_nc_worker - periodic task for house keeping related to network coding
* @work: kernel work struct
*/
@@ -212,12 +537,23 @@ static void batadv_nc_worker(struct work_struct *work)
struct delayed_work *delayed_work;
struct batadv_priv_nc *priv_nc;
struct batadv_priv *bat_priv;
+ unsigned long timeout;
delayed_work = container_of(work, struct delayed_work, work);
priv_nc = container_of(delayed_work, struct batadv_priv_nc, work);
bat_priv = container_of(priv_nc, struct batadv_priv, nc);
batadv_nc_purge_orig_hash(bat_priv);
+ batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash,
+ batadv_nc_to_purge_nc_path_coding);
+
+ timeout = bat_priv->nc.max_fwd_delay;
+
+ if (batadv_has_timed_out(bat_priv->nc.timestamp_fwd_flush, timeout)) {
+ batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.coding_hash,
+ batadv_nc_fwd_flush);
+ bat_priv->nc.timestamp_fwd_flush = jiffies;
+ }
/* Schedule a new check */
batadv_nc_start_timer(bat_priv);
@@ -408,12 +744,163 @@ out:
}
/**
+ * batadv_nc_get_path - get existing nc_path or allocate a new one
+ * @bat_priv: the bat priv with all the soft interface information
+ * @hash: hash table containing the nc path
+ * @src: ethernet source address - first half of the nc path search key
+ * @dst: ethernet destination address - second half of the nc path search key
+ *
+ * Returns pointer to nc_path if the path was found or created, returns NULL
+ * on error.
+ */
+static struct batadv_nc_path *batadv_nc_get_path(struct batadv_priv *bat_priv,
+ struct batadv_hashtable *hash,
+ uint8_t *src,
+ uint8_t *dst)
+{
+ int hash_added;
+ struct batadv_nc_path *nc_path, nc_path_key;
+
+ batadv_nc_hash_key_gen(&nc_path_key, src, dst);
+
+ /* Search for existing nc_path */
+ nc_path = batadv_nc_hash_find(hash, (void *)&nc_path_key);
+
+ if (nc_path) {
+ /* Set timestamp to delay removal of nc_path */
+ nc_path->last_valid = jiffies;
+ return nc_path;
+ }
+
+ /* No existing nc_path was found; create a new */
+ nc_path = kzalloc(sizeof(*nc_path), GFP_ATOMIC);
+
+ if (!nc_path)
+ return NULL;
+
+ /* Initialize nc_path */
+ INIT_LIST_HEAD(&nc_path->packet_list);
+ spin_lock_init(&nc_path->packet_list_lock);
+ atomic_set(&nc_path->refcount, 2);
+ nc_path->last_valid = jiffies;
+ memcpy(nc_path->next_hop, dst, ETH_ALEN);
+ memcpy(nc_path->prev_hop, src, ETH_ALEN);
+
+ batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_path %pM -> %pM\n",
+ nc_path->prev_hop,
+ nc_path->next_hop);
+
+ /* Add nc_path to hash table */
+ hash_added = batadv_hash_add(hash, batadv_nc_hash_compare,
+ batadv_nc_hash_choose, &nc_path_key,
+ &nc_path->hash_entry);
+
+ if (hash_added < 0) {
+ kfree(nc_path);
+ return NULL;
+ }
+
+ return nc_path;
+}
+
+/**
+ * batadv_nc_skb_add_to_path - buffer skb for later encoding / decoding
+ * @skb: skb to add to path
+ * @nc_path: path to add skb to
+ * @neigh_node: next hop to forward packet to
+ * @packet_id: checksum to identify packet
+ *
+ * Returns true if the packet was buffered or false in case of an error.
+ */
+static bool batadv_nc_skb_add_to_path(struct sk_buff *skb,
+ struct batadv_nc_path *nc_path,
+ struct batadv_neigh_node *neigh_node,
+ __be32 packet_id)
+{
+ struct batadv_nc_packet *nc_packet;
+
+ nc_packet = kzalloc(sizeof(*nc_packet), GFP_ATOMIC);
+ if (!nc_packet)
+ return false;
+
+ /* Initialize nc_packet */
+ nc_packet->timestamp = jiffies;
+ nc_packet->packet_id = packet_id;
+ nc_packet->skb = skb;
+ nc_packet->neigh_node = neigh_node;
+ nc_packet->nc_path = nc_path;
+
+ /* Add coding packet to list */
+ spin_lock_bh(&nc_path->packet_list_lock);
+ list_add_tail(&nc_packet->list, &nc_path->packet_list);
+ spin_unlock_bh(&nc_path->packet_list_lock);
+
+ return true;
+}
+
+/**
+ * batadv_nc_skb_forward - try to code a packet or add it to the coding packet
+ * buffer
+ * @skb: data skb to forward
+ * @neigh_node: next hop to forward packet to
+ * @ethhdr: pointer to the ethernet header inside the skb
+ *
+ * Returns true if the skb was consumed (encoded packet sent) or false otherwise
+ */
+bool batadv_nc_skb_forward(struct sk_buff *skb,
+ struct batadv_neigh_node *neigh_node,
+ struct ethhdr *ethhdr)
+{
+ const struct net_device *netdev = neigh_node->if_incoming->soft_iface;
+ struct batadv_priv *bat_priv = netdev_priv(netdev);
+ struct batadv_unicast_packet *packet;
+ struct batadv_nc_path *nc_path;
+ __be32 packet_id;
+ u8 *payload;
+
+ /* Check if network coding is enabled */
+ if (!atomic_read(&bat_priv->network_coding))
+ goto out;
+
+ /* We only handle unicast packets */
+ payload = skb_network_header(skb);
+ packet = (struct batadv_unicast_packet *)payload;
+ if (packet->header.packet_type != BATADV_UNICAST)
+ goto out;
+
+ /* Find or create a nc_path for this src-dst pair */
+ nc_path = batadv_nc_get_path(bat_priv,
+ bat_priv->nc.coding_hash,
+ ethhdr->h_source,
+ neigh_node->addr);
+
+ if (!nc_path)
+ goto out;
+
+ /* Add skb to nc_path */
+ packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
+ if (!batadv_nc_skb_add_to_path(skb, nc_path, neigh_node, packet_id))
+ goto free_nc_path;
+
+ /* Packet is consumed */
+ return true;
+
+free_nc_path:
+ batadv_nc_path_free_ref(nc_path);
+out:
+ /* Packet is not consumed */
+ return false;
+}
+
+/**
* batadv_nc_free - clean up network coding memory
* @bat_priv: the bat priv with all the soft interface information
*/
void batadv_nc_free(struct batadv_priv *bat_priv)
{
cancel_delayed_work_sync(&bat_priv->nc.work);
+ batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash, NULL);
+ batadv_hash_destroy(bat_priv->nc.coding_hash);
}
/**
@@ -490,6 +977,11 @@ int batadv_nc_init_debugfs(struct batadv_priv *bat_priv)
if (!file)
goto out;
+ file = debugfs_create_u32("max_fwd_delay", S_IRUGO | S_IWUSR, nc_dir,
+ &bat_priv->nc.max_fwd_delay);
+ if (!file)
+ goto out;
+
return 0;
out:
diff --git a/network-coding.h b/network-coding.h
index 56dadfd..970dbde 100644
--- a/network-coding.h
+++ b/network-coding.h
@@ -35,6 +35,9 @@ void batadv_nc_purge_orig(struct batadv_priv *bat_priv,
struct batadv_nc_node *));
void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv);
void batadv_nc_init_orig(struct batadv_orig_node *orig_node);
+bool batadv_nc_skb_forward(struct sk_buff *skb,
+ struct batadv_neigh_node *neigh_node,
+ struct ethhdr *ethhdr);
int batadv_nc_nodes_seq_print_text(struct seq_file *seq, void *offset);
int batadv_nc_init_debugfs(struct batadv_priv *bat_priv);
@@ -79,6 +82,13 @@ static inline void batadv_nc_init_orig(struct batadv_orig_node *orig_node)
return;
}
+static inline bool batadv_nc_skb_forward(struct sk_buff *skb,
+ struct batadv_neigh_node *neigh_node,
+ struct ethhdr *ethhdr)
+{
+ return false;
+}
+
static inline int batadv_nc_nodes_seq_print_text(struct seq_file *seq,
void *offset)
{
diff --git a/routing.c b/routing.c
index 0cea96b..f97cfe3 100644
--- a/routing.c
+++ b/routing.c
@@ -29,6 +29,7 @@
#include "unicast.h"
#include "bridge_loop_avoidance.h"
#include "distributed-arp-table.h"
+#include "network-coding.h"
static int batadv_route_unicast_packet(struct sk_buff *skb,
struct batadv_hard_iface *recv_if);
@@ -865,14 +866,17 @@ static int batadv_route_unicast_packet(struct sk_buff *skb,
/* decrement ttl */
unicast_packet->header.ttl--;
- /* Update stats counter */
- batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
- batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
- skb->len + ETH_HLEN);
-
- /* route it */
- if (batadv_send_skb_to_orig(skb, orig_node, recv_if))
+ /* network code packet if possible */
+ if (batadv_nc_skb_forward(skb, neigh_node, ethhdr)) {
ret = NET_RX_SUCCESS;
+ } else if (batadv_send_skb_to_orig(skb, orig_node, recv_if)) {
+ ret = NET_RX_SUCCESS;
+
+ /* Update stats counter */
+ batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
+ batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
+ skb->len + ETH_HLEN);
+ }
out:
if (neigh_node)
diff --git a/types.h b/types.h
index beb84f4..b34fde7 100644
--- a/types.h
+++ b/types.h
@@ -275,11 +275,19 @@ struct batadv_priv_dat {
* struct batadv_priv_nc - per mesh interface network coding private data
* @work: work queue callback item for cleanup
* @min_tq: only consider neighbors for encoding if neigh_tq > min_tq
+ * @max_fwd_delay: maximum packet forward delay to allow coding of packets
+ * @timestamp_fwd_flush: timestamp of last forward packet queue flush
+ * @coding_hash: Hash table used to buffer skbs while waiting for another
+ * incoming skb to code it with. Skbs are added to the buffer just before being
+ * forwarded in routing.c
*/
struct batadv_priv_nc {
struct delayed_work work;
struct dentry *debug_dir;
u8 min_tq;
+ u32 max_fwd_delay;
+ unsigned long timestamp_fwd_flush;
+ struct batadv_hashtable *coding_hash;
};
/**
@@ -441,6 +449,47 @@ struct batadv_nc_node {
unsigned long last_seen;
};
+/**
+ * struct batadv_nc_path - network coding path
+ * @hash_entry: next and prev pointer for the list handling
+ * @rcu: struct used for freeing in an RCU-safe manner
+ * @refcount: number of contexts the object is used by
+ * @packet_list: list of buffered packets for this path
+ * @packet_list_lock: access lock for packet list
+ * @next_hop: next hop (destination) of path
+ * @prev_hop: previous hop (source) of path
+ * @last_valid: timestamp for last validation of path
+ */
+struct batadv_nc_path {
+ struct hlist_node hash_entry;
+ struct rcu_head rcu;
+ atomic_t refcount;
+ struct list_head packet_list;
+ spinlock_t packet_list_lock; /* Protects packet_list */
+ uint8_t next_hop[ETH_ALEN];
+ uint8_t prev_hop[ETH_ALEN];
+ unsigned long last_valid;
+};
+
+/**
+ * struct batadv_nc_packet - network coding packet used when coding and
+ * decoding packets
+ * @list: next and prev pointer for the list handling
+ * @packet_id: crc32 checksum of skb data
+ * @timestamp: field containing the info when the packet was added to path
+ * @neigh_node: pointer to original next hop neighbor of skb
+ * @skb: skb which can be encoded or used for decoding
+ * @nc_path: pointer to path this nc packet is attached to
+ */
+struct batadv_nc_packet {
+ struct list_head list;
+ __be32 packet_id;
+ unsigned long timestamp;
+ struct batadv_neigh_node *neigh_node;
+ struct sk_buff *skb;
+ struct batadv_nc_path *nc_path;
+};
+
/* forw_packet - structure for forw_list maintaining packets to be
* send/forwarded
*/
--
1.8.0.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [B.A.T.M.A.N.] [PATCHv2 4/7] batman-adv: Buffer unicast packets before forward.
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 4/7] batman-adv: Buffer unicast packets before forward Martin Hundebøll
@ 2012-12-18 22:54 ` Antonio Quartulli
0 siblings, 0 replies; 14+ messages in thread
From: Antonio Quartulli @ 2012-12-18 22:54 UTC (permalink / raw)
To: The list for a Better Approach To Mobile Ad-hoc Networking
Cc: Martin Hundebøll
[-- Attachment #1: Type: text/plain, Size: 24078 bytes --]
On Fri, Dec 14, 2012 at 07:32:49 +0100, Martin Hundebøll wrote:
>
> #define BATADV_NC_NODE_TIMEOUT 10000 /* Milliseconds */
> +#define BATADV_NC_PATH_TIMEOUT 10000 /* Milliseconds */
>
Whit define doesn't seem to be used anywhere in this patch..
> enum batadv_mesh_state {
> BATADV_MESH_INACTIVE,
> diff --git a/network-coding.c b/network-coding.c
> index e3d9f01..2388176 100644
> --- a/network-coding.c
> +++ b/network-coding.c
> @@ -20,10 +20,14 @@
> #include <linux/debugfs.h>
>
> #include "main.h"
> +#include "hash.h"
> #include "network-coding.h"
> +#include "send.h"
> #include "originator.h"
> #include "hard-interface.h"
>
> +static struct lock_class_key batadv_nc_coding_hash_lock_class_key;
> +
> static void batadv_nc_worker(struct work_struct *work);
>
> /**
> @@ -42,10 +46,25 @@ static void batadv_nc_start_timer(struct batadv_priv *bat_priv)
> */
> int batadv_nc_init(struct batadv_priv *bat_priv)
> {
> + bat_priv->nc.timestamp_fwd_flush = jiffies;
> +
> + if (bat_priv->nc.coding_hash)
> + return 0;
> +
> + bat_priv->nc.coding_hash = batadv_hash_new(128);
> + if (!bat_priv->nc.coding_hash)
> + goto err;
> +
> + batadv_hash_set_lock_class(bat_priv->nc.coding_hash,
> + &batadv_nc_coding_hash_lock_class_key);
> +
> INIT_DELAYED_WORK(&bat_priv->nc.work, batadv_nc_worker);
> batadv_nc_start_timer(bat_priv);
>
> return 0;
> +
> +err:
> + return -ENOMEM;
> }
>
> /**
> @@ -56,6 +75,7 @@ void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
> {
> atomic_set(&bat_priv->network_coding, 1);
> bat_priv->nc.min_tq = 200;
> + bat_priv->nc.max_fwd_delay = 10;
> }
>
> /**
> @@ -96,6 +116,30 @@ static void batadv_nc_node_free_ref(struct batadv_nc_node *nc_node)
> }
>
> /**
> + * batadv_nc_path_free_ref - decrements the nc path refcounter and possibly
> + * frees it
> + * @nc_path: the nc node to free
> + */
> +static void batadv_nc_path_free_ref(struct batadv_nc_path *nc_path)
> +{
> + if (atomic_dec_and_test(&nc_path->refcount))
> + kfree_rcu(nc_path, rcu);
> +}
> +
> +/**
> + * batadv_nc_packet_free - frees nc packet
> + * @nc_packet: the nc packet to free
> + */
> +static void batadv_nc_packet_free(struct batadv_nc_packet *nc_packet)
> +{
> + if (nc_packet->skb)
> + kfree_skb(nc_packet->skb);
> +
> + batadv_nc_path_free_ref(nc_packet->nc_path);
> + kfree(nc_packet);
> +}
> +
> +/**
> * batadv_nc_to_purge_nc_node - checks whether an nc node has to be purged
> * @bat_priv: the bat priv with all the soft interface information
> * @nc_node: the nc node to check
> @@ -112,6 +156,26 @@ static bool batadv_nc_to_purge_nc_node(struct batadv_priv *bat_priv,
> }
>
> /**
> + * batadv_nc_to_purge_nc_path_coding - checks whether an nc path has timed out
> + * @bat_priv: the bat priv with all the soft interface information
> + * @nc_path: the nc path to check
> + *
> + * Returns true if the entry has to be purged now, false otherwise
> + */
> +static bool batadv_nc_to_purge_nc_path_coding(struct batadv_priv *bat_priv,
> + struct batadv_nc_path *nc_path)
> +{
> + if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
> + return true;
> +
> + /* purge the path when no packets has been added for 10 times the
> + * max_fwd_delay time
> + */
> + return batadv_has_timed_out(nc_path->last_valid,
> + bat_priv->nc.max_fwd_delay * 10);
> +}
> +
> +/**
> * batadv_nc_purge_orig_nc_nodes - go through list of nc nodes and purge stale
> * entries
> * @bat_priv: the bat priv with all the soft interface information
> @@ -204,6 +268,267 @@ static void batadv_nc_purge_orig_hash(struct batadv_priv *bat_priv)
> }
>
> /**
> + * batadv_nc_purge_paths - traverse all nc paths part of the hash and remove
> + * unused ones
> + * @bat_priv: the bat priv with all the soft interface information
> + * @hash: hash table containing the nc paths to check
> + * @to_purge: function in charge to decide whether an entry has to be purged or
> + * not. This function takes the nc node as argument and has to return
> + * a boolean value: true is the entry has to be deleted, false
> + * otherwise
> + */
> +static void batadv_nc_purge_paths(struct batadv_priv *bat_priv,
> + struct batadv_hashtable *hash,
> + bool (*to_purge)(struct batadv_priv *,
> + struct batadv_nc_path *))
> +{
> + struct hlist_head *head;
> + struct hlist_node *node, *node_tmp;
> + struct batadv_nc_path *nc_path;
> + spinlock_t *lock; /* Protects lists in hash */
> + uint32_t i;
> +
> + for (i = 0; i < hash->size; i++) {
> + head = &hash->table[i];
> + lock = &hash->list_locks[i];
> +
> + /* For each nc_path in this bin */
> + spin_lock_bh(lock);
> + hlist_for_each_entry_safe(nc_path, node, node_tmp,
> + head, hash_entry) {
> +
> + /* if an helper function has been passed as parameter,
> + * ask it if the entry has to be purged or not
> + */
> + if (to_purge && !to_purge(bat_priv, nc_path))
> + continue;
> +
> + /* purging an non-empty nc_path should never happen, but
> + * is observed under high CPU load. Delay the purging
> + * until next iteration to allow the packet_list to be
> + * emptied first.
> + */
> + if (!unlikely(list_empty(&nc_path->packet_list))) {
> + net_ratelimited_function(printk,
> + KERN_WARNING
> + "Skipping free of non-empty nc_path (%pM -> %pM)!\n",
> + nc_path->prev_hop,
> + nc_path->next_hop);
> + continue;
> + }
> +
> + /* nc_path is unused, so remove it */
> + batadv_dbg(BATADV_DBG_NC, bat_priv,
> + "Remove nc_path %pM -> %pM\n",
> + nc_path->prev_hop, nc_path->next_hop);
> + hlist_del_rcu(node);
> + batadv_nc_path_free_ref(nc_path);
> + }
> + spin_unlock_bh(lock);
> + }
> +}
> +
> +/**
> + * batadv_nc_hash_key_gen - computes the nc_path hash key
> + * @key: buffer to hold the final hash key
> + * @src: source ethernet mac address going into the hash key
> + * @dst: destination ethernet mac address going into the hash key
> + */
> +static void batadv_nc_hash_key_gen(struct batadv_nc_path *key,
> + const char *src,
> + const char *dst)
> +{
> + memcpy(key->prev_hop, src, sizeof(key->prev_hop));
> + memcpy(key->next_hop, dst, sizeof(key->next_hop));
> +}
> +
> +/**
> + * batadv_nc_hash_choose - compute the hash value for an nc path
> + * @data: data to hash
> + * @size: size of the hash table
> + *
> + * Returns the selected index in the hash table for the given data.
> + */
> +static uint32_t batadv_nc_hash_choose(const void *data, uint32_t size)
> +{
> + const struct batadv_nc_path *nc_path = data;
> + uint32_t hash = 0;
> +
> + hash = batadv_hash_bytes(hash, &nc_path->prev_hop,
> + sizeof(nc_path->prev_hop));
> + hash = batadv_hash_bytes(hash, &nc_path->next_hop,
> + sizeof(nc_path->next_hop));
> +
> + hash += (hash << 3);
> + hash ^= (hash >> 11);
> + hash += (hash << 15);
> +
> + return hash % size;
> +}
> +
> +/**
> + * batadv_nc_hash_compare - comparing function used in the network coding hash
> + * tables
> + * @node: node in the local table
> + * @data2: second object to compare the node to
> + *
> + * Returns 1 if the two entry are the same, 0 otherwise
> + */
> +static int batadv_nc_hash_compare(const struct hlist_node *node,
> + const void *data2)
> +{
> + const struct batadv_nc_path *nc_path1, *nc_path2;
> +
> + nc_path1 = container_of(node, struct batadv_nc_path, hash_entry);
> + nc_path2 = data2;
> +
> + /* Return 1 if the two keys are identical */
> + if (memcmp(nc_path1->prev_hop, nc_path2->prev_hop,
> + sizeof(nc_path1->prev_hop)) != 0)
> + return 0;
> +
> + if (memcmp(nc_path1->next_hop, nc_path2->next_hop,
> + sizeof(nc_path1->next_hop)) != 0)
> + return 0;
> +
> + return 1;
> +}
> +
> +/**
> + * batadv_nc_hash_find - search for an existing nc path and return it
> + * @hash: hash table containing the nc path
> + * @data: search key
> + *
> + * Returns the nc_path if found, NULL otherwise.
> + */
> +static struct batadv_nc_path *
> +batadv_nc_hash_find(struct batadv_hashtable *hash,
> + void *data)
> +{
> + struct hlist_head *head;
> + struct hlist_node *node;
> + struct batadv_nc_path *nc_path, *nc_path_tmp = NULL;
> + int index;
> +
> + if (!hash)
> + return NULL;
> +
> + index = batadv_nc_hash_choose(data, hash->size);
> + head = &hash->table[index];
> +
> + rcu_read_lock();
> + hlist_for_each_entry_rcu(nc_path, node, head, hash_entry) {
> + if (!batadv_nc_hash_compare(node, data))
> + continue;
> +
> + if (!atomic_inc_not_zero(&nc_path->refcount))
> + continue;
> +
> + nc_path_tmp = nc_path;
> + break;
> + }
> + rcu_read_unlock();
> +
> + return nc_path_tmp;
> +}
> +
> +/**
> + * batadv_nc_send_packet - send non-coded packet and free nc_packet struct
> + * @nc_packet: the nc packet to send
> + */
> +static void batadv_nc_send_packet(struct batadv_nc_packet *nc_packet)
> +{
> + batadv_send_skb_packet(nc_packet->skb,
> + nc_packet->neigh_node->if_incoming,
> + nc_packet->nc_path->next_hop);
> + nc_packet->skb = NULL;
> + batadv_nc_packet_free(nc_packet);
> +}
> +
> +/**
> + * batadv_nc_fwd_flush - Checks the timestamp of the given nc packet.
> + * @bat_priv: the bat priv with all the soft interface information
> + * @nc_path: the nc path the packet belongs to
> + * @nc_packet: the nc packet to be checked
> + *
> + * Checks whether the given nc packet has hit its forward timeout. If so, the
> + * packet is no longer delayed, immediately sent and the entry deleted from the
> + * queue. Has to be called with the appropriate locks.
> + *
> + * Returns false as soon as the entry in the fifo queue has not been timed out
> + * yet and true otherwise.
> + */
> +static bool batadv_nc_fwd_flush(struct batadv_priv *bat_priv,
> + struct batadv_nc_path *nc_path,
> + struct batadv_nc_packet *nc_packet)
> +{
> + unsigned long timeout = bat_priv->nc.max_fwd_delay;
> +
> + /* Packets are added to tail, so the remaining packets did not time
> + * out and we can stop processing the current queue
> + */
> + if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
> + !batadv_has_timed_out(nc_packet->timestamp, timeout))
> + return false;
> +
> + /* Send packet */
> + batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
> + batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
> + nc_packet->skb->len + ETH_HLEN);
> + list_del(&nc_packet->list);
> + batadv_nc_send_packet(nc_packet);
> +
> + return true;
> +}
> +
> +/**
> + * batadv_nc_process_nc_paths - traverse given nc packet pool and free timed out
> + * nc packets
> + * @bat_priv: the bat priv with all the soft interface information
> + * @hash: to be processed hash table
> + * @process_fn: Function called to process given nc packet. Should return true
> + * to encourage this function to proceed with the next packet.
> + * Otherwise the rest of the current queue is skipped.
> + */
> +static void
> +batadv_nc_process_nc_paths(struct batadv_priv *bat_priv,
> + struct batadv_hashtable *hash,
> + bool (*process_fn)(struct batadv_priv *,
> + struct batadv_nc_path *,
> + struct batadv_nc_packet *))
> +{
> + struct hlist_node *node;
> + struct hlist_head *head;
> + struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
> + struct batadv_nc_path *nc_path;
> + bool ret;
> + int i;
> +
> + if (!hash)
> + return;
> +
> + /* Loop hash table bins */
> + for (i = 0; i < hash->size; i++) {
> + head = &hash->table[i];
> +
> + /* Loop coding paths */
> + rcu_read_lock();
> + hlist_for_each_entry_rcu(nc_path, node, head, hash_entry) {
> + /* Loop packets */
> + spin_lock_bh(&nc_path->packet_list_lock);
> + list_for_each_entry_safe(nc_packet, nc_packet_tmp,
> + &nc_path->packet_list, list) {
> + ret = process_fn(bat_priv, nc_path, nc_packet);
> + if (!ret)
> + break;
> + }
> + spin_unlock_bh(&nc_path->packet_list_lock);
> + }
> + rcu_read_unlock();
> + }
> +}
> +
> +/**
> * batadv_nc_worker - periodic task for house keeping related to network coding
> * @work: kernel work struct
> */
> @@ -212,12 +537,23 @@ static void batadv_nc_worker(struct work_struct *work)
> struct delayed_work *delayed_work;
> struct batadv_priv_nc *priv_nc;
> struct batadv_priv *bat_priv;
> + unsigned long timeout;
>
> delayed_work = container_of(work, struct delayed_work, work);
> priv_nc = container_of(delayed_work, struct batadv_priv_nc, work);
> bat_priv = container_of(priv_nc, struct batadv_priv, nc);
>
> batadv_nc_purge_orig_hash(bat_priv);
> + batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash,
> + batadv_nc_to_purge_nc_path_coding);
> +
> + timeout = bat_priv->nc.max_fwd_delay;
> +
> + if (batadv_has_timed_out(bat_priv->nc.timestamp_fwd_flush, timeout)) {
> + batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.coding_hash,
> + batadv_nc_fwd_flush);
> + bat_priv->nc.timestamp_fwd_flush = jiffies;
> + }
>
> /* Schedule a new check */
> batadv_nc_start_timer(bat_priv);
> @@ -408,12 +744,163 @@ out:
> }
>
> /**
> + * batadv_nc_get_path - get existing nc_path or allocate a new one
> + * @bat_priv: the bat priv with all the soft interface information
> + * @hash: hash table containing the nc path
> + * @src: ethernet source address - first half of the nc path search key
> + * @dst: ethernet destination address - second half of the nc path search key
> + *
> + * Returns pointer to nc_path if the path was found or created, returns NULL
> + * on error.
> + */
> +static struct batadv_nc_path *batadv_nc_get_path(struct batadv_priv *bat_priv,
> + struct batadv_hashtable *hash,
> + uint8_t *src,
> + uint8_t *dst)
> +{
> + int hash_added;
> + struct batadv_nc_path *nc_path, nc_path_key;
> +
> + batadv_nc_hash_key_gen(&nc_path_key, src, dst);
> +
> + /* Search for existing nc_path */
> + nc_path = batadv_nc_hash_find(hash, (void *)&nc_path_key);
> +
> + if (nc_path) {
> + /* Set timestamp to delay removal of nc_path */
> + nc_path->last_valid = jiffies;
> + return nc_path;
> + }
> +
> + /* No existing nc_path was found; create a new */
> + nc_path = kzalloc(sizeof(*nc_path), GFP_ATOMIC);
> +
> + if (!nc_path)
> + return NULL;
> +
> + /* Initialize nc_path */
> + INIT_LIST_HEAD(&nc_path->packet_list);
> + spin_lock_init(&nc_path->packet_list_lock);
> + atomic_set(&nc_path->refcount, 2);
> + nc_path->last_valid = jiffies;
> + memcpy(nc_path->next_hop, dst, ETH_ALEN);
> + memcpy(nc_path->prev_hop, src, ETH_ALEN);
> +
> + batadv_dbg(BATADV_DBG_NC, bat_priv, "Adding nc_path %pM -> %pM\n",
> + nc_path->prev_hop,
> + nc_path->next_hop);
> +
> + /* Add nc_path to hash table */
> + hash_added = batadv_hash_add(hash, batadv_nc_hash_compare,
> + batadv_nc_hash_choose, &nc_path_key,
> + &nc_path->hash_entry);
> +
> + if (hash_added < 0) {
> + kfree(nc_path);
> + return NULL;
> + }
> +
> + return nc_path;
> +}
> +
> +/**
> + * batadv_nc_skb_add_to_path - buffer skb for later encoding / decoding
> + * @skb: skb to add to path
> + * @nc_path: path to add skb to
> + * @neigh_node: next hop to forward packet to
> + * @packet_id: checksum to identify packet
> + *
> + * Returns true if the packet was buffered or false in case of an error.
> + */
> +static bool batadv_nc_skb_add_to_path(struct sk_buff *skb,
> + struct batadv_nc_path *nc_path,
> + struct batadv_neigh_node *neigh_node,
> + __be32 packet_id)
> +{
> + struct batadv_nc_packet *nc_packet;
> +
> + nc_packet = kzalloc(sizeof(*nc_packet), GFP_ATOMIC);
> + if (!nc_packet)
> + return false;
> +
> + /* Initialize nc_packet */
> + nc_packet->timestamp = jiffies;
> + nc_packet->packet_id = packet_id;
> + nc_packet->skb = skb;
> + nc_packet->neigh_node = neigh_node;
> + nc_packet->nc_path = nc_path;
> +
> + /* Add coding packet to list */
> + spin_lock_bh(&nc_path->packet_list_lock);
> + list_add_tail(&nc_packet->list, &nc_path->packet_list);
> + spin_unlock_bh(&nc_path->packet_list_lock);
> +
> + return true;
> +}
> +
> +/**
> + * batadv_nc_skb_forward - try to code a packet or add it to the coding packet
> + * buffer
> + * @skb: data skb to forward
> + * @neigh_node: next hop to forward packet to
> + * @ethhdr: pointer to the ethernet header inside the skb
> + *
> + * Returns true if the skb was consumed (encoded packet sent) or false otherwise
> + */
> +bool batadv_nc_skb_forward(struct sk_buff *skb,
> + struct batadv_neigh_node *neigh_node,
> + struct ethhdr *ethhdr)
> +{
> + const struct net_device *netdev = neigh_node->if_incoming->soft_iface;
> + struct batadv_priv *bat_priv = netdev_priv(netdev);
> + struct batadv_unicast_packet *packet;
> + struct batadv_nc_path *nc_path;
> + __be32 packet_id;
> + u8 *payload;
> +
> + /* Check if network coding is enabled */
> + if (!atomic_read(&bat_priv->network_coding))
> + goto out;
> +
> + /* We only handle unicast packets */
> + payload = skb_network_header(skb);
> + packet = (struct batadv_unicast_packet *)payload;
> + if (packet->header.packet_type != BATADV_UNICAST)
> + goto out;
> +
> + /* Find or create a nc_path for this src-dst pair */
> + nc_path = batadv_nc_get_path(bat_priv,
> + bat_priv->nc.coding_hash,
> + ethhdr->h_source,
> + neigh_node->addr);
> +
> + if (!nc_path)
> + goto out;
> +
> + /* Add skb to nc_path */
> + packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
> + if (!batadv_nc_skb_add_to_path(skb, nc_path, neigh_node, packet_id))
> + goto free_nc_path;
> +
> + /* Packet is consumed */
> + return true;
> +
> +free_nc_path:
> + batadv_nc_path_free_ref(nc_path);
> +out:
> + /* Packet is not consumed */
> + return false;
> +}
> +
> +/**
> * batadv_nc_free - clean up network coding memory
> * @bat_priv: the bat priv with all the soft interface information
> */
> void batadv_nc_free(struct batadv_priv *bat_priv)
> {
> cancel_delayed_work_sync(&bat_priv->nc.work);
> + batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash, NULL);
> + batadv_hash_destroy(bat_priv->nc.coding_hash);
> }
>
> /**
> @@ -490,6 +977,11 @@ int batadv_nc_init_debugfs(struct batadv_priv *bat_priv)
> if (!file)
> goto out;
>
> + file = debugfs_create_u32("max_fwd_delay", S_IRUGO | S_IWUSR, nc_dir,
> + &bat_priv->nc.max_fwd_delay);
> + if (!file)
> + goto out;
> +
> return 0;
>
> out:
> diff --git a/network-coding.h b/network-coding.h
> index 56dadfd..970dbde 100644
> --- a/network-coding.h
> +++ b/network-coding.h
> @@ -35,6 +35,9 @@ void batadv_nc_purge_orig(struct batadv_priv *bat_priv,
> struct batadv_nc_node *));
> void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv);
> void batadv_nc_init_orig(struct batadv_orig_node *orig_node);
> +bool batadv_nc_skb_forward(struct sk_buff *skb,
> + struct batadv_neigh_node *neigh_node,
> + struct ethhdr *ethhdr);
> int batadv_nc_nodes_seq_print_text(struct seq_file *seq, void *offset);
> int batadv_nc_init_debugfs(struct batadv_priv *bat_priv);
>
> @@ -79,6 +82,13 @@ static inline void batadv_nc_init_orig(struct batadv_orig_node *orig_node)
> return;
> }
>
> +static inline bool batadv_nc_skb_forward(struct sk_buff *skb,
> + struct batadv_neigh_node *neigh_node,
> + struct ethhdr *ethhdr)
> +{
> + return false;
> +}
> +
> static inline int batadv_nc_nodes_seq_print_text(struct seq_file *seq,
> void *offset)
> {
> diff --git a/routing.c b/routing.c
> index 0cea96b..f97cfe3 100644
> --- a/routing.c
> +++ b/routing.c
> @@ -29,6 +29,7 @@
> #include "unicast.h"
> #include "bridge_loop_avoidance.h"
> #include "distributed-arp-table.h"
> +#include "network-coding.h"
>
> static int batadv_route_unicast_packet(struct sk_buff *skb,
> struct batadv_hard_iface *recv_if);
> @@ -865,14 +866,17 @@ static int batadv_route_unicast_packet(struct sk_buff *skb,
> /* decrement ttl */
> unicast_packet->header.ttl--;
>
> - /* Update stats counter */
> - batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
> - batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
> - skb->len + ETH_HLEN);
> -
> - /* route it */
> - if (batadv_send_skb_to_orig(skb, orig_node, recv_if))
> + /* network code packet if possible */
> + if (batadv_nc_skb_forward(skb, neigh_node, ethhdr)) {
> ret = NET_RX_SUCCESS;
> + } else if (batadv_send_skb_to_orig(skb, orig_node, recv_if)) {
> + ret = NET_RX_SUCCESS;
> +
> + /* Update stats counter */
> + batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
> + batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
> + skb->len + ETH_HLEN);
> + }
>
> out:
> if (neigh_node)
> diff --git a/types.h b/types.h
> index beb84f4..b34fde7 100644
> --- a/types.h
> +++ b/types.h
> @@ -275,11 +275,19 @@ struct batadv_priv_dat {
> * struct batadv_priv_nc - per mesh interface network coding private data
> * @work: work queue callback item for cleanup
> * @min_tq: only consider neighbors for encoding if neigh_tq > min_tq
> + * @max_fwd_delay: maximum packet forward delay to allow coding of packets
> + * @timestamp_fwd_flush: timestamp of last forward packet queue flush
> + * @coding_hash: Hash table used to buffer skbs while waiting for another
> + * incoming skb to code it with. Skbs are added to the buffer just before being
> + * forwarded in routing.c
> */
> struct batadv_priv_nc {
> struct delayed_work work;
> struct dentry *debug_dir;
> u8 min_tq;
> + u32 max_fwd_delay;
> + unsigned long timestamp_fwd_flush;
> + struct batadv_hashtable *coding_hash;
> };
>
> /**
> @@ -441,6 +449,47 @@ struct batadv_nc_node {
> unsigned long last_seen;
> };
>
> +/**
> + * struct batadv_nc_path - network coding path
> + * @hash_entry: next and prev pointer for the list handling
> + * @rcu: struct used for freeing in an RCU-safe manner
> + * @refcount: number of contexts the object is used by
> + * @packet_list: list of buffered packets for this path
> + * @packet_list_lock: access lock for packet list
> + * @next_hop: next hop (destination) of path
> + * @prev_hop: previous hop (source) of path
> + * @last_valid: timestamp for last validation of path
> + */
> +struct batadv_nc_path {
> + struct hlist_node hash_entry;
> + struct rcu_head rcu;
> + atomic_t refcount;
> + struct list_head packet_list;
> + spinlock_t packet_list_lock; /* Protects packet_list */
> + uint8_t next_hop[ETH_ALEN];
> + uint8_t prev_hop[ETH_ALEN];
> + unsigned long last_valid;
> +};
> +
> +/**
> + * struct batadv_nc_packet - network coding packet used when coding and
> + * decoding packets
> + * @list: next and prev pointer for the list handling
> + * @packet_id: crc32 checksum of skb data
> + * @timestamp: field containing the info when the packet was added to path
> + * @neigh_node: pointer to original next hop neighbor of skb
> + * @skb: skb which can be encoded or used for decoding
> + * @nc_path: pointer to path this nc packet is attached to
> + */
> +struct batadv_nc_packet {
> + struct list_head list;
> + __be32 packet_id;
> + unsigned long timestamp;
> + struct batadv_neigh_node *neigh_node;
> + struct sk_buff *skb;
> + struct batadv_nc_path *nc_path;
> +};
> +
> /* forw_packet - structure for forw_list maintaining packets to be
> * send/forwarded
> */
> --
> 1.8.0.2
--
Antonio Quartulli
..each of us alone is worth nothing..
Ernesto "Che" Guevara
[-- Attachment #2: Type: application/pgp-signature, Size: 836 bytes --]
^ permalink raw reply [flat|nested] 14+ messages in thread
* [B.A.T.M.A.N.] [PATCHv2 5/7] batman-adv: Code and transmit packets if possible.
2012-12-14 6:32 [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Martin Hundebøll
` (3 preceding siblings ...)
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 4/7] batman-adv: Buffer unicast packets before forward Martin Hundebøll
@ 2012-12-14 6:32 ` Martin Hundebøll
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 6/7] batman-adv: Save overheard and tx packets for decoding Martin Hundebøll
` (2 subsequent siblings)
7 siblings, 0 replies; 14+ messages in thread
From: Martin Hundebøll @ 2012-12-14 6:32 UTC (permalink / raw)
To: b.a.t.m.a.n; +Cc: Martin Hundebøll
Before adding forward-skbs to the coding buffer, the buffer is searched
for a potential coding opportunity. If one is found, the two packets are
network coded and transmitted right away. If not, the forward-skb is
added to the buffer.
Network coded packets are transmitted with information about the two
receivers and the two coded packets. The first receiver is given by the
MAC header, while the second is given in the payload/bat-header. The
second receiver uses promiscuous mode to receive the packet and check
the second destination.
Signed-off-by: Martin Hundebøll <martin@hundeboll.net>
---
main.h | 6 +
network-coding.c | 403 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
packet.h | 33 +++++
soft-interface.c | 6 +
types.h | 16 +++
5 files changed, 464 insertions(+)
diff --git a/main.h b/main.h
index 9fd81b8..ac44412 100644
--- a/main.h
+++ b/main.h
@@ -303,4 +303,10 @@ static inline uint64_t batadv_sum_counter(struct batadv_priv *bat_priv,
return sum;
}
+/* Define a macro to reach the control buffer of the skb. The members of the
+ * control buffer are defined in struct batadv_skb_cb in types.h.
+ * The macro is inspired by the similar macro TCP_SKB_CB() in tcp.h.
+ */
+#define BATADV_SKB_CB(__skb) ((struct batadv_skb_cb *)&((__skb)->cb[0]))
+
#endif /* _NET_BATMAN_ADV_MAIN_H_ */
diff --git a/network-coding.c b/network-coding.c
index 2388176..5884c73 100644
--- a/network-coding.c
+++ b/network-coding.c
@@ -804,6 +804,405 @@ static struct batadv_nc_path *batadv_nc_get_path(struct batadv_priv *bat_priv,
}
/**
+ * batadv_nc_random_weight_tq - scale the receivers TQ-value to avoid unfair
+ * selection of a receiver with slightly lower TQ than the other
+ * @tq: to be weighted tq value
+ */
+static uint8_t batadv_nc_random_weight_tq(uint8_t tq)
+{
+ uint8_t rand_val, rand_tq;
+
+ get_random_bytes(&rand_val, sizeof(rand_val));
+
+ /* randomize the estimated packet loss (max TQ - estimated TQ) */
+ rand_tq = rand_val * (BATADV_TQ_MAX_VALUE - tq);
+
+ /* normalize the randomized packet loss */
+ rand_tq /= BATADV_TQ_MAX_VALUE;
+
+ /* convert to (randomized) estimated tq again */
+ return BATADV_TQ_MAX_VALUE - rand_tq;
+}
+
+/**
+ * batadv_nc_memxor - XOR destination with source
+ * @dst: byte array to XOR into
+ * @src: byte array to XOR from
+ * @len: length of destination array
+ */
+static void batadv_nc_memxor(char *dst, const char *src, unsigned int len)
+{
+ unsigned int i;
+
+ for (i = 0; i < len; ++i)
+ dst[i] ^= src[i];
+}
+
+/**
+ * batadv_nc_code_packets - code a received unicast_packet with an nc packet
+ * into a coded_packet and send it
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: data skb to forward
+ * @ethhdr: pointer to the ethernet header inside the skb
+ * @nc_packet: structure containing the packet to the skb can be coded with
+ * @neigh_node: next hop to forward packet to
+ *
+ * Returns true if both packets are consumed, false otherwise.
+ */
+static bool batadv_nc_code_packets(struct batadv_priv *bat_priv,
+ struct sk_buff *skb,
+ struct ethhdr *ethhdr,
+ struct batadv_nc_packet *nc_packet,
+ struct batadv_neigh_node *neigh_node)
+{
+ uint8_t tq_weighted_neigh, tq_weighted_coding;
+ struct sk_buff *skb_dest, *skb_src;
+ struct batadv_unicast_packet *packet1;
+ struct batadv_unicast_packet *packet2;
+ struct batadv_coded_packet *coded_packet;
+ struct batadv_neigh_node *neigh_tmp, *router_neigh;
+ struct batadv_neigh_node *router_coding = NULL;
+ uint8_t *first_source, *first_dest, *second_source, *second_dest;
+ __be32 packet_id1, packet_id2;
+ size_t count;
+ bool res = false;
+ int coding_len;
+ int unicast_size = sizeof(*packet1);
+ int coded_size = sizeof(*coded_packet);
+ int header_add = coded_size + unicast_size;
+
+ router_neigh = batadv_orig_node_get_router(neigh_node->orig_node);
+ if (!router_neigh)
+ goto out;
+
+ neigh_tmp = nc_packet->neigh_node;
+ router_coding = batadv_orig_node_get_router(neigh_tmp->orig_node);
+ if (!router_coding)
+ goto out;
+
+ tq_weighted_neigh = batadv_nc_random_weight_tq(router_neigh->tq_avg);
+ tq_weighted_coding = batadv_nc_random_weight_tq(router_coding->tq_avg);
+
+ /* Select one destination for the MAC-header dst-field based on
+ * weighted TQ-values.
+ */
+ if (tq_weighted_neigh >= tq_weighted_coding) {
+ /* Destination from nc_packet is selected for MAC-header */
+ first_dest = nc_packet->nc_path->next_hop;
+ first_source = nc_packet->nc_path->prev_hop;
+ second_dest = neigh_node->addr;
+ second_source = ethhdr->h_source;
+ packet1 = (struct batadv_unicast_packet *)nc_packet->skb->data;
+ packet2 = (struct batadv_unicast_packet *)skb->data;
+ packet_id1 = nc_packet->packet_id;
+ packet_id2 = batadv_skb_crc32(skb,
+ skb->data + sizeof(*packet2));
+ } else {
+ /* Destination for skb is selected for MAC-header */
+ first_dest = neigh_node->addr;
+ first_source = ethhdr->h_source;
+ second_dest = nc_packet->nc_path->next_hop;
+ second_source = nc_packet->nc_path->prev_hop;
+ packet1 = (struct batadv_unicast_packet *)skb->data;
+ packet2 = (struct batadv_unicast_packet *)nc_packet->skb->data;
+ packet_id1 = batadv_skb_crc32(skb,
+ skb->data + sizeof(*packet1));
+ packet_id2 = nc_packet->packet_id;
+ }
+
+ /* Instead of zero padding the smallest data buffer, we
+ * code into the largest.
+ */
+ if (skb->len <= nc_packet->skb->len) {
+ skb_dest = nc_packet->skb;
+ skb_src = skb;
+ } else {
+ skb_dest = skb;
+ skb_src = nc_packet->skb;
+ }
+
+ /* coding_len is used when decoding the packet shorter packet */
+ coding_len = skb_src->len - unicast_size;
+
+ if (skb_linearize(skb_dest) < 0 || skb_linearize(skb_src) < 0)
+ goto out;
+
+ skb_push(skb_dest, header_add);
+
+ coded_packet = (struct batadv_coded_packet *)skb_dest->data;
+ skb_reset_mac_header(skb_dest);
+
+ coded_packet->header.packet_type = BATADV_CODED;
+ coded_packet->header.version = BATADV_COMPAT_VERSION;
+ coded_packet->header.ttl = packet1->header.ttl;
+
+ /* Info about first unicast packet */
+ memcpy(coded_packet->first_source, first_source, ETH_ALEN);
+ memcpy(coded_packet->first_orig_dest, packet1->dest, ETH_ALEN);
+ coded_packet->first_crc = packet_id1;
+ coded_packet->first_ttvn = packet1->ttvn;
+
+ /* Info about second unicast packet */
+ memcpy(coded_packet->second_dest, second_dest, ETH_ALEN);
+ memcpy(coded_packet->second_source, second_source, ETH_ALEN);
+ memcpy(coded_packet->second_orig_dest, packet2->dest, ETH_ALEN);
+ coded_packet->second_crc = packet_id2;
+ coded_packet->second_ttl = packet2->header.ttl;
+ coded_packet->second_ttvn = packet2->ttvn;
+ coded_packet->coded_len = htons(coding_len);
+
+ /* This is where the magic happens: Code skb_src into skb_dest */
+ batadv_nc_memxor(skb_dest->data + coded_size,
+ skb_src->data + unicast_size, coding_len);
+
+ /* Update counters accordingly */
+ if (BATADV_SKB_CB(skb_src)->decoded &&
+ BATADV_SKB_CB(skb_dest)->decoded) {
+ /* Both packets are recoded */
+ count = skb_src->len + ETH_HLEN;
+ count += skb_dest->len + ETH_HLEN;
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE, 2);
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES, count);
+ } else if (!BATADV_SKB_CB(skb_src)->decoded &&
+ !BATADV_SKB_CB(skb_dest)->decoded) {
+ /* Both packets are newly coded */
+ count = skb_src->len + ETH_HLEN;
+ count += skb_dest->len + ETH_HLEN;
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE, 2);
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES, count);
+ } else if (BATADV_SKB_CB(skb_src)->decoded &&
+ !BATADV_SKB_CB(skb_dest)->decoded) {
+ /* skb_src recoded and skb_dest is newly coded */
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_RECODE);
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES,
+ skb_src->len + ETH_HLEN);
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_CODE);
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES,
+ skb_dest->len + ETH_HLEN);
+ } else if (!BATADV_SKB_CB(skb_src)->decoded &&
+ BATADV_SKB_CB(skb_dest)->decoded) {
+ /* skb_src is newly coded and skb_dest is recoded */
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_CODE);
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_CODE_BYTES,
+ skb_src->len + ETH_HLEN);
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_RECODE);
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_RECODE_BYTES,
+ skb_dest->len + ETH_HLEN);
+ }
+
+ /* skb_src is now coded into skb_dest, so free it */
+ kfree_skb(skb_src);
+
+ /* avoid duplicate free of skb from nc_packet */
+ nc_packet->skb = NULL;
+ batadv_nc_packet_free(nc_packet);
+
+ /* Send the coded packet and return true */
+ batadv_send_skb_packet(skb_dest, neigh_node->if_incoming, first_dest);
+ res = true;
+out:
+ if (router_neigh)
+ batadv_neigh_node_free_ref(router_neigh);
+ if (router_coding)
+ batadv_neigh_node_free_ref(router_coding);
+ return res;
+}
+
+/**
+ * batadv_nc_skb_coding_possible - true if a decoded skb is available at dst.
+ * @skb: data skb to forward
+ * @dst: destination mac address of the other skb to code with
+ * @src: source mac address of skb
+ *
+ * Whenever we network code a packet we have to check whether we received it in
+ * a network coded form. If so, we may not be able to use it for coding because
+ * some neighbors may also have received (overheard) the packet in the network
+ * coded form without being able to decode it. It is hard to know which of the
+ * neighboring nodes was able to decode the packet, therefore we can only
+ * re-code the packet if the source of the previous encoded packet is involved.
+ * Since the source encoded the packet we can be certain it has all necessary
+ * decode information.
+ *
+ * Returns true if coding of a decoded packet is allowed.
+ */
+static bool batadv_nc_skb_coding_possible(struct sk_buff *skb,
+ uint8_t *dst,
+ uint8_t *src)
+{
+ if (BATADV_SKB_CB(skb)->decoded && !batadv_compare_eth(dst, src))
+ return false;
+ else
+ return true;
+}
+
+/**
+ * batadv_nc_path_search - Find the coding path matching in_nc_node and
+ * out_nc_node to retrieve a buffered packet that can be used for coding.
+ * @bat_priv: the bat priv with all the soft interface information
+ * @in_nc_node: pointer to skb next hop's neighbor nc node
+ * @out_nc_node: pointer to skb source's neighbor nc node
+ * @skb: data skb to forward
+ * @eth_dst: next hop mac address of skb
+ *
+ * Returns true if coding of a decoded skb is allowed.
+ */
+static struct batadv_nc_packet *
+batadv_nc_path_search(struct batadv_priv *bat_priv,
+ struct batadv_nc_node *in_nc_node,
+ struct batadv_nc_node *out_nc_node,
+ struct sk_buff *skb,
+ uint8_t *eth_dst)
+{
+ struct batadv_nc_path *nc_path, nc_path_key;
+ struct batadv_nc_packet *nc_packet_out = NULL;
+ struct batadv_nc_packet *nc_packet, *nc_packet_tmp;
+ struct hlist_node *node;
+ struct batadv_hashtable *hash = bat_priv->nc.coding_hash;
+ int idx;
+
+ if (!hash)
+ return NULL;
+
+ /* Create almost path key */
+ batadv_nc_hash_key_gen(&nc_path_key, in_nc_node->addr,
+ out_nc_node->addr);
+ idx = batadv_nc_hash_choose(&nc_path_key, hash->size);
+
+ /* Check for coding opportunities in this nc_path */
+ rcu_read_lock();
+ hlist_for_each_entry_rcu(nc_path, node, &hash->table[idx], hash_entry) {
+ if (!batadv_compare_eth(nc_path->prev_hop, in_nc_node->addr))
+ continue;
+
+ if (!batadv_compare_eth(nc_path->next_hop, out_nc_node->addr))
+ continue;
+
+ spin_lock_bh(&nc_path->packet_list_lock);
+ if (list_empty(&nc_path->packet_list)) {
+ spin_unlock_bh(&nc_path->packet_list_lock);
+ continue;
+ }
+
+ list_for_each_entry_safe(nc_packet, nc_packet_tmp,
+ &nc_path->packet_list, list) {
+ if (!batadv_nc_skb_coding_possible(nc_packet->skb,
+ eth_dst,
+ in_nc_node->addr))
+ continue;
+
+ /* Coding opportunity is found! */
+ list_del(&nc_packet->list);
+ nc_packet_out = nc_packet;
+ break;
+ }
+
+ spin_unlock_bh(&nc_path->packet_list_lock);
+ break;
+ }
+ rcu_read_unlock();
+
+ return nc_packet_out;
+}
+
+/**
+ * batadv_nc_skb_src_search - Loops through the list of neighoring nodes of the
+ * skb's sender (may be equal to the originator).
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: data skb to forward
+ * @eth_dst: next hop mac address of skb
+ * @eth_src: source mac address of skb
+ * @in_nc_node: pointer to skb next hop's neighbor nc node
+ *
+ * Returns an nc packet if a suitable coding packet was found, NULL otherwise.
+ */
+static struct batadv_nc_packet *
+batadv_nc_skb_src_search(struct batadv_priv *bat_priv,
+ struct sk_buff *skb,
+ uint8_t *eth_dst,
+ uint8_t *eth_src,
+ struct batadv_nc_node *in_nc_node)
+{
+ struct batadv_orig_node *orig_node;
+ struct batadv_nc_node *out_nc_node;
+ struct batadv_nc_packet *nc_packet = NULL;
+
+ orig_node = batadv_orig_hash_find(bat_priv, eth_src);
+ if (!orig_node)
+ return NULL;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(out_nc_node,
+ &orig_node->out_coding_list, list) {
+ /* Check if the skb is decoded and if recoding is possible */
+ if (!batadv_nc_skb_coding_possible(skb,
+ out_nc_node->addr, eth_src))
+ continue;
+
+ /* Search for an opportunity in this nc_path */
+ nc_packet = batadv_nc_path_search(bat_priv, in_nc_node,
+ out_nc_node, skb, eth_dst);
+ if (nc_packet)
+ break;
+ }
+ rcu_read_unlock();
+
+ batadv_orig_node_free_ref(orig_node);
+ return nc_packet;
+}
+
+/**
+ * batadv_nc_skb_dst_search - Loops through list of neighboring nodes to dst.
+ * @skb: data skb to forward
+ * @neigh_node: next hop to forward packet to
+ * @ethhdr: pointer to the ethernet header inside the skb
+ *
+ * Loops through list of neighboring nodes the next hop has a good connection to
+ * (receives OGMs with a sufficient quality). We need to find a neighbor of our
+ * next hop that potentially sent a packet which our next hop also received
+ * (overheard) and has stored for later decoding.
+ *
+ * Returns true if the skb was consumed (encoded packet sent) or false otherwise
+ */
+static bool batadv_nc_skb_dst_search(struct sk_buff *skb,
+ struct batadv_neigh_node *neigh_node,
+ struct ethhdr *ethhdr)
+{
+ struct net_device *netdev = neigh_node->if_incoming->soft_iface;
+ struct batadv_priv *bat_priv = netdev_priv(netdev);
+ struct batadv_orig_node *orig_node = neigh_node->orig_node;
+ struct batadv_nc_node *nc_node;
+ struct batadv_nc_packet *nc_packet = NULL;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(nc_node, &orig_node->in_coding_list, list) {
+ /* Search for coding opportunity with this in_nc_node */
+ nc_packet = batadv_nc_skb_src_search(bat_priv, skb,
+ neigh_node->addr,
+ ethhdr->h_source, nc_node);
+
+ /* Opportunity was found, so stop searching */
+ if (nc_packet)
+ break;
+ }
+ rcu_read_unlock();
+
+ if (!nc_packet)
+ return false;
+
+ /* Code and send packets */
+ if (batadv_nc_code_packets(bat_priv, skb, ethhdr, nc_packet,
+ neigh_node))
+ return true;
+
+ /* out of mem ? Coding failed - we have to free the buffered packet
+ * to avoid memleaks. The skb passed as argument will be dealt with
+ * by the calling function.
+ */
+ batadv_nc_send_packet(nc_packet);
+ return false;
+}
+
+/**
* batadv_nc_skb_add_to_path - buffer skb for later encoding / decoding
* @skb: skb to add to path
* @nc_path: path to add skb to
@@ -868,6 +1267,10 @@ bool batadv_nc_skb_forward(struct sk_buff *skb,
if (packet->header.packet_type != BATADV_UNICAST)
goto out;
+ /* Try to find a coding opportunity and send the skb if one is found */
+ if (batadv_nc_skb_dst_search(skb, neigh_node, ethhdr))
+ return true;
+
/* Find or create a nc_path for this src-dst pair */
nc_path = batadv_nc_get_path(bat_priv,
bat_priv->nc.coding_hash,
diff --git a/packet.h b/packet.h
index cb6405b..49ab4f6 100644
--- a/packet.h
+++ b/packet.h
@@ -30,6 +30,7 @@ enum batadv_packettype {
BATADV_TT_QUERY = 0x07,
BATADV_ROAM_ADV = 0x08,
BATADV_UNICAST_4ADDR = 0x09,
+ BATADV_CODED = 0x0a,
};
/**
@@ -278,4 +279,36 @@ struct batadv_tt_change {
uint8_t addr[ETH_ALEN];
} __packed;
+/**
+ * struct batadv_coded_packet - network coded packet
+ * @header: common batman packet header and ttl of first included packet
+ * @reserved: Align following fields to 2-byte boundaries
+ * @first_source: original source of first included packet
+ * @first_orig_dest: original destinal of first included packet
+ * @first_crc: checksum of first included packet
+ * @first_ttvn: tt-version number of first included packet
+ * @second_ttl: ttl of second packet
+ * @second_dest: second receiver of this coded packet
+ * @second_source: original source of second included packet
+ * @second_orig_dest: original destination of second included packet
+ * @second_crc: checksum of second included packet
+ * @second_ttvn: tt version number of second included packet
+ * @coded_len: length of network coded part of the payload
+ */
+struct batadv_coded_packet {
+ struct batadv_header header;
+ uint8_t first_ttvn;
+ /* uint8_t first_dest[ETH_ALEN]; - saved in mac header destination */
+ uint8_t first_source[ETH_ALEN];
+ uint8_t first_orig_dest[ETH_ALEN];
+ __be32 first_crc;
+ uint8_t second_ttl;
+ uint8_t second_ttvn;
+ uint8_t second_dest[ETH_ALEN];
+ uint8_t second_source[ETH_ALEN];
+ uint8_t second_orig_dest[ETH_ALEN];
+ __be32 second_crc;
+ uint16_t coded_len;
+};
+
#endif /* _NET_BATMAN_ADV_PACKET_H_ */
diff --git a/soft-interface.c b/soft-interface.c
index 69ad5e2..83abdf9 100644
--- a/soft-interface.c
+++ b/soft-interface.c
@@ -636,6 +636,12 @@ static const struct {
{ "dat_put_rx" },
{ "dat_cached_reply_tx" },
#endif
+#ifdef CONFIG_BATMAN_ADV_NC
+ { "nc_code" },
+ { "nc_code_bytes" },
+ { "nc_recode" },
+ { "nc_recode_bytes" },
+#endif
};
static void batadv_get_strings(struct net_device *dev, uint32_t stringset,
diff --git a/types.h b/types.h
index b34fde7..a44e948 100644
--- a/types.h
+++ b/types.h
@@ -192,6 +192,12 @@ enum batadv_counters {
BATADV_CNT_DAT_PUT_RX,
BATADV_CNT_DAT_CACHED_REPLY_TX,
#endif
+#ifdef CONFIG_BATMAN_ADV_NC
+ BATADV_CNT_NC_CODE,
+ BATADV_CNT_NC_CODE_BYTES,
+ BATADV_CNT_NC_RECODE,
+ BATADV_CNT_NC_RECODE_BYTES,
+#endif
BATADV_CNT_NUM,
};
@@ -490,6 +496,16 @@ struct batadv_nc_packet {
struct batadv_nc_path *nc_path;
};
+/**
+ * batadv_skb_cb - control buffer structure used to store private data relevant
+ * to batman-adv in the skb->cb buffer in skbs.
+ * @decoded: Marks a skb as decoded, which is checked when searching for coding
+ * opportunities in network-coding.c
+ */
+struct batadv_skb_cb {
+ bool decoded;
+};
+
/* forw_packet - structure for forw_list maintaining packets to be
* send/forwarded
*/
--
1.8.0.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [B.A.T.M.A.N.] [PATCHv2 6/7] batman-adv: Save overheard and tx packets for decoding.
2012-12-14 6:32 [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Martin Hundebøll
` (4 preceding siblings ...)
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 5/7] batman-adv: Code and transmit packets if possible Martin Hundebøll
@ 2012-12-14 6:32 ` Martin Hundebøll
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 7/7] batman-adv: Receive coded packets and decode them Martin Hundebøll
2012-12-15 8:13 ` [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Marek Lindner
7 siblings, 0 replies; 14+ messages in thread
From: Martin Hundebøll @ 2012-12-14 6:32 UTC (permalink / raw)
To: b.a.t.m.a.n; +Cc: Martin Hundebøll
To be able to decode a network coded packet, a node must already know
one of the two coded packets. This is done by buffering skbs before
transmission and buffering packets sniffed with promiscuous mode from
other hosts.
Packets are kept in a buffer similar to the one with forward-skbs: A
hash table, where each entry, which corresponds to a src-dst pair, has a
linked list packets.
Signed-off-by: Martin Hundebøll <martin@hundeboll.net>
---
network-coding.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
network-coding.h | 18 +++++
routing.c | 13 +++-
send.c | 5 ++
soft-interface.c | 1 +
types.h | 10 +++
6 files changed, 252 insertions(+), 3 deletions(-)
diff --git a/network-coding.c b/network-coding.c
index 5884c73..b148ccb 100644
--- a/network-coding.c
+++ b/network-coding.c
@@ -27,6 +27,7 @@
#include "hard-interface.h"
static struct lock_class_key batadv_nc_coding_hash_lock_class_key;
+static struct lock_class_key batadv_nc_decoding_hash_lock_class_key;
static void batadv_nc_worker(struct work_struct *work);
@@ -47,8 +48,9 @@ static void batadv_nc_start_timer(struct batadv_priv *bat_priv)
int batadv_nc_init(struct batadv_priv *bat_priv)
{
bat_priv->nc.timestamp_fwd_flush = jiffies;
+ bat_priv->nc.timestamp_sniffed_purge = jiffies;
- if (bat_priv->nc.coding_hash)
+ if (bat_priv->nc.coding_hash || bat_priv->nc.decoding_hash)
return 0;
bat_priv->nc.coding_hash = batadv_hash_new(128);
@@ -58,6 +60,13 @@ int batadv_nc_init(struct batadv_priv *bat_priv)
batadv_hash_set_lock_class(bat_priv->nc.coding_hash,
&batadv_nc_coding_hash_lock_class_key);
+ bat_priv->nc.decoding_hash = batadv_hash_new(128);
+ if (!bat_priv->nc.decoding_hash)
+ goto err;
+
+ batadv_hash_set_lock_class(bat_priv->nc.coding_hash,
+ &batadv_nc_decoding_hash_lock_class_key);
+
INIT_DELAYED_WORK(&bat_priv->nc.work, batadv_nc_worker);
batadv_nc_start_timer(bat_priv);
@@ -76,6 +85,7 @@ void batadv_nc_init_bat_priv(struct batadv_priv *bat_priv)
atomic_set(&bat_priv->network_coding, 1);
bat_priv->nc.min_tq = 200;
bat_priv->nc.max_fwd_delay = 10;
+ bat_priv->nc.max_buffer_time = 200;
}
/**
@@ -176,6 +186,26 @@ static bool batadv_nc_to_purge_nc_path_coding(struct batadv_priv *bat_priv,
}
/**
+ * batadv_nc_to_purge_nc_path_decoding - checks whether an nc path has timed out
+ * @bat_priv: the bat priv with all the soft interface information
+ * @nc_path: the nc path to check
+ *
+ * Returns true if the entry has to be purged now, false otherwise
+ */
+static bool batadv_nc_to_purge_nc_path_decoding(struct batadv_priv *bat_priv,
+ struct batadv_nc_path *nc_path)
+{
+ if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
+ return true;
+
+ /* purge the path when no packets has been added for 10 times the
+ * max_buffer time
+ */
+ return batadv_has_timed_out(nc_path->last_valid,
+ bat_priv->nc.max_buffer_time*10);
+}
+
+/**
* batadv_nc_purge_orig_nc_nodes - go through list of nc nodes and purge stale
* entries
* @bat_priv: the bat priv with all the soft interface information
@@ -446,6 +476,43 @@ static void batadv_nc_send_packet(struct batadv_nc_packet *nc_packet)
}
/**
+ * batadv_nc_sniffed_purge - Checks timestamp of given sniffed nc_packet.
+ * @bat_priv: the bat priv with all the soft interface information
+ * @nc_path: the nc path the packet belongs to
+ * @nc_packet: the nc packet to be checked
+ *
+ * Checks whether the given sniffed (overheard) nc_packet has hit its buffering
+ * timeout. If so, the packet is no longer kept and the entry deleted from the
+ * queue. Has to be called with the appropriate locks.
+ *
+ * Returns false as soon as the entry in the fifo queue has not been timed out
+ * yet and true otherwise.
+ */
+static bool batadv_nc_sniffed_purge(struct batadv_priv *bat_priv,
+ struct batadv_nc_path *nc_path,
+ struct batadv_nc_packet *nc_packet)
+{
+ unsigned long timeout = bat_priv->nc.max_buffer_time;
+ bool res = false;
+
+ /* Packets are added to tail, so the remaining packets did not time
+ * out and we can stop processing the current queue
+ */
+ if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE &&
+ !batadv_has_timed_out(nc_packet->timestamp, timeout))
+ goto out;
+
+ /* purge nc packet */
+ list_del(&nc_packet->list);
+ batadv_nc_packet_free(nc_packet);
+
+ res = true;
+
+out:
+ return res;
+}
+
+/**
* batadv_nc_fwd_flush - Checks the timestamp of the given nc packet.
* @bat_priv: the bat priv with all the soft interface information
* @nc_path: the nc path the packet belongs to
@@ -546,6 +613,8 @@ static void batadv_nc_worker(struct work_struct *work)
batadv_nc_purge_orig_hash(bat_priv);
batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash,
batadv_nc_to_purge_nc_path_coding);
+ batadv_nc_purge_paths(bat_priv, bat_priv->nc.decoding_hash,
+ batadv_nc_to_purge_nc_path_decoding);
timeout = bat_priv->nc.max_fwd_delay;
@@ -555,6 +624,13 @@ static void batadv_nc_worker(struct work_struct *work)
bat_priv->nc.timestamp_fwd_flush = jiffies;
}
+ if (batadv_has_timed_out(bat_priv->nc.timestamp_sniffed_purge,
+ bat_priv->nc.max_buffer_time)) {
+ batadv_nc_process_nc_paths(bat_priv, bat_priv->nc.decoding_hash,
+ batadv_nc_sniffed_purge);
+ bat_priv->nc.timestamp_sniffed_purge = jiffies;
+ }
+
/* Schedule a new check */
batadv_nc_start_timer(bat_priv);
}
@@ -1151,6 +1227,41 @@ batadv_nc_skb_src_search(struct batadv_priv *bat_priv,
}
/**
+ * batadv_nc_skb_store_before_coding - set the ethernet src and dst of the
+ * unicast skb before it is stored for use in later decoding
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: data skb to store
+ * @eth_dst_new: new destination mac address of skb
+ */
+static void batadv_nc_skb_store_before_coding(struct batadv_priv *bat_priv,
+ struct sk_buff *skb,
+ uint8_t *eth_dst_new)
+{
+ struct ethhdr *ethhdr;
+
+ /* Copy skb header to change the mac header */
+ skb = pskb_copy(skb, GFP_ATOMIC);
+ if (!skb)
+ return;
+
+ /* Set the mac header as if we actually sent the packet uncoded */
+ ethhdr = (struct ethhdr *)skb_mac_header(skb);
+ memcpy(ethhdr->h_source, ethhdr->h_dest, ETH_ALEN);
+ memcpy(ethhdr->h_dest, eth_dst_new, ETH_ALEN);
+
+ /* Set data pointer to MAC header to mimic packets from our tx path */
+ skb_push(skb, ETH_HLEN);
+
+ /* Add the packet to the decoding packet pool */
+ batadv_nc_skb_store_for_decoding(bat_priv, skb);
+
+ /* batadv_nc_skb_store_for_decoding() clones the skb, so we must free
+ * our ref
+ */
+ kfree_skb(skb);
+}
+
+/**
* batadv_nc_skb_dst_search - Loops through list of neighboring nodes to dst.
* @skb: data skb to forward
* @neigh_node: next hop to forward packet to
@@ -1189,6 +1300,12 @@ static bool batadv_nc_skb_dst_search(struct sk_buff *skb,
if (!nc_packet)
return false;
+ /* Save packets for later decoding */
+ batadv_nc_skb_store_before_coding(bat_priv, skb,
+ neigh_node->addr);
+ batadv_nc_skb_store_before_coding(bat_priv, nc_packet->skb,
+ nc_packet->neigh_node->addr);
+
/* Code and send packets */
if (batadv_nc_code_packets(bat_priv, skb, ethhdr, nc_packet,
neigh_node))
@@ -1296,14 +1413,98 @@ out:
}
/**
+ * batadv_nc_skb_store_for_decoding - save a clone of the skb which can be used
+ * when decoding coded packets
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: data skb to store
+ */
+void batadv_nc_skb_store_for_decoding(struct batadv_priv *bat_priv,
+ struct sk_buff *skb)
+{
+ struct batadv_unicast_packet *packet;
+ struct batadv_nc_path *nc_path;
+ struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb);
+ __be32 packet_id;
+ u8 *payload;
+
+ /* Check if network coding is enabled */
+ if (!atomic_read(&bat_priv->network_coding))
+ goto out;
+
+ /* Check for supported packet type */
+ payload = skb_network_header(skb);
+ packet = (struct batadv_unicast_packet *)payload;
+ if (packet->header.packet_type != BATADV_UNICAST)
+ goto out;
+
+ /* Find existing nc_path or create a new */
+ nc_path = batadv_nc_get_path(bat_priv,
+ bat_priv->nc.decoding_hash,
+ ethhdr->h_source,
+ ethhdr->h_dest);
+
+ if (!nc_path)
+ goto out;
+
+ /* Clone skb and adjust skb->data to point at batman header */
+ skb = skb_clone(skb, GFP_ATOMIC);
+ if (unlikely(!skb))
+ goto free_nc_path;
+
+ if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
+ goto free_skb;
+
+ if (unlikely(!skb_pull_rcsum(skb, ETH_HLEN)))
+ goto free_skb;
+
+ /* Add skb to nc_path */
+ packet_id = batadv_skb_crc32(skb, payload + sizeof(*packet));
+ if (!batadv_nc_skb_add_to_path(skb, nc_path, NULL, packet_id))
+ goto free_skb;
+
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_BUFFER);
+ return;
+
+free_skb:
+ kfree_skb(skb);
+free_nc_path:
+ batadv_nc_path_free_ref(nc_path);
+out:
+ return;
+}
+
+/**
+ * batadv_nc_skb_store_sniffed_unicast - check if a received unicast packet
+ * should be saved in the decoding buffer and, if so, store it there
+ * @bat_priv: the bat priv with all the soft interface information
+ * @skb: unicast skb to store
+ */
+void batadv_nc_skb_store_sniffed_unicast(struct batadv_priv *bat_priv,
+ struct sk_buff *skb)
+{
+ struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb);
+
+ if (batadv_is_my_mac(ethhdr->h_dest))
+ return;
+
+ /* Set data pointer to MAC header to mimic packets from our tx path */
+ skb_push(skb, ETH_HLEN);
+
+ batadv_nc_skb_store_for_decoding(bat_priv, skb);
+}
+
+/**
* batadv_nc_free - clean up network coding memory
* @bat_priv: the bat priv with all the soft interface information
*/
void batadv_nc_free(struct batadv_priv *bat_priv)
{
cancel_delayed_work_sync(&bat_priv->nc.work);
+
batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash, NULL);
batadv_hash_destroy(bat_priv->nc.coding_hash);
+ batadv_nc_purge_paths(bat_priv, bat_priv->nc.decoding_hash, NULL);
+ batadv_hash_destroy(bat_priv->nc.decoding_hash);
}
/**
@@ -1385,6 +1586,11 @@ int batadv_nc_init_debugfs(struct batadv_priv *bat_priv)
if (!file)
goto out;
+ file = debugfs_create_u32("max_buffer_time", S_IRUGO | S_IWUSR, nc_dir,
+ &bat_priv->nc.max_buffer_time);
+ if (!file)
+ goto out;
+
return 0;
out:
diff --git a/network-coding.h b/network-coding.h
index 970dbde..7b4140d 100644
--- a/network-coding.h
+++ b/network-coding.h
@@ -38,6 +38,10 @@ void batadv_nc_init_orig(struct batadv_orig_node *orig_node);
bool batadv_nc_skb_forward(struct sk_buff *skb,
struct batadv_neigh_node *neigh_node,
struct ethhdr *ethhdr);
+void batadv_nc_skb_store_for_decoding(struct batadv_priv *bat_priv,
+ struct sk_buff *skb);
+void batadv_nc_skb_store_sniffed_unicast(struct batadv_priv *bat_priv,
+ struct sk_buff *skb);
int batadv_nc_nodes_seq_print_text(struct seq_file *seq, void *offset);
int batadv_nc_init_debugfs(struct batadv_priv *bat_priv);
@@ -89,6 +93,20 @@ static inline bool batadv_nc_skb_forward(struct sk_buff *skb,
return false;
}
+static inline void
+batadv_nc_skb_store_for_decoding(struct batadv_priv *bat_priv,
+ struct sk_buff *skb)
+{
+ return;
+}
+
+static inline void
+batadv_nc_skb_store_sniffed_unicast(struct batadv_priv *bat_priv,
+ struct sk_buff *skb)
+{
+ return;
+}
+
static inline int batadv_nc_nodes_seq_print_text(struct seq_file *seq,
void *offset)
{
diff --git a/routing.c b/routing.c
index f97cfe3..00e9f91 100644
--- a/routing.c
+++ b/routing.c
@@ -1052,7 +1052,7 @@ int batadv_recv_unicast_packet(struct sk_buff *skb,
struct batadv_unicast_4addr_packet *unicast_4addr_packet;
uint8_t *orig_addr;
struct batadv_orig_node *orig_node = NULL;
- int hdr_size = sizeof(*unicast_packet);
+ int check, hdr_size = sizeof(*unicast_packet);
bool is4addr;
unicast_packet = (struct batadv_unicast_packet *)skb->data;
@@ -1063,7 +1063,16 @@ int batadv_recv_unicast_packet(struct sk_buff *skb,
if (is4addr)
hdr_size = sizeof(*unicast_4addr_packet);
- if (batadv_check_unicast_packet(skb, hdr_size) < 0)
+ /* function returns -4 for promiscuous packets */
+ check = batadv_check_unicast_packet(skb, hdr_size);
+
+ /* Even though the packet is not for us, we might save it to use for
+ * decoding a later received coded packet
+ */
+ if (check == -4)
+ batadv_nc_skb_store_sniffed_unicast(bat_priv, skb);
+
+ if (check < 0)
return NET_RX_DROP;
if (!batadv_check_unicast_ttvn(bat_priv, skb))
diff --git a/send.c b/send.c
index 4425af9..8482b85 100644
--- a/send.c
+++ b/send.c
@@ -27,6 +27,7 @@
#include "vis.h"
#include "gateway_common.h"
#include "originator.h"
+#include "network-coding.h"
#include <linux/if_ether.h>
@@ -39,6 +40,7 @@ int batadv_send_skb_packet(struct sk_buff *skb,
struct batadv_hard_iface *hard_iface,
const uint8_t *dst_addr)
{
+ struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
struct ethhdr *ethhdr;
if (hard_iface->if_status != BATADV_IF_ACTIVE)
@@ -70,6 +72,9 @@ int batadv_send_skb_packet(struct sk_buff *skb,
skb->dev = hard_iface->net_dev;
+ /* Save a clone of the skb to use when decoding coded packets */
+ batadv_nc_skb_store_for_decoding(bat_priv, skb);
+
/* dev_queue_xmit() returns a negative result on error. However on
* congestion and traffic shaping, it drops and returns NET_XMIT_DROP
* (which is > 0). This will not be treated as an error.
diff --git a/soft-interface.c b/soft-interface.c
index 83abdf9..8f8a433 100644
--- a/soft-interface.c
+++ b/soft-interface.c
@@ -641,6 +641,7 @@ static const struct {
{ "nc_code_bytes" },
{ "nc_recode" },
{ "nc_recode_bytes" },
+ { "nc_buffer" },
#endif
};
diff --git a/types.h b/types.h
index a44e948..90df980 100644
--- a/types.h
+++ b/types.h
@@ -197,6 +197,7 @@ enum batadv_counters {
BATADV_CNT_NC_CODE_BYTES,
BATADV_CNT_NC_RECODE,
BATADV_CNT_NC_RECODE_BYTES,
+ BATADV_CNT_NC_BUFFER,
#endif
BATADV_CNT_NUM,
};
@@ -282,18 +283,27 @@ struct batadv_priv_dat {
* @work: work queue callback item for cleanup
* @min_tq: only consider neighbors for encoding if neigh_tq > min_tq
* @max_fwd_delay: maximum packet forward delay to allow coding of packets
+ * @max_buffer_time: buffer time for sniffed packets used to decoding
* @timestamp_fwd_flush: timestamp of last forward packet queue flush
+ * @timestamp_sniffed_purge: timestamp of last sniffed packet queue purge
* @coding_hash: Hash table used to buffer skbs while waiting for another
* incoming skb to code it with. Skbs are added to the buffer just before being
* forwarded in routing.c
+ * @decoding_hash: Hash table used to buffer skbs that might be needed to decode
+ * a received coded skb. The buffer is used for 1) skbs arriving on the
+ * soft-interface; 2) skbs overheard on the hard-interface; and 3) skbs
+ * forwarded by batman-adv.
*/
struct batadv_priv_nc {
struct delayed_work work;
struct dentry *debug_dir;
u8 min_tq;
u32 max_fwd_delay;
+ u32 max_buffer_time;
unsigned long timestamp_fwd_flush;
+ unsigned long timestamp_sniffed_purge;
struct batadv_hashtable *coding_hash;
+ struct batadv_hashtable *decoding_hash;
};
/**
--
1.8.0.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* [B.A.T.M.A.N.] [PATCHv2 7/7] batman-adv: Receive coded packets and decode them.
2012-12-14 6:32 [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Martin Hundebøll
` (5 preceding siblings ...)
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 6/7] batman-adv: Save overheard and tx packets for decoding Martin Hundebøll
@ 2012-12-14 6:32 ` Martin Hundebøll
2012-12-15 8:13 ` [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Marek Lindner
7 siblings, 0 replies; 14+ messages in thread
From: Martin Hundebøll @ 2012-12-14 6:32 UTC (permalink / raw)
To: b.a.t.m.a.n; +Cc: Martin Hundebøll
When receiving a network coded packet, the decoding buffer is searched
for a packet to use for decoding. The source, destination, and crc32 from
the coded packet is used to identify the wanted packet. The decoded
packet is passed to the usual unicast receiver function, as had it never
been network coded.
Signed-off-by: Martin Hundebøll <martin@hundeboll.net>
---
network-coding.c | 230 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
soft-interface.c | 4 +
types.h | 4 +
3 files changed, 238 insertions(+)
diff --git a/network-coding.c b/network-coding.c
index b148ccb..61f6ec8 100644
--- a/network-coding.c
+++ b/network-coding.c
@@ -25,11 +25,14 @@
#include "send.h"
#include "originator.h"
#include "hard-interface.h"
+#include "routing.h"
static struct lock_class_key batadv_nc_coding_hash_lock_class_key;
static struct lock_class_key batadv_nc_decoding_hash_lock_class_key;
static void batadv_nc_worker(struct work_struct *work);
+static int batadv_nc_recv_coded_packet(struct sk_buff *skb,
+ struct batadv_hard_iface *recv_if);
/**
* batadv_nc_start_timer - initialise the nc periodic worker
@@ -67,6 +70,11 @@ int batadv_nc_init(struct batadv_priv *bat_priv)
batadv_hash_set_lock_class(bat_priv->nc.coding_hash,
&batadv_nc_decoding_hash_lock_class_key);
+ /* Register our packet type */
+ if (batadv_recv_handler_register(BATADV_CODED,
+ batadv_nc_recv_coded_packet) < 0)
+ goto err;
+
INIT_DELAYED_WORK(&bat_priv->nc.work, batadv_nc_worker);
batadv_nc_start_timer(bat_priv);
@@ -1494,11 +1502,233 @@ void batadv_nc_skb_store_sniffed_unicast(struct batadv_priv *bat_priv,
}
/**
+ * batadv_nc_skb_decode_packet - decode given skb using the decode data stored
+ * in nc_packet
+ * @skb: unicast skb to decode
+ * @nc_packet: decode data needed to decode the skb
+ *
+ * Returns pointer to decoded unicast packet if the packet was decoded or NULL
+ * in case of an error.
+ */
+static struct batadv_unicast_packet *
+batadv_nc_skb_decode_packet(struct sk_buff *skb,
+ struct batadv_nc_packet *nc_packet)
+{
+ const int h_size = sizeof(struct batadv_unicast_packet);
+ const int h_diff = sizeof(struct batadv_coded_packet) - h_size;
+ struct batadv_unicast_packet *unicast_packet;
+ struct batadv_coded_packet coded_packet_tmp;
+ struct ethhdr *ethhdr, ethhdr_tmp;
+ uint8_t *orig_dest, ttl, ttvn;
+ unsigned int coding_len;
+
+ /* Save headers temporarily */
+ memcpy(&coded_packet_tmp, skb->data, sizeof(coded_packet_tmp));
+ memcpy(ðhdr_tmp, skb_mac_header(skb), sizeof(ethhdr_tmp));
+
+ if (skb_cow(skb, 0) < 0)
+ return NULL;
+
+ if (unlikely(!skb_pull_rcsum(skb, h_diff)))
+ return NULL;
+
+ /* Data points to batman header, so set mac header 14 bytes before
+ * and network to data
+ */
+ skb_set_mac_header(skb, -ETH_HLEN);
+ skb_reset_network_header(skb);
+
+ /* Reconstruct original mac header */
+ ethhdr = (struct ethhdr *)skb_mac_header(skb);
+ memcpy(ethhdr, ðhdr_tmp, sizeof(*ethhdr));
+
+ /* Select the correct unicast header information based on the location
+ * of our mac address in the coded_packet header
+ */
+ if (batadv_is_my_mac(coded_packet_tmp.second_dest)) {
+ /* If we are the second destination the packet was overheard,
+ * so the Ethernet address must be copied to h_dest and
+ * pkt_type changed from PACKET_OTHERHOST to PACKET_HOST
+ */
+ memcpy(ethhdr->h_dest, coded_packet_tmp.second_dest, ETH_ALEN);
+ skb->pkt_type = PACKET_HOST;
+
+ orig_dest = coded_packet_tmp.second_orig_dest;
+ ttl = coded_packet_tmp.second_ttl;
+ ttvn = coded_packet_tmp.second_ttvn;
+ } else {
+ orig_dest = coded_packet_tmp.first_orig_dest;
+ ttl = coded_packet_tmp.header.ttl;
+ ttvn = coded_packet_tmp.first_ttvn;
+ }
+
+ coding_len = ntohs(coded_packet_tmp.coded_len);
+
+ if (coding_len > skb->len)
+ return NULL;
+
+ /* Here the magic is reversed:
+ * extract the missing packet from the received coded packet
+ */
+ batadv_nc_memxor(skb->data + h_size,
+ nc_packet->skb->data + h_size,
+ coding_len);
+
+ /* Resize decoded skb if decoded with larger packet */
+ if (nc_packet->skb->len > coding_len + h_size)
+ pskb_trim_rcsum(skb, coding_len + h_size);
+
+ /* Create decoded unicast packet */
+ unicast_packet = (struct batadv_unicast_packet *)skb->data;
+ unicast_packet->header.packet_type = BATADV_UNICAST;
+ unicast_packet->header.version = BATADV_COMPAT_VERSION;
+ unicast_packet->header.ttl = ttl;
+ memcpy(unicast_packet->dest, orig_dest, ETH_ALEN);
+ unicast_packet->ttvn = ttvn;
+
+ batadv_nc_packet_free(nc_packet);
+ return unicast_packet;
+}
+
+/**
+ * batadv_nc_find_decoding_packet - search through buffered decoding data to
+ * find the data needed to decode the coded packet
+ * @bat_priv: the bat priv with all the soft interface information
+ * @ethhdr: pointer to the ethernet header inside the coded packet
+ * @coded: coded packet we try to find decode data for
+ *
+ * Returns pointer to nc packet if the needed data was found or NULL otherwise.
+ */
+static struct batadv_nc_packet *
+batadv_nc_find_decoding_packet(struct batadv_priv *bat_priv,
+ struct ethhdr *ethhdr,
+ struct batadv_coded_packet *coded)
+{
+ struct batadv_hashtable *hash = bat_priv->nc.decoding_hash;
+ struct hlist_node *hnode;
+ struct batadv_nc_packet *tmp_nc_packet, *nc_packet = NULL;
+ struct batadv_nc_path *nc_path, nc_path_key;
+ uint8_t *dest, *source;
+ __be32 packet_id;
+ int index;
+
+ if (!hash)
+ return NULL;
+
+ /* Select the correct packet id based on the location of our mac-addr */
+ dest = ethhdr->h_source;
+ if (!batadv_is_my_mac(coded->second_dest)) {
+ source = coded->second_source;
+ packet_id = coded->second_crc;
+ } else {
+ source = coded->first_source;
+ packet_id = coded->first_crc;
+ }
+
+ batadv_nc_hash_key_gen(&nc_path_key, source, dest);
+ index = batadv_nc_hash_choose(&nc_path_key, hash->size);
+
+ /* Search for matching coding path */
+ rcu_read_lock();
+ hlist_for_each_entry_rcu(nc_path, hnode, &hash->table[index],
+ hash_entry) {
+ /* Find matching nc_packet */
+ spin_lock_bh(&nc_path->packet_list_lock);
+ list_for_each_entry(tmp_nc_packet,
+ &nc_path->packet_list, list) {
+ if (packet_id == tmp_nc_packet->packet_id) {
+ list_del(&tmp_nc_packet->list);
+
+ nc_packet = tmp_nc_packet;
+ break;
+ }
+ }
+ spin_unlock_bh(&nc_path->packet_list_lock);
+
+ if (nc_packet)
+ break;
+ }
+ rcu_read_unlock();
+
+ if (!nc_packet)
+ batadv_dbg(BATADV_DBG_NC, bat_priv,
+ "No decoding packet found for %u\n", packet_id);
+
+ return nc_packet;
+}
+
+/**
+ * batadv_nc_recv_coded_packet - try to decode coded packet and enqueue the
+ * resulting unicast packet
+ * @skb: incoming coded packet
+ * @recv_if: pointer to interface this packet was received on
+ */
+static int batadv_nc_recv_coded_packet(struct sk_buff *skb,
+ struct batadv_hard_iface *recv_if)
+{
+ struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
+ struct batadv_unicast_packet *unicast_packet;
+ struct batadv_coded_packet *coded_packet;
+ struct batadv_nc_packet *nc_packet;
+ struct ethhdr *ethhdr;
+ int hdr_size = sizeof(*coded_packet);
+
+ /* Check if network coding is enabled */
+ if (!atomic_read(&bat_priv->network_coding))
+ return NET_RX_DROP;
+
+ /* Make sure we can access (and remove) header */
+ if (unlikely(!pskb_may_pull(skb, hdr_size)))
+ return NET_RX_DROP;
+
+ coded_packet = (struct batadv_coded_packet *)skb->data;
+ ethhdr = (struct ethhdr *)skb_mac_header(skb);
+
+ /* Verify frame is destined for us */
+ if (!batadv_is_my_mac(ethhdr->h_dest) &&
+ !batadv_is_my_mac(coded_packet->second_dest))
+ return NET_RX_DROP;
+
+ /* Update stat counter */
+ if (batadv_is_my_mac(coded_packet->second_dest))
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_SNIFFED);
+
+ nc_packet = batadv_nc_find_decoding_packet(bat_priv, ethhdr,
+ coded_packet);
+ if (!nc_packet) {
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE_FAILED);
+ return NET_RX_DROP;
+ }
+
+ /* Make skb's linear, because decoding accesses the entire buffer */
+ if (skb_linearize(skb) < 0)
+ return NET_RX_DROP;
+
+ if (skb_linearize(nc_packet->skb) < 0)
+ return NET_RX_DROP;
+
+ /* Decode the packet */
+ unicast_packet = batadv_nc_skb_decode_packet(skb, nc_packet);
+ if (!unicast_packet) {
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE_FAILED);
+ return NET_RX_DROP;
+ }
+
+ /* Mark packet as decoded to do correct recoding when forwarding */
+ BATADV_SKB_CB(skb)->decoded = true;
+ batadv_inc_counter(bat_priv, BATADV_CNT_NC_DECODE);
+ batadv_add_counter(bat_priv, BATADV_CNT_NC_DECODE_BYTES,
+ skb->len + ETH_HLEN);
+ return batadv_recv_unicast_packet(skb, recv_if);
+}
+
+/**
* batadv_nc_free - clean up network coding memory
* @bat_priv: the bat priv with all the soft interface information
*/
void batadv_nc_free(struct batadv_priv *bat_priv)
{
+ batadv_recv_handler_unregister(BATADV_CODED);
cancel_delayed_work_sync(&bat_priv->nc.work);
batadv_nc_purge_paths(bat_priv, bat_priv->nc.coding_hash, NULL);
diff --git a/soft-interface.c b/soft-interface.c
index 8f8a433..ac887d4 100644
--- a/soft-interface.c
+++ b/soft-interface.c
@@ -642,6 +642,10 @@ static const struct {
{ "nc_recode" },
{ "nc_recode_bytes" },
{ "nc_buffer" },
+ { "nc_decode" },
+ { "nc_decode_bytes" },
+ { "nc_decode_failed" },
+ { "nc_sniffed" },
#endif
};
diff --git a/types.h b/types.h
index 90df980..182daea 100644
--- a/types.h
+++ b/types.h
@@ -198,6 +198,10 @@ enum batadv_counters {
BATADV_CNT_NC_RECODE,
BATADV_CNT_NC_RECODE_BYTES,
BATADV_CNT_NC_BUFFER,
+ BATADV_CNT_NC_DECODE,
+ BATADV_CNT_NC_DECODE_BYTES,
+ BATADV_CNT_NC_DECODE_FAILED,
+ BATADV_CNT_NC_SNIFFED,
#endif
BATADV_CNT_NUM,
};
--
1.8.0.2
^ permalink raw reply related [flat|nested] 14+ messages in thread* Re: [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv
2012-12-14 6:32 [B.A.T.M.A.N.] [PATCHv2 0/7] CATWOMAN: Network coding in batman-adv Martin Hundebøll
` (6 preceding siblings ...)
2012-12-14 6:32 ` [B.A.T.M.A.N.] [PATCHv2 7/7] batman-adv: Receive coded packets and decode them Martin Hundebøll
@ 2012-12-15 8:13 ` Marek Lindner
7 siblings, 0 replies; 14+ messages in thread
From: Marek Lindner @ 2012-12-15 8:13 UTC (permalink / raw)
To: b.a.t.m.a.n; +Cc: Martin Hundebøll
On Friday, December 14, 2012 14:32:45 Martin Hundebøll wrote:
> I hereby bring you network coding in batman-adv. (Changed according
> to Antonios latest review). This allows a relay to send two packets
> (to two destinations) in a single transmission. Tests[1] have shown
> an increase in throughput up to 1.6 under the right circumstances.
>
> For this to work, you will need to compile batman-adv with
> CONFIG_BATMAN_ADV_NC=y and a wireless interface with working
> promiscuous mode. The rest is taken care of by batman-adv and the
> following patches.
Next time, please provide a "patch changelog" to make it easier to follow your
changes. Everybody else does this too. :-)
A few examples:
* https://lists.open-mesh.org/pipermail/b.a.t.m.a.n/2012-November/008536.html
* https://lists.open-mesh.org/pipermail/b.a.t.m.a.n/2012-October/008213.html
The second example is from you ..
Thanks,
Marek
^ permalink raw reply [flat|nested] 14+ messages in thread