This commit adds the needed configurable variables in bat_priv and according user interfaces in sysfs for the future multicast optimizations.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- Makefile.kbuild | 1 + bat_sysfs.c | 160 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ multicast.c | 121 +++++++++++++++++++++++++++++++++++++++++ multicast.h | 30 ++++++++++ packet.h | 4 ++ soft-interface.c | 4 ++ types.h | 4 ++ 7 files changed, 324 insertions(+), 0 deletions(-) create mode 100644 multicast.c create mode 100644 multicast.h

diff --git a/batman-adv/Makefile.kbuild b/batman-adv/Makefile.kbuild index e99c198..56296c4 100644 --- a/batman-adv/Makefile.kbuild +++ b/batman-adv/Makefile.kbuild @@ -49,5 +49,6 @@ batman-adv-y += send.o batman-adv-y += soft-interface.o batman-adv-y += translation-table.o batman-adv-y += unicast.o +batman-adv-y += multicast.o batman-adv-y += vis.o batman-adv-y += bat_printk.o diff --git a/batman-adv/bat_sysfs.c b/batman-adv/bat_sysfs.c index cd7bb51..f627d70 100644 --- a/batman-adv/bat_sysfs.c +++ b/batman-adv/bat_sysfs.c @@ -27,6 +27,7 @@ #include "gateway_common.h" #include "gateway_client.h" #include "vis.h" +#include "multicast.h"

#define to_dev(obj) container_of(obj, struct device, kobj) #define kobj_to_netdev(obj) to_net_dev(to_dev(obj->parent)) @@ -356,6 +357,153 @@ static ssize_t store_gw_bwidth(struct kobject *kobj, struct attribute *attr, return gw_bandwidth_set(net_dev, buff, count); }

+static ssize_t show_mcast_mode(struct kobject *kobj, struct attribute *attr, + char *buff) +{ + struct device *dev = to_dev(kobj->parent); + struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); + int mcast_mode = atomic_read(&bat_priv->mcast_mode); + int ret; + + switch (mcast_mode) { + case MCAST_MODE_CLASSIC_FLOODING: + ret = sprintf(buff, "classic_flooding\n"); + break; + case MCAST_MODE_PROACT_TRACKING: + ret = sprintf(buff, "proactive_tracking\n"); + break; + default: + ret = -1; + break; + } + + return ret; +} + +static ssize_t store_mcast_mode(struct kobject *kobj, struct attribute *attr, + char *buff, size_t count) +{ + struct device *dev = to_dev(kobj->parent); + struct net_device *net_dev = to_net_dev(dev); + struct bat_priv *bat_priv = netdev_priv(net_dev); + unsigned long val; + int ret, mcast_mode_tmp = -1; + + ret = strict_strtoul(buff, 10, &val); + + if (((count == 2) && (!ret) && (val == MCAST_MODE_CLASSIC_FLOODING)) || + (strncmp(buff, "classic_flooding", 16) == 0)) + mcast_mode_tmp = MCAST_MODE_CLASSIC_FLOODING; + + if (((count == 2) && (!ret) && (val == MCAST_MODE_PROACT_TRACKING)) || + (strncmp(buff, "proact_tracking", 15) == 0)) + mcast_mode_tmp = MCAST_MODE_PROACT_TRACKING; + + if (mcast_mode_tmp < 0) { + if (buff[count - 1] == '\n') + buff[count - 1] = '\0'; + + bat_info(net_dev, + "Invalid parameter for 'mcast mode' setting received: " + "%s\n", buff); + return -EINVAL; + } + + if (atomic_read(&bat_priv->mcast_mode) == mcast_mode_tmp) + return count; + + bat_info(net_dev, "Changing mcast mode from: %s to: %s\n", + atomic_read(&bat_priv->mcast_mode) == + MCAST_MODE_CLASSIC_FLOODING ? + "classic_flooding" : "proact_tracking", + mcast_mode_tmp == MCAST_MODE_CLASSIC_FLOODING ? + "classic_flooding" : "proact_tracking"); + + atomic_set(&bat_priv->mcast_mode, (unsigned)mcast_mode_tmp); + return count; +} + +static ssize_t show_mcast_tracker_interval(struct kobject *kobj, + struct attribute *attr, char *buff) +{ + struct device *dev = to_dev(kobj->parent); + struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); + int tracker_interval = atomic_read(&bat_priv->mcast_tracker_interval); + + if (!tracker_interval) + return sprintf(buff, "auto\n"); + else + return sprintf(buff, "%i\n", tracker_interval); +} + +static ssize_t store_mcast_tracker_interval(struct kobject *kobj, + struct attribute *attr, char *buff, size_t count) +{ + struct device *dev = to_dev(kobj->parent); + struct net_device *net_dev = to_net_dev(dev); + + return mcast_tracker_interval_set(net_dev, buff, count); +} + +static ssize_t show_mcast_tracker_timeout(struct kobject *kobj, + struct attribute *attr, char *buff) +{ + struct device *dev = to_dev(kobj->parent); + struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); + int tracker_timeout = atomic_read(&bat_priv->mcast_tracker_timeout); + + if (!tracker_timeout) + return sprintf(buff, "auto\n"); + else + return sprintf(buff, "%i\n", tracker_timeout); +} + +static ssize_t store_mcast_tracker_timeout(struct kobject *kobj, + struct attribute *attr, char *buff, size_t count) +{ + struct device *dev = to_dev(kobj->parent); + struct net_device *net_dev = to_net_dev(dev); + + return mcast_tracker_timeout_set(net_dev, buff, count); +} + +static ssize_t show_mcast_fanout(struct kobject *kobj, + struct attribute *attr, char *buff) +{ + struct device *dev = to_dev(kobj->parent); + struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); + + return sprintf(buff, "%i\n", + atomic_read(&bat_priv->mcast_fanout)); +} + +static ssize_t store_mcast_fanout(struct kobject *kobj, + struct attribute *attr, char *buff, size_t count) +{ + struct device *dev = to_dev(kobj->parent); + struct net_device *net_dev = to_net_dev(dev); + struct bat_priv *bat_priv = netdev_priv(net_dev); + unsigned long mcast_fanout_tmp; + int ret; + + ret = strict_strtoul(buff, 10, &mcast_fanout_tmp); + if (ret) { + bat_info(net_dev, "Invalid parameter for 'mcast_fanout' " + "setting received: %s\n", buff); + return -EINVAL; + } + + if (atomic_read(&bat_priv->mcast_fanout) == mcast_fanout_tmp) + return count; + + bat_info(net_dev, "Changing mcast fanout interval from: %i to: %li\n", + atomic_read(&bat_priv->mcast_fanout), + mcast_fanout_tmp); + + atomic_set(&bat_priv->mcast_fanout, mcast_fanout_tmp); + return count; +} + BAT_ATTR_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL); BAT_ATTR_BOOL(bonding, S_IRUGO | S_IWUSR, NULL); BAT_ATTR_BOOL(fragmentation, S_IRUGO | S_IWUSR, update_min_mtu); @@ -367,6 +515,14 @@ BAT_ATTR_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, TQ_MAX_VALUE, post_gw_deselect); static BAT_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, show_gw_bwidth, store_gw_bwidth); +static BAT_ATTR(mcast_mode, S_IRUGO | S_IWUSR, + show_mcast_mode, store_mcast_mode); +static BAT_ATTR(mcast_tracker_interval, S_IRUGO | S_IWUSR, + show_mcast_tracker_interval, store_mcast_tracker_interval); +static BAT_ATTR(mcast_tracker_timeout, S_IRUGO | S_IWUSR, + show_mcast_tracker_timeout, store_mcast_tracker_timeout); +static BAT_ATTR(mcast_fanout, S_IRUGO | S_IWUSR, + show_mcast_fanout, store_mcast_fanout); #ifdef CONFIG_BATMAN_ADV_DEBUG BAT_ATTR_UINT(log_level, S_IRUGO | S_IWUSR, 0, 3, NULL); #endif @@ -381,6 +537,10 @@ static struct bat_attribute *mesh_attrs[] = { &bat_attr_hop_penalty, &bat_attr_gw_sel_class, &bat_attr_gw_bandwidth, + &bat_attr_mcast_mode, + &bat_attr_mcast_tracker_interval, + &bat_attr_mcast_tracker_timeout, + &bat_attr_mcast_fanout, #ifdef CONFIG_BATMAN_ADV_DEBUG &bat_attr_log_level, #endif diff --git a/batman-adv/multicast.c b/batman-adv/multicast.c new file mode 100644 index 0000000..0598873 --- /dev/null +++ b/batman-adv/multicast.c @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2010 B.A.T.M.A.N. contributors: + * + * Linus Lüssing + * + * 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 "multicast.h" + +int mcast_tracker_interval_set(struct net_device *net_dev, char *buff, + size_t count) +{ + struct bat_priv *bat_priv = netdev_priv(net_dev); + unsigned long new_tracker_interval; + int cur_tracker_interval; + int ret; + + ret = strict_strtoul(buff, 10, &new_tracker_interval); + + if (ret && !strncmp(buff, "auto", 4)) { + new_tracker_interval = 0; + goto ok; + } + + else if (ret) { + bat_info(net_dev, "Invalid parameter for " + "'mcast_tracker_interval' setting received: %s\n", + buff); + return -EINVAL; + } + + if (new_tracker_interval < JITTER) { + bat_info(net_dev, "New mcast tracker interval too small: %li " + "(min: %i or auto)\n", new_tracker_interval, JITTER); + return -EINVAL; + } + +ok: + cur_tracker_interval = atomic_read(&bat_priv->mcast_tracker_interval); + + if (cur_tracker_interval == new_tracker_interval) + return count; + + if (!cur_tracker_interval && new_tracker_interval) + bat_info(net_dev, "Tracker interval change from: %s to: %li\n", + "auto", new_tracker_interval); + else if (cur_tracker_interval && !new_tracker_interval) + bat_info(net_dev, "Tracker interval change from: %i to: %s\n", + cur_tracker_interval, "auto"); + else + bat_info(net_dev, "Tracker interval change from: %i to: %li\n", + cur_tracker_interval, new_tracker_interval); + + atomic_set(&bat_priv->mcast_tracker_interval, new_tracker_interval); + + return count; +} + +int mcast_tracker_timeout_set(struct net_device *net_dev, char *buff, + size_t count) +{ + struct bat_priv *bat_priv = netdev_priv(net_dev); + unsigned long new_tracker_timeout; + int cur_tracker_timeout; + int ret; + + ret = strict_strtoul(buff, 10, &new_tracker_timeout); + + if (ret && !strncmp(buff, "auto", 4)) { + new_tracker_timeout = 0; + goto ok; + } + + else if (ret) { + bat_info(net_dev, "Invalid parameter for " + "'mcast_tracker_timeout' setting received: %s\n", + buff); + return -EINVAL; + } + + if (new_tracker_timeout < JITTER) { + bat_info(net_dev, "New mcast tracker timeout too small: %li " + "(min: %i or auto)\n", new_tracker_timeout, JITTER); + return -EINVAL; + } + +ok: + cur_tracker_timeout = atomic_read(&bat_priv->mcast_tracker_timeout); + + if (cur_tracker_timeout == new_tracker_timeout) + return count; + + if (!cur_tracker_timeout && new_tracker_timeout) + bat_info(net_dev, "Tracker timeout change from: %s to: %li\n", + "auto", new_tracker_timeout); + else if (cur_tracker_timeout && !new_tracker_timeout) + bat_info(net_dev, "Tracker timeout change from: %i to: %s\n", + cur_tracker_timeout, "auto"); + else + bat_info(net_dev, "Tracker timeout change from: %i to: %li\n", + cur_tracker_timeout, new_tracker_timeout); + + atomic_set(&bat_priv->mcast_tracker_timeout, new_tracker_timeout); + + return count; +} diff --git a/batman-adv/multicast.h b/batman-adv/multicast.h new file mode 100644 index 0000000..12a3376 --- /dev/null +++ b/batman-adv/multicast.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2010 B.A.T.M.A.N. contributors: + * + * Linus Lüssing + * + * 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_MULTICAST_H_ +#define _NET_BATMAN_ADV_MULTICAST_H_ + +int mcast_tracker_interval_set(struct net_device *net_dev, char *buff, + size_t count); +int mcast_tracker_timeout_set(struct net_device *net_dev, char *buff, + size_t count); + +#endif /* _NET_BATMAN_ADV_MULTICAST_H_ */ diff --git a/batman-adv/packet.h b/batman-adv/packet.h index a02f793..519bca8 100644 --- a/batman-adv/packet.h +++ b/batman-adv/packet.h @@ -50,6 +50,10 @@ #define VIS_TYPE_SERVER_SYNC 0 #define VIS_TYPE_CLIENT_UPDATE 1

+/* mcast defines */ +#define MCAST_MODE_CLASSIC_FLOODING 0 +#define MCAST_MODE_PROACT_TRACKING 1 + /* fragmentation defines */ #define UNI_FRAG_HEAD 0x01

diff --git a/batman-adv/soft-interface.c b/batman-adv/soft-interface.c index e89ede1..7cea678 100644 --- a/batman-adv/soft-interface.c +++ b/batman-adv/soft-interface.c @@ -597,6 +597,10 @@ struct net_device *softif_create(char *name) atomic_set(&bat_priv->gw_bandwidth, 41); atomic_set(&bat_priv->orig_interval, 1000); atomic_set(&bat_priv->hop_penalty, 10); + atomic_set(&bat_priv->mcast_mode, MCAST_MODE_CLASSIC_FLOODING); + atomic_set(&bat_priv->mcast_tracker_interval, 0); /* = auto */ + atomic_set(&bat_priv->mcast_tracker_timeout, 0); /* = auto */ + atomic_set(&bat_priv->mcast_fanout, 2); atomic_set(&bat_priv->log_level, 0); atomic_set(&bat_priv->fragmentation, 1); atomic_set(&bat_priv->bcast_queue_left, BCAST_QUEUE_LEN); diff --git a/batman-adv/types.h b/batman-adv/types.h index 8e97861..3abf6d9 100644 --- a/batman-adv/types.h +++ b/batman-adv/types.h @@ -137,6 +137,10 @@ struct bat_priv { atomic_t gw_bandwidth; /* gw bandwidth */ atomic_t orig_interval; /* uint */ atomic_t hop_penalty; /* uint */ + atomic_t mcast_mode; /* MCAST_MODE_* */ + atomic_t mcast_tracker_interval;/* uint, auto */ + atomic_t mcast_tracker_timeout; /* uint, auto */ + atomic_t mcast_fanout; /* uint */ atomic_t log_level; /* uint */ atomic_t bcast_seqno; atomic_t bcast_queue_left;

This commit adds a timer for sending periodic tracker packets (the sending is not in the scope of this patch). Furthermore, the timer gets restarted if the tracker interval gets changed or if the originator interval changed and we have selected auto mode for the tracker interval.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- bat_sysfs.c | 13 +++++++++++-- main.c | 5 +++++ multicast.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ multicast.h | 3 +++ types.h | 1 + 5 files changed, 77 insertions(+), 2 deletions(-)

diff --git a/batman-adv/bat_sysfs.c b/batman-adv/bat_sysfs.c index f627d70..8f688db 100644 --- a/batman-adv/bat_sysfs.c +++ b/batman-adv/bat_sysfs.c @@ -357,8 +357,16 @@ static ssize_t store_gw_bwidth(struct kobject *kobj, struct attribute *attr, return gw_bandwidth_set(net_dev, buff, count); }

+void update_mcast_tracker(struct net_device *net_dev) +{ + struct bat_priv *bat_priv = netdev_priv(net_dev); + + if (!atomic_read(&bat_priv->mcast_tracker_interval)) + mcast_tracker_reset(bat_priv); +} + static ssize_t show_mcast_mode(struct kobject *kobj, struct attribute *attr, - char *buff) + char *buff) { struct device *dev = to_dev(kobj->parent); struct bat_priv *bat_priv = netdev_priv(to_net_dev(dev)); @@ -509,7 +517,8 @@ BAT_ATTR_BOOL(bonding, S_IRUGO | S_IWUSR, NULL); BAT_ATTR_BOOL(fragmentation, S_IRUGO | S_IWUSR, update_min_mtu); static BAT_ATTR(vis_mode, S_IRUGO | S_IWUSR, show_vis_mode, store_vis_mode); static BAT_ATTR(gw_mode, S_IRUGO | S_IWUSR, show_gw_mode, store_gw_mode); -BAT_ATTR_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * JITTER, INT_MAX, NULL); +BAT_ATTR_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * JITTER, INT_MAX, + update_mcast_tracker); BAT_ATTR_UINT(hop_penalty, S_IRUGO | S_IWUSR, 0, TQ_MAX_VALUE, NULL); BAT_ATTR_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, TQ_MAX_VALUE, post_gw_deselect); diff --git a/batman-adv/main.c b/batman-adv/main.c index cb3c3a3..1641075 100644 --- a/batman-adv/main.c +++ b/batman-adv/main.c @@ -32,6 +32,7 @@ #include "gateway_client.h" #include "types.h" #include "vis.h" +#include "multicast.h" #include "hash.h"

struct list_head if_list; @@ -108,6 +109,9 @@ int mesh_init(struct net_device *soft_iface) if (vis_init(bat_priv) < 1) goto err;

+ if (mcast_init(bat_priv) < 1) + goto err; + atomic_set(&bat_priv->mesh_state, MESH_ACTIVE); goto end;

@@ -138,6 +142,7 @@ void mesh_free(struct net_device *soft_iface) hna_global_free(bat_priv);

softif_neigh_purge(bat_priv); + mcast_free(bat_priv);

atomic_set(&bat_priv->mesh_state, MESH_INACTIVE); } diff --git a/batman-adv/multicast.c b/batman-adv/multicast.c index 0598873..cc83937 100644 --- a/batman-adv/multicast.c +++ b/batman-adv/multicast.c @@ -22,6 +22,48 @@ #include "main.h" #include "multicast.h"

+/* how long to wait until sending a multicast tracker packet */ +static int tracker_send_delay(struct bat_priv *bat_priv) +{ + int tracker_interval = atomic_read(&bat_priv->mcast_tracker_interval); + + /* auto mode, set to 1/2 ogm interval */ + if (!tracker_interval) + tracker_interval = atomic_read(&bat_priv->orig_interval) / 2; + + /* multicast tracker packets get half as much jitter as ogms as they're + * limited down to JITTER and not JITTER*2 */ + return msecs_to_jiffies(tracker_interval - + JITTER/2 + (random32() % JITTER)); +} + +static void start_mcast_tracker(struct bat_priv *bat_priv) +{ + /* adding some jitter */ + unsigned long tracker_interval = tracker_send_delay(bat_priv); + queue_delayed_work(bat_event_workqueue, &bat_priv->mcast_tracker_work, + tracker_interval); +} + +static void stop_mcast_tracker(struct bat_priv *bat_priv) +{ + cancel_delayed_work_sync(&bat_priv->mcast_tracker_work); +} + +void mcast_tracker_reset(struct bat_priv *bat_priv) +{ + stop_mcast_tracker(bat_priv); + start_mcast_tracker(bat_priv); +} + +static void mcast_tracker_timer(struct work_struct *work) +{ + struct bat_priv *bat_priv = container_of(work, struct bat_priv, + mcast_tracker_work.work); + + start_mcast_tracker(bat_priv); +} + int mcast_tracker_interval_set(struct net_device *net_dev, char *buff, size_t count) { @@ -68,6 +110,8 @@ ok:

atomic_set(&bat_priv->mcast_tracker_interval, new_tracker_interval);

+ mcast_tracker_reset(bat_priv); + return count; }

@@ -119,3 +163,16 @@ ok:

return count; } + +int mcast_init(struct bat_priv *bat_priv) +{ + INIT_DELAYED_WORK(&bat_priv->mcast_tracker_work, mcast_tracker_timer); + start_mcast_tracker(bat_priv); + + return 1; +} + +void mcast_free(struct bat_priv *bat_priv) +{ + stop_mcast_tracker(bat_priv); +} diff --git a/batman-adv/multicast.h b/batman-adv/multicast.h index 12a3376..26ce6d8 100644 --- a/batman-adv/multicast.h +++ b/batman-adv/multicast.h @@ -26,5 +26,8 @@ int mcast_tracker_interval_set(struct net_device *net_dev, char *buff, size_t count); int mcast_tracker_timeout_set(struct net_device *net_dev, char *buff, size_t count); +void mcast_tracker_reset(struct bat_priv *bat_priv); +int mcast_init(struct bat_priv *bat_priv); +void mcast_free(struct bat_priv *bat_priv);

#endif /* _NET_BATMAN_ADV_MULTICAST_H_ */ diff --git a/batman-adv/types.h b/batman-adv/types.h index 3abf6d9..c4ae252 100644 --- a/batman-adv/types.h +++ b/batman-adv/types.h @@ -173,6 +173,7 @@ struct bat_priv { struct delayed_work hna_work; struct delayed_work orig_work; struct delayed_work vis_work; + struct delayed_work mcast_tracker_work; struct gw_node *curr_gw; struct vis_info *my_vis_info; };

This commit introduces batman multicast tracker packets. Their job is, to mark nodes responsible for forwarding multicast data later (so a multicast receiver will not be marked, only the forwarding nodes).

When having activated the proact_tracking multicast mode, a path between all multicast _receivers_ of a group will be marked - in fact, in this mode BATMAN will assume, that a multicast receiver is also a multicast sender, therefore a multicast sender should also join the same multicast group.

The advantage of this is less complexity and the paths are marked in advance before an actual data packet has been sent, decreasing delays. The disadvantage is higher protocol overhead.

One large tracker packet will be created on a generating node first, which then gets split for every necessary next hop destination.

This commit does not add forwarding of tracker packets but just local generation and local sending of them.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- multicast.c | 548 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ multicast.h | 3 + 2 files changed, 551 insertions(+), 0 deletions(-)

diff --git a/batman-adv/multicast.c b/batman-adv/multicast.c index cc83937..34e89a8 100644 --- a/batman-adv/multicast.c +++ b/batman-adv/multicast.c @@ -21,6 +21,76 @@

#include "main.h" #include "multicast.h" +#include "hash.h" +#include "send.h" +#include "compat.h" + +struct tracker_packet_state { + int mcast_num, dest_num; + struct mcast_entry *mcast_entry; + uint8_t *dest_entry; + int break_flag; +}; + +static void init_state_mcast_entry(struct tracker_packet_state *state, + struct mcast_tracker_packet *tracker_packet) +{ + state->mcast_num = 0; + state->mcast_entry = (struct mcast_entry *)(tracker_packet + 1); + state->dest_entry = (uint8_t *)(state->mcast_entry + 1); +} + +static int check_state_mcast_entry(struct tracker_packet_state *state, + struct mcast_tracker_packet *tracker_packet) +{ + if (state->mcast_num < tracker_packet->num_mcast_entries && + !state->break_flag) + return 1; + + return 0; +} + +static void inc_state_mcast_entry(struct tracker_packet_state *state) +{ + state->mcast_num++; + state->mcast_entry = (struct mcast_entry *)state->dest_entry; + state->dest_entry = (uint8_t *)(state->mcast_entry + 1); +} + +static void init_state_dest_entry(struct tracker_packet_state *state) +{ + state->dest_num = 0; + state->break_flag = 1; +} + +static int check_state_dest_entry(struct tracker_packet_state *state) +{ + if (state->dest_num < state->mcast_entry->num_dest) + return 1; + + return 0; +} + +static void inc_state_dest_entry(struct tracker_packet_state *state) +{ + state->dest_num++; + state->dest_entry += ETH_ALEN; + state->break_flag = 0; +} + +#define tracker_packet_for_each_dest(state, tracker_packet) \ + for (init_state_mcast_entry(state, tracker_packet); \ + check_state_mcast_entry(state, tracker_packet); \ + inc_state_mcast_entry(state)) \ + for (init_state_dest_entry(state); \ + check_state_dest_entry(state); \ + inc_state_dest_entry(state)) + +struct dest_entries_list { + struct list_head list; + uint8_t dest[6]; + struct batman_if *batman_if; +};

/* how long to wait until sending a multicast tracker packet */ static int tracker_send_delay(struct bat_priv *bat_priv) @@ -56,11 +126,489 @@ void mcast_tracker_reset(struct bat_priv *bat_priv) start_mcast_tracker(bat_priv); }

+static inline int find_mca_match(struct orig_node *orig_node, + int mca_pos, uint8_t *mc_addr_list, int num_mcast_entries) +{ + int pos; + + for (pos = 0; pos < num_mcast_entries; pos++) + if (!memcmp(&mc_addr_list[pos*ETH_ALEN], + &orig_node->mca_buff[ETH_ALEN*mca_pos], ETH_ALEN)) + return pos; + return -1; +} + +/** + * Prepares a multicast tracker packet on a multicast member with all its + * groups and their members attached. Note, that the proactive tracking + * mode does not differentiate between multicast senders and receivers, + * resulting in tracker packets between each node. + * + * Returns NULL if this node is not a member of any group or if there are + * no other members in its groups. + * + * @bat_priv: bat_priv for the mesh we are preparing this packet + */ +static struct mcast_tracker_packet *mcast_proact_tracker_prepare( + struct bat_priv *bat_priv, int *tracker_packet_len) +{ + struct net_device *soft_iface = bat_priv->primary_if->soft_iface; + uint8_t *mc_addr_list; + MC_LIST *mc_entry; + struct element_t *bucket; + struct orig_node *orig_node; + struct hashtable_t *hash = bat_priv->orig_hash; + struct hlist_node *walk; + struct hlist_head *head; + int i; + + /* one dest_entries_list per multicast group, + * they'll collect dest_entries[x] */ + int num_mcast_entries, used_mcast_entries = 0; + struct list_head *dest_entries_list; + struct dest_entries_list dest_entries[UINT8_MAX], *dest, *tmp; + int num_dest_entries, dest_entries_total = 0; + + uint8_t *dest_entry; + int pos, mca_pos; + struct mcast_tracker_packet *tracker_packet = NULL; + struct mcast_entry *mcast_entry; + + if (!hash) + goto out; + + /* Make a copy so we don't have to rush because of locking */ + netif_addr_lock_bh(soft_iface); + num_mcast_entries = netdev_mc_count(soft_iface); + mc_addr_list = kmalloc(ETH_ALEN * num_mcast_entries, GFP_ATOMIC); + if (!mc_addr_list) { + netif_addr_unlock_bh(soft_iface); + goto out; + } + pos = 0; + netdev_for_each_mc_addr(mc_entry, soft_iface) { + memcpy(&mc_addr_list[pos * ETH_ALEN], mc_entry->MC_LIST_ADDR, + ETH_ALEN); + pos++; + } + netif_addr_unlock_bh(soft_iface); + + if (num_mcast_entries > UINT8_MAX) + num_mcast_entries = UINT8_MAX; + dest_entries_list = kmalloc(num_mcast_entries * + sizeof(struct list_head), GFP_ATOMIC); + if (!dest_entries_list) + goto free; + + for (pos = 0; pos < num_mcast_entries; pos++) + INIT_LIST_HEAD(&dest_entries_list[pos]); + + /* fill the lists and buffers */ + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(bucket, walk, head, hlist) { + orig_node = bucket->data; + if (!orig_node->num_mca) + continue; + + num_dest_entries = 0; + for (mca_pos = 0; mca_pos < orig_node->num_mca && + dest_entries_total != UINT8_MAX; mca_pos++) { + pos = find_mca_match(orig_node, mca_pos, + mc_addr_list, num_mcast_entries); + if (pos > UINT8_MAX || pos < 0) + continue; + memcpy(dest_entries[dest_entries_total].dest, + orig_node->orig, ETH_ALEN); + list_add( + &dest_entries[dest_entries_total].list, + &dest_entries_list[pos]); + + num_dest_entries++; + dest_entries_total++; + } + } + rcu_read_unlock(); + } + + /* Any list left empty? */ + for (pos = 0; pos < num_mcast_entries; pos++) + if (!list_empty(&dest_entries_list[pos])) + used_mcast_entries++; + + if (!used_mcast_entries) + goto free_all; + + /* prepare tracker packet, finally! */ + *tracker_packet_len = sizeof(struct mcast_tracker_packet) + + used_mcast_entries * sizeof(struct mcast_entry) + + ETH_ALEN * dest_entries_total; + if (*tracker_packet_len > ETH_DATA_LEN) { + pr_warning("mcast tracker packet got too large (%i Bytes), " + "forcing reduced size of %i Bytes\n", + *tracker_packet_len, ETH_DATA_LEN); + *tracker_packet_len = ETH_DATA_LEN; + } + tracker_packet = kmalloc(*tracker_packet_len, GFP_ATOMIC); + + tracker_packet->packet_type = BAT_MCAST_TRACKER; + tracker_packet->version = COMPAT_VERSION; + memcpy(tracker_packet->orig, bat_priv->primary_if->net_dev->dev_addr, + ETH_ALEN); + tracker_packet->ttl = TTL; + tracker_packet->num_mcast_entries = (used_mcast_entries > UINT8_MAX) ? + UINT8_MAX : used_mcast_entries; + memset(tracker_packet->align, 0, sizeof(tracker_packet->align)); + + /* append all collected entries */ + mcast_entry = (struct mcast_entry *)(tracker_packet + 1); + for (pos = 0; pos < num_mcast_entries; pos++) { + if (list_empty(&dest_entries_list[pos])) + continue; + + if ((char *)(mcast_entry + 1) <= + (char *)tracker_packet + ETH_DATA_LEN) { + memcpy(mcast_entry->mcast_addr, + &mc_addr_list[pos*ETH_ALEN], ETH_ALEN); + mcast_entry->num_dest = 0; + } + + dest_entry = (uint8_t *)(mcast_entry + 1); + list_for_each_entry_safe(dest, tmp, &dest_entries_list[pos], + list) { + /* still place for a dest_entry left? + * watch out for overflow here, stop at UINT8_MAX */ + if ((char *)dest_entry + ETH_ALEN <= + (char *)tracker_packet + ETH_DATA_LEN && + mcast_entry->num_dest != UINT8_MAX) { + mcast_entry->num_dest++; + memcpy(dest_entry, dest->dest, ETH_ALEN); + dest_entry += ETH_ALEN; + } + list_del(&dest->list); + } + /* still space for another mcast_entry left? */ + if ((char *)(mcast_entry + 1) <= + (char *)tracker_packet + ETH_DATA_LEN) + mcast_entry = (struct mcast_entry *)dest_entry; + } + + + /* outstanding cleanup */ +free_all: + kfree(dest_entries_list); +free: + kfree(mc_addr_list); +out: + + return tracker_packet; +} + +/* Adds the router for the destination address to the next_hop list and its + * interface to the forw_if_list - but only if this router has not been + * added yet */ +static int add_router_of_dest(struct dest_entries_list *next_hops, + uint8_t *dest, struct bat_priv *bat_priv) +{ + struct dest_entries_list *next_hop_tmp, *next_hop_entry; + struct element_t *bucket; + struct orig_node *orig_node; + struct hashtable_t *hash = bat_priv->orig_hash; + struct hlist_node *walk; + struct hlist_head *head; + int i; + + next_hop_entry = kmalloc(sizeof(struct dest_entries_list), GFP_ATOMIC); + if (!next_hop_entry) + return 1; + + next_hop_entry->batman_if = NULL; + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(bucket, walk, head, hlist) { + orig_node = bucket->data; + + if (memcmp(orig_node->orig, dest, ETH_ALEN)) + continue; + + if (!orig_node->router) { + i = hash->size; + break; + } + + memcpy(next_hop_entry->dest, orig_node->router->addr, + ETH_ALEN); + next_hop_entry->batman_if = + orig_node->router->if_incoming; + i = hash->size; + break; + } + rcu_read_unlock(); + } + if (!next_hop_entry->batman_if) + goto free; + + list_for_each_entry(next_hop_tmp, &next_hops->list, list) + if (!memcmp(next_hop_tmp->dest, next_hop_entry->dest, + ETH_ALEN)) + goto free; + + list_add(&next_hop_entry->list, &next_hops->list); + + return 0; + +free: + kfree(next_hop_entry); + return 1; +} + +/* Collect nexthops for all dest entries specified in this tracker packet */ +static int tracker_next_hops(struct mcast_tracker_packet *tracker_packet, + struct dest_entries_list *next_hops, + struct bat_priv *bat_priv) +{ + int num_next_hops = 0, ret; + struct tracker_packet_state state; + + INIT_LIST_HEAD(&next_hops->list); + + tracker_packet_for_each_dest(&state, tracker_packet) { + ret = add_router_of_dest(next_hops, state.dest_entry, + bat_priv); + if (!ret) + num_next_hops++; + } + + return num_next_hops; +} + +static void zero_tracker_packet(struct mcast_tracker_packet *tracker_packet, + uint8_t *next_hop, struct bat_priv *bat_priv) +{ + struct tracker_packet_state state; + + struct element_t *bucket; + struct orig_node *orig_node; + struct hashtable_t *hash = bat_priv->orig_hash; + struct hlist_node *walk; + struct hlist_head *head; + int i; + + tracker_packet_for_each_dest(&state, tracker_packet) { + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(bucket, walk, head, hlist) { + orig_node = bucket->data; + + if (memcmp(orig_node->orig, state.dest_entry, + ETH_ALEN)) + continue; + + /* is the next hop already our destination? */ + if (!memcmp(orig_node->orig, next_hop, + ETH_ALEN)) + memset(state.dest_entry, '\0', + ETH_ALEN); + else if (!orig_node->router) + memset(state.dest_entry, '\0', + ETH_ALEN); + else if (!memcmp(orig_node->orig, + orig_node->router->orig_node-> + primary_addr, ETH_ALEN)) + memset(state.dest_entry, '\0', + ETH_ALEN); + /* is this the wrong next hop for our + * destination? */ + else if (memcmp(orig_node->router->addr, + next_hop, ETH_ALEN)) + memset(state.dest_entry, '\0', + ETH_ALEN); + + i = hash->size; + break; + } + rcu_read_unlock(); + } + } +} + +static int shrink_tracker_packet(struct mcast_tracker_packet *tracker_packet, + int tracker_packet_len) +{ + struct tracker_packet_state state; + uint8_t *tail = (uint8_t *)tracker_packet + tracker_packet_len; + int new_tracker_packet_len = sizeof(struct mcast_tracker_packet); + + tracker_packet_for_each_dest(&state, tracker_packet) { + if (memcmp(state.dest_entry, "\0\0\0\0\0\0", ETH_ALEN)) { + new_tracker_packet_len += ETH_ALEN; + continue; + } + + memmove(state.dest_entry, state.dest_entry + ETH_ALEN, + tail - state.dest_entry - ETH_ALEN); + + state.mcast_entry->num_dest--; + tail -= ETH_ALEN; + + if (state.mcast_entry->num_dest) { + state.dest_num--; + state.dest_entry -= ETH_ALEN; + continue; + } + + /* = mcast_entry */ + state.dest_entry -= sizeof(struct mcast_entry); + + memmove(state.dest_entry, state.dest_entry + + sizeof(struct mcast_entry), + tail - state.dest_entry - sizeof(struct mcast_entry)); + + tracker_packet->num_mcast_entries--; + tail -= sizeof(struct mcast_entry); + + state.mcast_num--; + + /* Avoid mcast_entry check of tracker_packet_for_each_dest's + * inner loop */ + state.break_flag = 0; + break; + } + + new_tracker_packet_len += sizeof(struct mcast_entry) * + tracker_packet->num_mcast_entries; + + return new_tracker_packet_len; +} + +static struct sk_buff *build_tracker_packet_skb( + struct mcast_tracker_packet *tracker_packet, + int tracker_packet_len, uint8_t *dest) +{ + struct sk_buff *skb; + struct mcast_tracker_packet *skb_tracker_data; + + skb = dev_alloc_skb(tracker_packet_len + sizeof(struct ethhdr)); + if (!skb) + return NULL; + + skb_reserve(skb, sizeof(struct ethhdr)); + skb_tracker_data = (struct mcast_tracker_packet *) + skb_put(skb, tracker_packet_len); + + memcpy(skb_tracker_data, tracker_packet, tracker_packet_len); + + return skb; +} + + +/** + * Sends (splitted parts of) a multicast tracker packet on the according + * interfaces. + * + * @tracker_packet: A compact multicast tracker packet with all groups and + * destinations attached. + */ +void route_mcast_tracker_packet( + struct mcast_tracker_packet *tracker_packet, + int tracker_packet_len, struct bat_priv *bat_priv) +{ + struct dest_entries_list next_hops, *tmp; + struct mcast_tracker_packet *next_hop_tracker_packets, + *next_hop_tracker_packet; + struct dest_entries_list *next_hop; + struct sk_buff *skb; + int num_next_hops, i; + int *tracker_packet_lengths; + + rcu_read_lock(); + num_next_hops = tracker_next_hops(tracker_packet, &next_hops, + bat_priv); + if (!num_next_hops) + goto out; + next_hop_tracker_packets = kmalloc(tracker_packet_len * num_next_hops, + GFP_ATOMIC); + if (!next_hop_tracker_packets) + goto free; + + tracker_packet_lengths = kmalloc(num_next_hops * sizeof(int), + GFP_ATOMIC); + if (!tracker_packet_lengths) + goto free2; + + i = 0; + list_for_each_entry_safe(next_hop, tmp, &next_hops.list, list) { + next_hop_tracker_packet = (struct mcast_tracker_packet *) + ((char *)next_hop_tracker_packets + + i * tracker_packet_len); + memcpy(next_hop_tracker_packet, tracker_packet, + tracker_packet_len); + zero_tracker_packet(next_hop_tracker_packet, next_hop->dest, + bat_priv); + tracker_packet_lengths[i] = shrink_tracker_packet( + next_hop_tracker_packet, tracker_packet_len); + i++; + } + + i = 0; + /* Add ethernet header, send 'em! */ + list_for_each_entry_safe(next_hop, tmp, &next_hops.list, list) { + if (tracker_packet_lengths[i] == + sizeof(struct mcast_tracker_packet)) + goto skip_send; + + skb = build_tracker_packet_skb(&next_hop_tracker_packets[i], + tracker_packet_lengths[i], + next_hop->dest); + if (skb) + send_skb_packet(skb, next_hop->batman_if, + next_hop->dest); +skip_send: + list_del(&next_hop->list); + kfree(next_hop); + i++; + } + + kfree(tracker_packet_lengths); + kfree(next_hop_tracker_packets); + return; + +free2: + kfree(next_hop_tracker_packets); +free: + list_for_each_entry_safe(next_hop, tmp, &next_hops.list, list) { + list_del(&next_hop->list); + kfree(next_hop); + } +out: + rcu_read_unlock(); +} + static void mcast_tracker_timer(struct work_struct *work) { struct bat_priv *bat_priv = container_of(work, struct bat_priv, mcast_tracker_work.work); + struct mcast_tracker_packet *tracker_packet = NULL; + int tracker_packet_len = 0;

+ if (atomic_read(&bat_priv->mcast_mode) == MCAST_MODE_PROACT_TRACKING) + tracker_packet = mcast_proact_tracker_prepare(bat_priv, + &tracker_packet_len); + + if (!tracker_packet) + goto out; + + route_mcast_tracker_packet(tracker_packet, tracker_packet_len, + bat_priv); + kfree(tracker_packet); + +out: start_mcast_tracker(bat_priv); }

diff --git a/batman-adv/multicast.h b/batman-adv/multicast.h index 26ce6d8..2711d8b 100644 --- a/batman-adv/multicast.h +++ b/batman-adv/multicast.h @@ -27,6 +27,9 @@ int mcast_tracker_interval_set(struct net_device *net_dev, char *buff, int mcast_tracker_timeout_set(struct net_device *net_dev, char *buff, size_t count); void mcast_tracker_reset(struct bat_priv *bat_priv); +void route_mcast_tracker_packet( + struct mcast_tracker_packet *tracker_packet, + int tracker_packet_len, struct bat_priv *bat_priv); int mcast_init(struct bat_priv *bat_priv); void mcast_free(struct bat_priv *bat_priv);

Before/while a tracker packet is being searched for next hops for its destination entries, it will also be checked if the number of destination and mcast entries might exceed the tracker_packet_len. Otherwise we might read/write in unallocated memory. Such a broken tracker packet could potentially occure when we are going to reuse route_mcast_tracker_packet for tracker packets received from a neighbour node.

In such a case, we are just reducing the stated mcast / dest numbers in the tracker packet to fit the size of the allocated buffer.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- multicast.c | 27 ++++++++++++++++++++++++--- 1 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/batman-adv/multicast.c b/batman-adv/multicast.c index 34e89a8..c06035f 100644 --- a/batman-adv/multicast.c +++ b/batman-adv/multicast.c @@ -366,17 +366,38 @@ free: return 1; }

-/* Collect nexthops for all dest entries specified in this tracker packet */ +/* Collect nexthops for all dest entries specified in this tracker packet. + * It also reduces the number of elements in the tracker packet if they exceed + * the buffers length (e.g. because of a received, broken tracker packet) to + * avoid writing in unallocated memory. */ static int tracker_next_hops(struct mcast_tracker_packet *tracker_packet, + int tracker_packet_len, struct dest_entries_list *next_hops, struct bat_priv *bat_priv) { int num_next_hops = 0, ret; struct tracker_packet_state state; + uint8_t *tail = (uint8_t *)tracker_packet + tracker_packet_len;

INIT_LIST_HEAD(&next_hops->list);

tracker_packet_for_each_dest(&state, tracker_packet) { + /* avoid writing outside of unallocated memory later */ + if (state.dest_entry + ETH_ALEN > tail) { + bat_dbg(DBG_BATMAN, bat_priv, + "mcast tracker packet is broken, too many " + "entries claimed for its length, repairing"); + + tracker_packet->num_mcast_entries = state.mcast_num; + + if (state.dest_num) { + tracker_packet->num_mcast_entries++; + state.mcast_entry->num_dest = state.dest_num; + } + + break; + } + ret = add_router_of_dest(next_hops, state.dest_entry, bat_priv); if (!ret) @@ -528,8 +549,8 @@ void route_mcast_tracker_packet( int *tracker_packet_lengths;

rcu_read_lock(); - num_next_hops = tracker_next_hops(tracker_packet, &next_hops, - bat_priv); + num_next_hops = tracker_next_hops(tracker_packet, tracker_packet_len, + &next_hops, bat_priv); if (!num_next_hops) goto out; next_hop_tracker_packets = kmalloc(tracker_packet_len * num_next_hops,

On reception of a multicast tracker packet (both locally generated or received over an interface), a node now memorizes its forwarding state for a tuple of multicast-group, originator, and next-hops (+ their according outgoing interface).

The first two elements are necessary to determine, whether a node shall forward a multicast data packet on reception later. The next-hop and according interface information is necessary to quickly determine, if a multicast data packet shall be forwarded via unicast to each single next hop or via broadcast.

This commit does not yet purge multicast forwarding table entries after the set tracker timeout yet.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- multicast.c | 277 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- types.h | 2 + 2 files changed, 276 insertions(+), 3 deletions(-)

diff --git a/batman-adv/multicast.c b/batman-adv/multicast.c index c06035f..bef3972 100644 --- a/batman-adv/multicast.c +++ b/batman-adv/multicast.c @@ -25,6 +25,10 @@ #include "send.h" #include "compat.h"

+/* If auto mode for tracker timeout has been selected, + * how many times of tracker_interval to wait */ +#define TRACKER_TIMEOUT_AUTO_X 5 + struct tracker_packet_state { int mcast_num, dest_num; struct mcast_entry *mcast_entry; @@ -92,6 +96,34 @@ struct dest_entries_list { struct batman_if *batman_if; };

+ +struct mcast_forw_nexthop_entry { + struct list_head list; + uint8_t neigh_addr[6]; + unsigned long timeout; /* old jiffies value */ +}; + +struct mcast_forw_if_entry { + struct list_head list; + int16_t if_num; + int num_nexthops; + struct list_head mcast_nexthop_list; +}; + +struct mcast_forw_orig_entry { + struct list_head list; + uint8_t orig[6]; + uint32_t last_mcast_seqno; + unsigned long mcast_bits[NUM_WORDS]; + struct list_head mcast_if_list; +}; + +struct mcast_forw_table_entry { + struct list_head list; + uint8_t mcast_addr[6]; + struct list_head mcast_orig_list; +}; + /* how long to wait until sending a multicast tracker packet */ static int tracker_send_delay(struct bat_priv *bat_priv) { @@ -126,6 +158,217 @@ void mcast_tracker_reset(struct bat_priv *bat_priv) start_mcast_tracker(bat_priv); }

+static void prepare_forw_if_entry(struct list_head *forw_if_list, + int16_t if_num, uint8_t *neigh_addr) +{ + struct mcast_forw_if_entry *forw_if_entry; + struct mcast_forw_nexthop_entry *forw_nexthop_entry; + + list_for_each_entry(forw_if_entry, forw_if_list, list) + if (forw_if_entry->if_num == if_num) + goto skip_create_if; + + forw_if_entry = kmalloc(sizeof(struct mcast_forw_if_entry), + GFP_ATOMIC); + if (!forw_if_entry) + return; + + forw_if_entry->if_num = if_num; + forw_if_entry->num_nexthops = 0; + INIT_LIST_HEAD(&forw_if_entry->mcast_nexthop_list); + list_add(&forw_if_entry->list, forw_if_list); + +skip_create_if: + list_for_each_entry(forw_nexthop_entry, + &forw_if_entry->mcast_nexthop_list, list) { + if (!memcmp(forw_nexthop_entry->neigh_addr, + neigh_addr, ETH_ALEN)) + return; + } + + forw_nexthop_entry = kmalloc(sizeof(struct mcast_forw_nexthop_entry), + GFP_ATOMIC); + if (!forw_nexthop_entry && forw_if_entry->num_nexthops) + return; + else if (!forw_nexthop_entry) + goto free; + + memcpy(forw_nexthop_entry->neigh_addr, neigh_addr, ETH_ALEN); + forw_if_entry->num_nexthops++; + if (forw_if_entry->num_nexthops < 0) { + kfree(forw_nexthop_entry); + goto free; + } + + list_add(&forw_nexthop_entry->list, + &forw_if_entry->mcast_nexthop_list); + return; +free: + list_del(&forw_if_entry->list); + kfree(forw_if_entry); +} + +static struct list_head *prepare_forw_table_entry( + struct mcast_forw_table_entry *forw_table, + uint8_t *mcast_addr, uint8_t *orig) +{ + struct mcast_forw_table_entry *forw_table_entry; + struct mcast_forw_orig_entry *orig_entry; + + forw_table_entry = kmalloc(sizeof(struct mcast_forw_table_entry), + GFP_ATOMIC); + if (!forw_table_entry) + return NULL; + + memcpy(forw_table_entry->mcast_addr, mcast_addr, ETH_ALEN); + list_add(&forw_table_entry->list, &forw_table->list); + + INIT_LIST_HEAD(&forw_table_entry->mcast_orig_list); + orig_entry = kmalloc(sizeof(struct mcast_forw_orig_entry), GFP_ATOMIC); + if (!orig_entry) + goto free; + + memcpy(orig_entry->orig, orig, ETH_ALEN); + INIT_LIST_HEAD(&orig_entry->mcast_if_list); + list_add(&orig_entry->list, &forw_table_entry->mcast_orig_list); + + return &orig_entry->mcast_if_list; + +free: + list_del(&forw_table_entry->list); + kfree(forw_table_entry); + return NULL; +} + +static int sync_nexthop(struct mcast_forw_nexthop_entry *sync_nexthop_entry, + struct list_head *nexthop_list) +{ + struct mcast_forw_nexthop_entry *nexthop_entry; + int synced = 0; + + list_for_each_entry(nexthop_entry, nexthop_list, list) { + if (memcmp(sync_nexthop_entry->neigh_addr, + nexthop_entry->neigh_addr, ETH_ALEN)) + continue; + + nexthop_entry->timeout = jiffies; + list_del(&sync_nexthop_entry->list); + kfree(sync_nexthop_entry); + + synced = 1; + break; + } + + if (!synced) { + sync_nexthop_entry->timeout = jiffies; + list_move(&sync_nexthop_entry->list, nexthop_list); + return 1; + } + + return 0; +} + +static void sync_if(struct mcast_forw_if_entry *sync_if_entry, + struct list_head *if_list) +{ + struct mcast_forw_if_entry *if_entry; + struct mcast_forw_nexthop_entry *sync_nexthop_entry, *tmp; + int synced = 0; + + list_for_each_entry(if_entry, if_list, list) { + if (sync_if_entry->if_num != if_entry->if_num) + continue; + + list_for_each_entry_safe(sync_nexthop_entry, tmp, + &sync_if_entry->mcast_nexthop_list, list) + if (sync_nexthop(sync_nexthop_entry, + &if_entry->mcast_nexthop_list)) + if_entry->num_nexthops++; + + list_del(&sync_if_entry->list); + kfree(sync_if_entry); + + synced = 1; + break; + } + + if (!synced) + list_move(&sync_if_entry->list, if_list); +} + +/* syncs all multicast entries of sync_table_entry to forw_table */ +static void sync_orig(struct mcast_forw_orig_entry *sync_orig_entry, + struct list_head *orig_list) +{ + struct mcast_forw_orig_entry *orig_entry; + struct mcast_forw_if_entry *sync_if_entry, *tmp; + int synced = 0; + + list_for_each_entry(orig_entry, orig_list, list) { + if (memcmp(sync_orig_entry->orig, + orig_entry->orig, ETH_ALEN)) + continue; + + list_for_each_entry_safe(sync_if_entry, tmp, + &sync_orig_entry->mcast_if_list, list) + sync_if(sync_if_entry, &orig_entry->mcast_if_list); + + list_del(&sync_orig_entry->list); + kfree(sync_orig_entry); + + synced = 1; + break; + } + + if (!synced) + list_move(&sync_orig_entry->list, orig_list); +} + + +/* syncs all multicast entries of sync_table_entry to forw_table */ +static void sync_table(struct mcast_forw_table_entry *sync_table_entry, + struct list_head *forw_table) +{ + struct mcast_forw_table_entry *table_entry; + struct mcast_forw_orig_entry *sync_orig_entry, *tmp; + int synced = 0; + + list_for_each_entry(table_entry, forw_table, list) { + if (memcmp(sync_table_entry->mcast_addr, + table_entry->mcast_addr, ETH_ALEN)) + continue; + + list_for_each_entry_safe(sync_orig_entry, tmp, + &sync_table_entry->mcast_orig_list, list) + sync_orig(sync_orig_entry, + &table_entry->mcast_orig_list); + + list_del(&sync_table_entry->list); + kfree(sync_table_entry); + + synced = 1; + break; + } + + if (!synced) + list_move(&sync_table_entry->list, forw_table); +} + +/* Updates the old multicast forwarding table with the information gained + * from the generated/received tracker packet. It also frees the generated + * table for syncing (*forw_table). */ +static void update_mcast_forw_table(struct mcast_forw_table_entry *forw_table, + struct bat_priv *bat_priv) +{ + struct mcast_forw_table_entry *sync_table_entry, *tmp; + + spin_lock_bh(&bat_priv->mcast_forw_table_lock); + list_for_each_entry_safe(sync_table_entry, tmp, &forw_table->list, + list) + sync_table(sync_table_entry, &bat_priv->mcast_forw_table); + spin_unlock_bh(&bat_priv->mcast_forw_table_lock); +} + static inline int find_mca_match(struct orig_node *orig_node, int mca_pos, uint8_t *mc_addr_list, int num_mcast_entries) { @@ -310,9 +553,12 @@ out: * interface to the forw_if_list - but only if this router has not been * added yet */ static int add_router_of_dest(struct dest_entries_list *next_hops, - uint8_t *dest, struct bat_priv *bat_priv) + uint8_t *dest, + struct list_head *forw_if_list, + struct bat_priv *bat_priv) { struct dest_entries_list *next_hop_tmp, *next_hop_entry; + int16_t if_num; struct element_t *bucket; struct orig_node *orig_node; struct hashtable_t *hash = bat_priv->orig_hash; @@ -344,6 +590,7 @@ static int add_router_of_dest(struct dest_entries_list *next_hops, ETH_ALEN); next_hop_entry->batman_if = orig_node->router->if_incoming; + if_num = next_hop_entry->batman_if->if_num; i = hash->size; break; } @@ -352,6 +599,10 @@ static int add_router_of_dest(struct dest_entries_list *next_hops, if (!next_hop_entry->batman_if) goto free;

+ if (forw_if_list) + prepare_forw_if_entry(forw_if_list, if_num, + next_hop_entry->dest); + list_for_each_entry(next_hop_tmp, &next_hops->list, list) if (!memcmp(next_hop_tmp->dest, next_hop_entry->dest, ETH_ALEN)) @@ -373,13 +624,16 @@ free: static int tracker_next_hops(struct mcast_tracker_packet *tracker_packet, int tracker_packet_len, struct dest_entries_list *next_hops, + struct mcast_forw_table_entry *forw_table, struct bat_priv *bat_priv) { int num_next_hops = 0, ret; struct tracker_packet_state state; uint8_t *tail = (uint8_t *)tracker_packet + tracker_packet_len; + struct list_head *forw_table_if = NULL;

INIT_LIST_HEAD(&next_hops->list); + INIT_LIST_HEAD(&forw_table->list);

tracker_packet_for_each_dest(&state, tracker_packet) { /* avoid writing outside of unallocated memory later */ @@ -398,8 +652,15 @@ static int tracker_next_hops(struct mcast_tracker_packet *tracker_packet, break; }

+ if (state.dest_num) + goto skip; + + forw_table_if = prepare_forw_table_entry(forw_table, + state.mcast_entry->mcast_addr, + tracker_packet->orig); +skip: ret = add_router_of_dest(next_hops, state.dest_entry, - bat_priv); + forw_table_if, bat_priv); if (!ret) num_next_hops++; } @@ -407,6 +668,8 @@ static int tracker_next_hops(struct mcast_tracker_packet *tracker_packet, return num_next_hops; }

+/* Zero destination entries not destined for the specified next hop in the + * tracker packet */ static void zero_tracker_packet(struct mcast_tracker_packet *tracker_packet, uint8_t *next_hop, struct bat_priv *bat_priv) { @@ -459,6 +722,8 @@ static void zero_tracker_packet(struct mcast_tracker_packet *tracker_packet, } }

+/* Remove zeroed destination entries and empty multicast entries in tracker + * packet */ static int shrink_tracker_packet(struct mcast_tracker_packet *tracker_packet, int tracker_packet_len) { @@ -544,15 +809,19 @@ void route_mcast_tracker_packet( struct mcast_tracker_packet *next_hop_tracker_packets, *next_hop_tracker_packet; struct dest_entries_list *next_hop; + struct mcast_forw_table_entry forw_table; struct sk_buff *skb; int num_next_hops, i; int *tracker_packet_lengths;

rcu_read_lock(); num_next_hops = tracker_next_hops(tracker_packet, tracker_packet_len, - &next_hops, bat_priv); + &next_hops, &forw_table, bat_priv); if (!num_next_hops) goto out; + + update_mcast_forw_table(&forw_table, bat_priv); + next_hop_tracker_packets = kmalloc(tracker_packet_len * num_next_hops, GFP_ATOMIC); if (!next_hop_tracker_packets) @@ -736,6 +1005,8 @@ ok: int mcast_init(struct bat_priv *bat_priv) { INIT_DELAYED_WORK(&bat_priv->mcast_tracker_work, mcast_tracker_timer); + INIT_LIST_HEAD(&bat_priv->mcast_forw_table); + start_mcast_tracker(bat_priv);

return 1; diff --git a/batman-adv/types.h b/batman-adv/types.h index 675a50f..75adec9 100644 --- a/batman-adv/types.h +++ b/batman-adv/types.h @@ -158,6 +158,7 @@ struct bat_priv { struct hlist_head forw_bcast_list; struct hlist_head gw_list; struct list_head vis_send_list; + struct list_head mcast_forw_table; struct hashtable_t *orig_hash; struct hashtable_t *hna_local_hash; struct hashtable_t *hna_global_hash; @@ -170,6 +171,7 @@ struct bat_priv { spinlock_t vis_hash_lock; /* protects vis_hash */ spinlock_t vis_list_lock; /* protects vis_info::recv_list */ spinlock_t softif_neigh_lock; /* protects soft-interface neigh list */ + spinlock_t mcast_forw_table_lock; /* protects mcast_forw_table */ int16_t num_local_hna; atomic_t hna_local_changed; struct delayed_work hna_work;

With this commit the full multicast forwarding table, which is used for determining whether to forward a multicast data packet or not, can now be displayed via mcast_forw_table in BATMAN's debugfs directory.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- bat_debugfs.c | 9 ++++++ multicast.c | 82 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ multicast.h | 1 + 3 files changed, 92 insertions(+), 0 deletions(-)

diff --git a/batman-adv/bat_debugfs.c b/batman-adv/bat_debugfs.c index 0ae81d0..7b1b57d 100644 --- a/batman-adv/bat_debugfs.c +++ b/batman-adv/bat_debugfs.c @@ -32,6 +32,7 @@ #include "soft-interface.h" #include "vis.h" #include "icmp_socket.h" +#include "multicast.h"

static struct dentry *bat_debugfs;

@@ -252,6 +253,12 @@ static int transtable_local_open(struct inode *inode, struct file *file) return single_open(file, hna_local_seq_print_text, net_dev); }

+static int mcast_forw_table_open(struct inode *inode, struct file *file) +{ + struct net_device *net_dev = (struct net_device *)inode->i_private; + return single_open(file, mcast_forw_table_seq_print_text, net_dev); +} + static int vis_data_open(struct inode *inode, struct file *file) { struct net_device *net_dev = (struct net_device *)inode->i_private; @@ -280,6 +287,7 @@ static BAT_DEBUGINFO(gateways, S_IRUGO, gateways_open); static BAT_DEBUGINFO(softif_neigh, S_IRUGO, softif_neigh_open); static BAT_DEBUGINFO(transtable_global, S_IRUGO, transtable_global_open); static BAT_DEBUGINFO(transtable_local, S_IRUGO, transtable_local_open); +static BAT_DEBUGINFO(mcast_forw_table, S_IRUGO, mcast_forw_table_open); static BAT_DEBUGINFO(vis_data, S_IRUGO, vis_data_open);

static struct bat_debuginfo *mesh_debuginfos[] = { @@ -288,6 +296,7 @@ static struct bat_debuginfo *mesh_debuginfos[] = { &bat_debuginfo_softif_neigh, &bat_debuginfo_transtable_global, &bat_debuginfo_transtable_local, + &bat_debuginfo_mcast_forw_table, &bat_debuginfo_vis_data, NULL, }; diff --git a/batman-adv/multicast.c b/batman-adv/multicast.c index bef3972..686e10b 100644 --- a/batman-adv/multicast.c +++ b/batman-adv/multicast.c @@ -158,6 +158,24 @@ void mcast_tracker_reset(struct bat_priv *bat_priv) start_mcast_tracker(bat_priv); }

+static inline int get_remaining_timeout( + struct mcast_forw_nexthop_entry *nexthop_entry, + struct bat_priv *bat_priv) +{ + int tracker_timeout = atomic_read(&bat_priv->mcast_tracker_timeout); + if (!tracker_timeout) + tracker_timeout = atomic_read(&bat_priv->mcast_tracker_interval) + * TRACKER_TIMEOUT_AUTO_X; + if (!tracker_timeout) + tracker_timeout = atomic_read(&bat_priv->orig_interval) + * TRACKER_TIMEOUT_AUTO_X / 2; + + tracker_timeout = jiffies_to_msecs(nexthop_entry->timeout) + + tracker_timeout - jiffies_to_msecs(jiffies); + + return (tracker_timeout > 0 ? tracker_timeout : 0); +} + static void prepare_forw_if_entry(struct list_head *forw_if_list, int16_t if_num, uint8_t *neigh_addr) { @@ -1002,6 +1020,70 @@ ok: return count; }

+static inline struct batman_if *if_num_to_batman_if(int16_t if_num) +{ + struct batman_if *batman_if; + + list_for_each_entry_rcu(batman_if, &if_list, list) + if (batman_if->if_num == if_num) + return batman_if; + + return NULL; +} + +int mcast_forw_table_seq_print_text(struct seq_file *seq, void *offset) +{ + struct net_device *net_dev = (struct net_device *)seq->private; + struct bat_priv *bat_priv = netdev_priv(net_dev); + struct batman_if *batman_if; + struct mcast_forw_table_entry *table_entry; + struct mcast_forw_orig_entry *orig_entry; + struct mcast_forw_if_entry *if_entry; + struct mcast_forw_nexthop_entry *nexthop_entry; + + seq_printf(seq, "[B.A.T.M.A.N. adv %s%s, MainIF/MAC: %s/%pM (%s)]\n", + SOURCE_VERSION, REVISION_VERSION_STR, + bat_priv->primary_if->net_dev->name, + bat_priv->primary_if->net_dev->dev_addr, net_dev->name); + seq_printf(seq, "Multicast group MAC\tOriginator\t" + "Outgoing interface\tNexthop - timeout in msecs\n"); + + rcu_read_lock(); + spin_lock_bh(&bat_priv->mcast_forw_table_lock); + list_for_each_entry(table_entry, &bat_priv->mcast_forw_table, list) { + seq_printf(seq, "%pM\n", table_entry->mcast_addr); + + list_for_each_entry(orig_entry, &table_entry->mcast_orig_list, + list) { + seq_printf(seq, "\t%pM\n", orig_entry->orig); + + list_for_each_entry(if_entry, + &orig_entry->mcast_if_list, list) { + batman_if = + if_num_to_batman_if(if_entry->if_num); + if (!batman_if) + continue; + + seq_printf(seq, "\t\t%s\n", + batman_if->net_dev->name); + + list_for_each_entry(nexthop_entry, + &if_entry->mcast_nexthop_list, + list) { + seq_printf(seq, "\t\t\t%pM - %i\n", + nexthop_entry->neigh_addr, + get_remaining_timeout( + nexthop_entry, bat_priv)); + } + } + } + } + spin_unlock_bh(&bat_priv->mcast_forw_table_lock); + rcu_read_unlock(); + + return 0; +} + int mcast_init(struct bat_priv *bat_priv) { INIT_DELAYED_WORK(&bat_priv->mcast_tracker_work, mcast_tracker_timer); diff --git a/batman-adv/multicast.h b/batman-adv/multicast.h index 2711d8b..0bd0590 100644 --- a/batman-adv/multicast.h +++ b/batman-adv/multicast.h @@ -30,6 +30,7 @@ void mcast_tracker_reset(struct bat_priv *bat_priv); void route_mcast_tracker_packet( struct mcast_tracker_packet *tracker_packet, int tracker_packet_len, struct bat_priv *bat_priv); +int mcast_forw_table_seq_print_text(struct seq_file *seq, void *offset); int mcast_init(struct bat_priv *bat_priv); void mcast_free(struct bat_priv *bat_priv);

This patch adds the capability to encapsulate and send a node's own multicast data packets. Based on the previously established multicast forwarding table, the sender can decide wheather it actually has to send the multicast data to one or more of its interfaces or not.

Furthermore, the sending procedure also decides whether to broadcast or unicast a multicast data packet to its next-hops, depending on the configured mcast_fanout (default: < 3 next hops on an interface, send seperate unicast packets).

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- multicast.c | 163 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ multicast.h | 1 + soft-interface.c | 27 ++++++++- types.h | 1 + 4 files changed, 188 insertions(+), 4 deletions(-)

diff --git a/batman-adv/multicast.c b/batman-adv/multicast.c index e47cc56..a8613ef 100644 --- a/batman-adv/multicast.c +++ b/batman-adv/multicast.c @@ -23,6 +23,8 @@ #include "multicast.h" #include "hash.h" #include "send.h" +#include "soft-interface.h" +#include "hard-interface.h" #include "compat.h"

/* If auto mode for tracker timeout has been selected, @@ -1154,6 +1156,167 @@ int mcast_forw_table_seq_print_text(struct seq_file *seq, void *offset) return 0; }

+static inline void nexthops_from_if_list(struct list_head *mcast_if_list, + struct list_head *nexthop_list, + struct bat_priv *bat_priv) +{ + struct batman_if *batman_if; + struct mcast_forw_if_entry *if_entry; + struct mcast_forw_nexthop_entry *nexthop_entry; + struct dest_entries_list *dest_entry; + int mcast_fanout = atomic_read(&bat_priv->mcast_fanout); + + list_for_each_entry(if_entry, mcast_if_list, list) { + rcu_read_lock(); + batman_if = if_num_to_batman_if(if_entry->if_num); + if (!batman_if) { + rcu_read_unlock(); + continue; + } + + kref_get(&batman_if->refcount); + rcu_read_unlock(); + + + /* send via broadcast */ + if (if_entry->num_nexthops > mcast_fanout) { + dest_entry = kmalloc(sizeof(struct dest_entries_list), + GFP_ATOMIC); + memcpy(dest_entry->dest, broadcast_addr, ETH_ALEN); + dest_entry->batman_if = batman_if; + list_add(&dest_entry->list, nexthop_list); + continue; + } + + /* send separate unicast packets */ + list_for_each_entry(nexthop_entry, + &if_entry->mcast_nexthop_list, list) { + if (!get_remaining_timeout(nexthop_entry, bat_priv)) + continue; + + dest_entry = kmalloc(sizeof(struct dest_entries_list), + GFP_ATOMIC); + memcpy(dest_entry->dest, nexthop_entry->neigh_addr, + ETH_ALEN); + + kref_get(&batman_if->refcount); + dest_entry->batman_if = batman_if; + list_add(&dest_entry->list, nexthop_list); + } + kref_put(&batman_if->refcount, hardif_free_ref); + } +} + +static inline void nexthops_from_orig_list(uint8_t *orig, + struct list_head *mcast_orig_list, + struct list_head *nexthop_list, + struct bat_priv *bat_priv) +{ + struct mcast_forw_orig_entry *orig_entry; + + list_for_each_entry(orig_entry, mcast_orig_list, list) { + if (memcmp(orig, orig_entry->orig, ETH_ALEN)) + continue; + + nexthops_from_if_list(&orig_entry->mcast_if_list, nexthop_list, + bat_priv); + break; + } +} + +static inline void nexthops_from_table(uint8_t *dest, uint8_t *orig, + struct list_head *mcast_forw_table, + struct list_head *nexthop_list, + struct bat_priv *bat_priv) +{ + struct mcast_forw_table_entry *table_entry; + + list_for_each_entry(table_entry, mcast_forw_table, list) { + if (memcmp(dest, table_entry->mcast_addr, ETH_ALEN)) + continue; + + nexthops_from_orig_list(orig, &table_entry->mcast_orig_list, + nexthop_list, bat_priv); + break; + } +} + +static void route_mcast_packet(struct sk_buff *skb, struct bat_priv *bat_priv) +{ + struct sk_buff *skb1; + struct mcast_packet *mcast_packet; + struct ethhdr *ethhdr; + int num_bcasts = 3, i; + struct list_head nexthop_list; + struct dest_entries_list *dest_entry, *tmp; + + mcast_packet = (struct mcast_packet *)skb->data; + ethhdr = (struct ethhdr *)(mcast_packet + 1); + + INIT_LIST_HEAD(&nexthop_list); + + mcast_packet->ttl--; + + spin_lock_bh(&bat_priv->mcast_forw_table_lock); + nexthops_from_table(ethhdr->h_dest, mcast_packet->orig, + &bat_priv->mcast_forw_table, &nexthop_list, + bat_priv); + spin_unlock_bh(&bat_priv->mcast_forw_table_lock); + + list_for_each_entry_safe(dest_entry, tmp, &nexthop_list, list) { + if (is_broadcast_ether_addr(dest_entry->dest)) { + for (i = 0; i < num_bcasts; i++) { + skb1 = skb_clone(skb, GFP_ATOMIC); + send_skb_packet(skb1, dest_entry->batman_if, + dest_entry->dest); + } + } else { + skb1 = skb_clone(skb, GFP_ATOMIC); + send_skb_packet(skb1, dest_entry->batman_if, + dest_entry->dest); + } + kref_put(&dest_entry->batman_if->refcount, hardif_free_ref); + list_del(&dest_entry->list); + kfree(dest_entry); + } +} + +int mcast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv) +{ + struct mcast_packet *mcast_packet; + + if (!bat_priv->primary_if) + goto dropped; + + if (my_skb_head_push(skb, sizeof(struct mcast_packet)) < 0) + goto dropped; + + mcast_packet = (struct mcast_packet *)skb->data; + mcast_packet->version = COMPAT_VERSION; + mcast_packet->ttl = TTL; + + /* batman packet type: broadcast */ + mcast_packet->packet_type = BAT_MCAST; + + /* hw address of first interface is the orig mac because only + * this mac is known throughout the mesh */ + memcpy(mcast_packet->orig, + bat_priv->primary_if->net_dev->dev_addr, ETH_ALEN); + + /* set broadcast sequence number */ + mcast_packet->seqno = + htonl(atomic_inc_return(&bat_priv->mcast_seqno)); + + route_mcast_packet(skb, bat_priv); + + kfree_skb(skb); + return 0; + +dropped: + kfree_skb(skb); + return 1; +} + int mcast_init(struct bat_priv *bat_priv) { INIT_DELAYED_WORK(&bat_priv->mcast_tracker_work, mcast_tracker_timer); diff --git a/batman-adv/multicast.h b/batman-adv/multicast.h index 7312afa..06dd398 100644 --- a/batman-adv/multicast.h +++ b/batman-adv/multicast.h @@ -32,6 +32,7 @@ void route_mcast_tracker_packet( int tracker_packet_len, struct bat_priv *bat_priv); void purge_mcast_forw_table(struct bat_priv *bat_priv); int mcast_forw_table_seq_print_text(struct seq_file *seq, void *offset); +int mcast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv); int mcast_init(struct bat_priv *bat_priv); void mcast_free(struct bat_priv *bat_priv);

diff --git a/batman-adv/soft-interface.c b/batman-adv/soft-interface.c index 7cea678..2f327c4 100644 --- a/batman-adv/soft-interface.c +++ b/batman-adv/soft-interface.c @@ -38,6 +38,7 @@ #include <linux/if_vlan.h> #include "unicast.h" #include "routing.h" +#include "multicast.h"

static int bat_get_settings(struct net_device *dev, struct ethtool_cmd *cmd); @@ -347,7 +348,7 @@ int interface_tx(struct sk_buff *skb, struct net_device *soft_iface) struct vlan_ethhdr *vhdr; int data_len = skb->len, ret; short vid = -1; - bool do_bcast = false; + bool bcast_dst = false, mcast_dst = false;

if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE) goto dropped; @@ -384,12 +385,22 @@ int interface_tx(struct sk_buff *skb, struct net_device *soft_iface) if (ret < 0) goto dropped;

- if (ret == 0) - do_bcast = true; + /* dhcp request, which should be sent to the gateway + * directly? */ + if (ret) + goto unicast; + + if (is_broadcast_ether_addr(ethhdr->h_dest)) + bcast_dst = true; + else if (atomic_read(&bat_priv->mcast_mode) == + MCAST_MODE_PROACT_TRACKING) + mcast_dst = true; + else + bcast_dst = true; }

/* ethernet packet should be broadcasted */ - if (do_bcast) { + if (bcast_dst) { if (!bat_priv->primary_if) goto dropped;

@@ -418,8 +429,15 @@ int interface_tx(struct sk_buff *skb, struct net_device *soft_iface) * the original skb. */ kfree_skb(skb);

+ /* multicast data with path optimization */ + } else if (mcast_dst) { + ret = mcast_send_skb(skb, bat_priv); + if (ret != 0) + goto dropped_freed; + /* unicast packet */ } else { +unicast: ret = unicast_send_skb(skb, bat_priv); if (ret != 0) goto dropped_freed; @@ -608,6 +626,7 @@ struct net_device *softif_create(char *name)

atomic_set(&bat_priv->mesh_state, MESH_INACTIVE); atomic_set(&bat_priv->bcast_seqno, 1); + atomic_set(&bat_priv->mcast_seqno, 1); atomic_set(&bat_priv->hna_local_changed, 0);

bat_priv->primary_if = NULL; diff --git a/batman-adv/types.h b/batman-adv/types.h index 75adec9..2857fba 100644 --- a/batman-adv/types.h +++ b/batman-adv/types.h @@ -145,6 +145,7 @@ struct bat_priv { atomic_t mcast_fanout; /* uint */ atomic_t log_level; /* uint */ atomic_t bcast_seqno; + atomic_t mcast_seqno; atomic_t bcast_queue_left; atomic_t batman_queue_left; char num_ifaces;

This patch adds the forwarding of multicast data packets to the local soft interface if this receiving node is a member of the same multicast group as specified in the multicast packet.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- hard-interface.c | 5 +++++ routing.c | 29 +++++++++++++++++++++++++++++ routing.h | 1 + 3 files changed, 35 insertions(+), 0 deletions(-)

diff --git a/batman-adv/hard-interface.c b/batman-adv/hard-interface.c index f478c4b..a535e09 100644 --- a/batman-adv/hard-interface.c +++ b/batman-adv/hard-interface.c @@ -624,6 +624,11 @@ int batman_skb_recv(struct sk_buff *skb, struct net_device *dev, ret = recv_bcast_packet(skb, batman_if); break;

+ /* multicast packet */ + case BAT_MCAST: + ret = recv_mcast_packet(skb, batman_if); + break; + /* multicast tracker packet */ case BAT_MCAST_TRACKER: ret = recv_mcast_tracker_packet(skb, batman_if); diff --git a/batman-adv/routing.c b/batman-adv/routing.c index 9482db2..b5559c0 100644 --- a/batman-adv/routing.c +++ b/batman-adv/routing.c @@ -1510,6 +1510,35 @@ out: return ret; }

+int recv_mcast_packet(struct sk_buff *skb, struct batman_if *recv_if) +{ + struct ethhdr *ethhdr; + MC_LIST *mc_entry; + int ret = 1; + int hdr_size = sizeof(struct mcast_packet); + + /* multicast data packets might be received via unicast or broadcast */ + if (check_unicast_packet(skb, hdr_size) < 0 && + check_broadcast_packet(skb, hdr_size) < 0) + return NET_RX_DROP; + + ethhdr = (struct ethhdr *)(skb->data + sizeof(struct mcast_packet)); + + /* multicast for me? */ + netif_addr_lock_bh(recv_if->soft_iface); + netdev_for_each_mc_addr(mc_entry, recv_if->soft_iface) { + ret = memcmp(mc_entry->MC_LIST_ADDR, ethhdr->h_dest, ETH_ALEN); + if (!ret) + break; + } + netif_addr_unlock_bh(recv_if->soft_iface); + + if (!ret) + interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size); + + return NET_RX_SUCCESS; +} + int recv_mcast_tracker_packet(struct sk_buff *skb, struct batman_if *recv_if) { struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); diff --git a/batman-adv/routing.h b/batman-adv/routing.h index 0fad12a..722d837 100644 --- a/batman-adv/routing.h +++ b/batman-adv/routing.h @@ -38,6 +38,7 @@ int recv_icmp_packet(struct sk_buff *skb, struct batman_if *recv_if); int recv_unicast_packet(struct sk_buff *skb, struct batman_if *recv_if); int recv_ucast_frag_packet(struct sk_buff *skb, struct batman_if *recv_if); int recv_bcast_packet(struct sk_buff *skb, struct batman_if *recv_if); +int recv_mcast_packet(struct sk_buff *skb, struct batman_if *recv_if); int recv_mcast_tracker_packet(struct sk_buff *skb, struct batman_if *recv_if); int recv_vis_packet(struct sk_buff *skb, struct batman_if *recv_if); int recv_bat_packet(struct sk_buff *skb, struct batman_if *recv_if);

This commit adds duplicate checks to avoid endless rebroadcasts in the case of forwarding multicast data packets via broadcasting.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- originator.c | 2 ++ routing.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++++---- types.h | 3 +++ 3 files changed, 58 insertions(+), 4 deletions(-)

diff --git a/batman-adv/originator.c b/batman-adv/originator.c index 6c964e5..c819189 100644 --- a/batman-adv/originator.c +++ b/batman-adv/originator.c @@ -234,6 +234,8 @@ struct orig_node *get_orig_node(struct bat_priv *bat_priv, uint8_t *addr) orig_node->num_mca = 0; orig_node->bcast_seqno_reset = jiffies - 1 - msecs_to_jiffies(RESET_PROTECTION_MS); + orig_node->mcast_seqno_reset = jiffies - 1 + - msecs_to_jiffies(RESET_PROTECTION_MS); orig_node->batman_seqno_reset = jiffies - 1 - msecs_to_jiffies(RESET_PROTECTION_MS);

diff --git a/batman-adv/routing.c b/batman-adv/routing.c index 512d9ba..8167526 100644 --- a/batman-adv/routing.c +++ b/batman-adv/routing.c @@ -1513,20 +1513,61 @@ out: int recv_mcast_packet(struct sk_buff *skb, struct batman_if *recv_if) { struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct orig_node *orig_node = NULL; + struct mcast_packet *mcast_packet; struct ethhdr *ethhdr; MC_LIST *mc_entry; - int ret = 1; + int32_t seq_diff; + int ret = NET_RX_DROP; int hdr_size = sizeof(struct mcast_packet);

/* multicast data packets might be received via unicast or broadcast */ if (check_unicast_packet(skb, hdr_size) < 0 && check_broadcast_packet(skb, hdr_size) < 0) - return NET_RX_DROP; + goto out; + + mcast_packet = (struct mcast_packet *)skb->data; + + /* ignore broadcasts originated by myself */ + if (is_my_mac(mcast_packet->orig)) + goto out; + + if (mcast_packet->ttl < 2) + goto out; + + rcu_read_lock(); + orig_node = ((struct orig_node *) + hash_find(bat_priv->orig_hash, compare_orig, choose_orig, + mcast_packet->orig)); + + if (!orig_node) + goto unlock; + + kref_get(&orig_node->refcount); + rcu_read_unlock(); + + /* check whether the packet is a duplicate */ + if (get_bit_status(orig_node->mcast_bits, + orig_node->last_mcast_seqno, + ntohl(mcast_packet->seqno))) + goto out; + + seq_diff = ntohl(mcast_packet->seqno) - orig_node->last_mcast_seqno; + + /* check whether the packet is old and the host just restarted. */ + if (window_protected(bat_priv, seq_diff, + &orig_node->mcast_seqno_reset)) + goto out; + + /* mark broadcast in flood history, update window position + * if required. */ + if (bit_get_packet(bat_priv, orig_node->mcast_bits, seq_diff, 1)) + orig_node->last_mcast_seqno = ntohl(mcast_packet->seqno);

/* forward multicast packet if necessary */ route_mcast_packet(skb, bat_priv);

- ethhdr = (struct ethhdr *)(skb->data + sizeof(struct mcast_packet)); + ethhdr = (struct ethhdr *)(mcast_packet + 1);

/* multicast for me? */ netif_addr_lock_bh(recv_if->soft_iface); @@ -1540,7 +1581,15 @@ int recv_mcast_packet(struct sk_buff *skb, struct batman_if *recv_if) if (!ret) interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size);

- return NET_RX_SUCCESS; + ret = NET_RX_SUCCESS; + goto out; + +unlock: + rcu_read_unlock(); +out: + if (orig_node) + kref_put(&orig_node->refcount, orig_node_free_ref); + return ret; }

int recv_mcast_tracker_packet(struct sk_buff *skb, struct batman_if *recv_if) diff --git a/batman-adv/types.h b/batman-adv/types.h index 2857fba..d9b0429 100644 --- a/batman-adv/types.h +++ b/batman-adv/types.h @@ -74,6 +74,7 @@ struct orig_node { int tq_asym_penalty; unsigned long last_valid; unsigned long bcast_seqno_reset; + unsigned long mcast_seqno_reset; unsigned long batman_seqno_reset; uint8_t gw_flags; uint8_t flags; @@ -84,7 +85,9 @@ struct orig_node { uint32_t last_real_seqno; uint8_t last_ttl; unsigned long bcast_bits[NUM_WORDS]; + unsigned long mcast_bits[NUM_WORDS]; uint32_t last_bcast_seqno; + uint32_t last_mcast_seqno; struct hlist_head neigh_list; struct list_head frag_list; spinlock_t neigh_list_lock; /* protects neighbor list */

Depending on the scenario, people might want to adjust the number of (re)broadcast of data packets - usually higher values in sparse or lower values in dense networks.

Signed-off-by: Linus Lüssing linus.luessing@saxnet.de --- bat_sysfs.c | 2 ++ send.c | 3 ++- types.h | 1 + 3 files changed, 5 insertions(+), 1 deletions(-)

diff --git a/batman-adv/bat_sysfs.c b/batman-adv/bat_sysfs.c index 8f688db..7135c08 100644 --- a/batman-adv/bat_sysfs.c +++ b/batman-adv/bat_sysfs.c @@ -520,6 +520,7 @@ static BAT_ATTR(gw_mode, S_IRUGO | S_IWUSR, show_gw_mode, store_gw_mode); BAT_ATTR_UINT(orig_interval, S_IRUGO | S_IWUSR, 2 * JITTER, INT_MAX, update_mcast_tracker); BAT_ATTR_UINT(hop_penalty, S_IRUGO | S_IWUSR, 0, TQ_MAX_VALUE, NULL); +BAT_ATTR_UINT(num_bcasts, S_IRUGO | S_IWUSR, 0, INT_MAX, NULL); BAT_ATTR_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, TQ_MAX_VALUE, post_gw_deselect); static BAT_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, show_gw_bwidth, @@ -544,6 +545,7 @@ static struct bat_attribute *mesh_attrs[] = { &bat_attr_gw_mode, &bat_attr_orig_interval, &bat_attr_hop_penalty, + &bat_attr_num_bcasts, &bat_attr_gw_sel_class, &bat_attr_gw_bandwidth, &bat_attr_mcast_mode, diff --git a/batman-adv/send.c b/batman-adv/send.c index 03db894..4169f6e 100644 --- a/batman-adv/send.c +++ b/batman-adv/send.c @@ -510,6 +510,7 @@ static void send_outstanding_bcast_packet(struct work_struct *work) struct sk_buff *skb1; struct net_device *soft_iface = forw_packet->if_incoming->soft_iface; struct bat_priv *bat_priv = netdev_priv(soft_iface); + int num_bcasts = atomic_read(&bat_priv->num_bcasts);

spin_lock_bh(&bat_priv->forw_bcast_list_lock); hlist_del(&forw_packet->list); @@ -534,7 +535,7 @@ static void send_outstanding_bcast_packet(struct work_struct *work) forw_packet->num_packets++;

/* if we still have some more bcasts to send */ - if (forw_packet->num_packets < 3) { + if (forw_packet->num_packets < num_bcasts) { _add_bcast_packet_to_list(bat_priv, forw_packet, ((5 * HZ) / 1000)); return; diff --git a/batman-adv/types.h b/batman-adv/types.h index d9b0429..5d72d4c 100644 --- a/batman-adv/types.h +++ b/batman-adv/types.h @@ -142,6 +142,7 @@ struct bat_priv { atomic_t gw_bandwidth; /* gw bandwidth */ atomic_t orig_interval; /* uint */ atomic_t hop_penalty; /* uint */ + atomic_t num_bcasts; /* uint */ atomic_t mcast_mode; /* MCAST_MODE_* */ atomic_t mcast_tracker_interval;/* uint, auto */ atomic_t mcast_tracker_timeout; /* uint, auto */