Merge tag 'batadv-next-for-davem-20160812' of git://git.open-mesh.org/linux-merge (f9f9ab17) · Commits · 戴 / test

Documentation/networking/batman-adv.txt

+11 −6

Original line number	Diff line number	Diff line
		@@ -43,10 +43,15 @@ new interfaces to verify the compatibility. There is no need to
		reload the module if you plug your USB wifi adapter into your ma-
		chine after batman advanced was initially loaded.

		To activate a given interface simply write "bat0" into its
		"mesh_iface" file inside the batman_adv subfolder:
		The batman-adv soft-interface can be created using the iproute2
		tool "ip"

		# echo bat0 > /sys/class/net/eth0/batman_adv/mesh_iface
		# ip link add name bat0 type batadv

		To activate a given interface simply attach it to the "bat0"
		interface

		# ip link set dev eth0 master bat0

		Repeat this step for all interfaces you wish to add. Now batman
		starts using/broadcasting on this/these interface(s).
		@@ -56,10 +61,10 @@ By reading the "iface_status" file you can check its status:
		# cat /sys/class/net/eth0/batman_adv/iface_status
		# active

		To deactivate an interface you have to write "none" into its
		"mesh_iface" file:
		To deactivate an interface you have to detach it from the
		"bat0" interface:

		# echo none > /sys/class/net/eth0/batman_adv/mesh_iface
		# ip link set dev eth0 nomaster


		All mesh wide settings can be found in batman's own interface

net/batman-adv/bat_iv_ogm.c

+276 −71

Original line number	Diff line number	Diff line
		@@ -51,6 +51,7 @@

		#include "bat_algo.h"
		#include "bitarray.h"
		#include "gateway_client.h"
		#include "hard-interface.h"
		#include "hash.h"
		#include "log.h"
		@@ -528,36 +529,25 @@ static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet,
		static void batadv_iv_ogm_emit(struct batadv_forw_packet *forw_packet)
		{
		struct net_device *soft_iface;
		struct batadv_priv *bat_priv;
		struct batadv_hard_iface *primary_if = NULL;

		if (!forw_packet->if_incoming) {
		pr_err("Error - can't forward packet: incoming iface not specified\n");
		goto out;
		return;
		}

		soft_iface = forw_packet->if_incoming->soft_iface;
		bat_priv = netdev_priv(soft_iface);

		if (WARN_ON(!forw_packet->if_outgoing))
		goto out;
		return;

		if (WARN_ON(forw_packet->if_outgoing->soft_iface != soft_iface))
		goto out;
		return;

		if (forw_packet->if_incoming->if_status != BATADV_IF_ACTIVE)
		goto out;

		primary_if = batadv_primary_if_get_selected(bat_priv);
		if (!primary_if)
		goto out;
		return;

		/* only for one specific outgoing interface */
		batadv_iv_ogm_send_to_if(forw_packet, forw_packet->if_outgoing);

		out:
		if (primary_if)
		batadv_hardif_put(primary_if);
		}

		/**
		@@ -685,19 +675,12 @@ static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
		struct batadv_forw_packet *forw_packet_aggr;
		unsigned char *skb_buff;
		unsigned int skb_size;
		atomic_t *queue_left = own_packet ? NULL : &bat_priv->batman_queue_left;

		/* own packet should always be scheduled */
		if (!own_packet) {
		if (!batadv_atomic_dec_not_zero(&bat_priv->batman_queue_left)) {
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"batman packet queue full\n");
		return;
		}
		}

		forw_packet_aggr = kmalloc(sizeof(*forw_packet_aggr), GFP_ATOMIC);
		forw_packet_aggr = batadv_forw_packet_alloc(if_incoming, if_outgoing,
		queue_left, bat_priv);
		if (!forw_packet_aggr)
		goto out_nomem;
		return;

		if (atomic_read(&bat_priv->aggregated_ogms) &&
		packet_len < BATADV_MAX_AGGREGATION_BYTES)
		@@ -708,8 +691,11 @@ static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
		skb_size += ETH_HLEN;

		forw_packet_aggr->skb = netdev_alloc_skb_ip_align(NULL, skb_size);
		if (!forw_packet_aggr->skb)
		goto out_free_forw_packet;
		if (!forw_packet_aggr->skb) {
		batadv_forw_packet_free(forw_packet_aggr);
		return;
		}

		forw_packet_aggr->skb->priority = TC_PRIO_CONTROL;
		skb_reserve(forw_packet_aggr->skb, ETH_HLEN);

		@@ -717,12 +703,7 @@ static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
		forw_packet_aggr->packet_len = packet_len;
		memcpy(skb_buff, packet_buff, packet_len);

		kref_get(&if_incoming->refcount);
		kref_get(&if_outgoing->refcount);
		forw_packet_aggr->own = own_packet;
		forw_packet_aggr->if_incoming = if_incoming;
		forw_packet_aggr->if_outgoing = if_outgoing;
		forw_packet_aggr->num_packets = 0;
		forw_packet_aggr->direct_link_flags = BATADV_NO_FLAGS;
		forw_packet_aggr->send_time = send_time;

		@@ -741,13 +722,6 @@ static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
		queue_delayed_work(batadv_event_workqueue,
		&forw_packet_aggr->delayed_work,
		send_time - jiffies);

		return;
		out_free_forw_packet:
		kfree(forw_packet_aggr);
		out_nomem:
		if (!own_packet)
		atomic_inc(&bat_priv->batman_queue_left);
		}

		/* aggregate a new packet into the existing ogm packet */
		@@ -1830,10 +1804,6 @@ static void batadv_iv_send_outstanding_bat_ogm_packet(struct work_struct *work)
		batadv_iv_ogm_schedule(forw_packet->if_incoming);

		out:
		/* don't count own packet */
		if (!forw_packet->own)
		atomic_inc(&bat_priv->batman_queue_left);

		batadv_forw_packet_free(forw_packet);
		}

		@@ -2029,35 +1999,40 @@ static void batadv_iv_neigh_print(struct batadv_priv *bat_priv,
		}

		/**
		* batadv_iv_ogm_neigh_cmp - compare the metrics of two neighbors
		* batadv_iv_ogm_neigh_diff - calculate tq difference of two neighbors
		* @neigh1: the first neighbor object of the comparison
		* @if_outgoing1: outgoing interface for the first neighbor
		* @neigh2: the second neighbor object of the comparison
		* @if_outgoing2: outgoing interface for the second neighbor
		* @diff: pointer to integer receiving the calculated difference
		*
		* Return: a value less, equal to or greater than 0 if the metric via neigh1 is
		* lower, the same as or higher than the metric via neigh2
		* The content of *@diff is only valid when this function returns true.
		* It is less, equal to or greater than 0 if the metric via neigh1 is lower,
		* the same as or higher than the metric via neigh2
		*
		* Return: true when the difference could be calculated, false otherwise
		*/
		static int batadv_iv_ogm_neigh_cmp(struct batadv_neigh_node *neigh1,
		static bool batadv_iv_ogm_neigh_diff(struct batadv_neigh_node *neigh1,
		struct batadv_hard_iface *if_outgoing1,
		struct batadv_neigh_node *neigh2,
		struct batadv_hard_iface *if_outgoing2)
		struct batadv_hard_iface *if_outgoing2,
		int *diff)
		{
		struct batadv_neigh_ifinfo neigh1_ifinfo, neigh2_ifinfo;
		u8 tq1, tq2;
		int diff;
		bool ret = true;

		neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
		neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);

		if (!neigh1_ifinfo \|\| !neigh2_ifinfo) {
		diff = 0;
		ret = false;
		goto out;
		}

		tq1 = neigh1_ifinfo->bat_iv.tq_avg;
		tq2 = neigh2_ifinfo->bat_iv.tq_avg;
		diff = tq1 - tq2;
		*diff = (int)tq1 - (int)tq2;

		out:
		if (neigh1_ifinfo)
		@@ -2065,6 +2040,32 @@ out:
		if (neigh2_ifinfo)
		batadv_neigh_ifinfo_put(neigh2_ifinfo);

		return ret;
		}

		/**
		* batadv_iv_ogm_neigh_cmp - compare the metrics of two neighbors
		* @neigh1: the first neighbor object of the comparison
		* @if_outgoing1: outgoing interface for the first neighbor
		* @neigh2: the second neighbor object of the comparison
		* @if_outgoing2: outgoing interface for the second neighbor
		*
		* Return: a value less, equal to or greater than 0 if the metric via neigh1 is
		* lower, the same as or higher than the metric via neigh2
		*/
		static int batadv_iv_ogm_neigh_cmp(struct batadv_neigh_node *neigh1,
		struct batadv_hard_iface *if_outgoing1,
		struct batadv_neigh_node *neigh2,
		struct batadv_hard_iface *if_outgoing2)
		{
		bool ret;
		int diff;

		ret = batadv_iv_ogm_neigh_diff(neigh1, if_outgoing1, neigh2,
		if_outgoing2, &diff);
		if (!ret)
		return 0;

		return diff;
		}

		@@ -2085,36 +2086,235 @@ batadv_iv_ogm_neigh_is_sob(struct batadv_neigh_node *neigh1,
		struct batadv_neigh_node *neigh2,
		struct batadv_hard_iface *if_outgoing2)
		{
		struct batadv_neigh_ifinfo neigh1_ifinfo, neigh2_ifinfo;
		u8 tq1, tq2;
		bool ret;
		int diff;

		neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1);
		neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2);
		ret = batadv_iv_ogm_neigh_diff(neigh1, if_outgoing1, neigh2,
		if_outgoing2, &diff);
		if (!ret)
		return false;

		/* we can't say that the metric is better */
		if (!neigh1_ifinfo \|\| !neigh2_ifinfo) {
		ret = false;
		ret = diff > -BATADV_TQ_SIMILARITY_THRESHOLD;
		return ret;
		}

		static void batadv_iv_iface_activate(struct batadv_hard_iface *hard_iface)
		{
		/* begin scheduling originator messages on that interface */
		batadv_iv_ogm_schedule(hard_iface);
		}

		static struct batadv_gw_node *
		batadv_iv_gw_get_best_gw_node(struct batadv_priv *bat_priv)
		{
		struct batadv_neigh_node *router;
		struct batadv_neigh_ifinfo *router_ifinfo;
		struct batadv_gw_node gw_node, curr_gw = NULL;
		u64 max_gw_factor = 0;
		u64 tmp_gw_factor = 0;
		u8 max_tq = 0;
		u8 tq_avg;
		struct batadv_orig_node *orig_node;

		rcu_read_lock();
		hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
		orig_node = gw_node->orig_node;
		router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
		if (!router)
		continue;

		router_ifinfo = batadv_neigh_ifinfo_get(router,
		BATADV_IF_DEFAULT);
		if (!router_ifinfo)
		goto next;

		if (!kref_get_unless_zero(&gw_node->refcount))
		goto next;

		tq_avg = router_ifinfo->bat_iv.tq_avg;

		switch (atomic_read(&bat_priv->gw.sel_class)) {
		case 1: /* fast connection */
		tmp_gw_factor = tq_avg * tq_avg;
		tmp_gw_factor *= gw_node->bandwidth_down;
		tmp_gw_factor = 100 100;
		tmp_gw_factor >>= 18;

		if ((tmp_gw_factor > max_gw_factor) \|\|
		((tmp_gw_factor == max_gw_factor) &&
		(tq_avg > max_tq))) {
		if (curr_gw)
		batadv_gw_node_put(curr_gw);
		curr_gw = gw_node;
		kref_get(&curr_gw->refcount);
		}
		break;

		default: /* 2: stable connection (use best statistic)
		* 3: fast-switch (use best statistic but change as
		* soon as a better gateway appears)
		* XX: late-switch (use best statistic but change as
		* soon as a better gateway appears which has
		* $routing_class more tq points)
		*/
		if (tq_avg > max_tq) {
		if (curr_gw)
		batadv_gw_node_put(curr_gw);
		curr_gw = gw_node;
		kref_get(&curr_gw->refcount);
		}
		break;
		}

		if (tq_avg > max_tq)
		max_tq = tq_avg;

		if (tmp_gw_factor > max_gw_factor)
		max_gw_factor = tmp_gw_factor;

		batadv_gw_node_put(gw_node);

		next:
		batadv_neigh_node_put(router);
		if (router_ifinfo)
		batadv_neigh_ifinfo_put(router_ifinfo);
		}
		rcu_read_unlock();

		return curr_gw;
		}

		static bool batadv_iv_gw_is_eligible(struct batadv_priv *bat_priv,
		struct batadv_orig_node *curr_gw_orig,
		struct batadv_orig_node *orig_node)
		{
		struct batadv_neigh_ifinfo *router_orig_ifinfo = NULL;
		struct batadv_neigh_ifinfo *router_gw_ifinfo = NULL;
		struct batadv_neigh_node *router_gw = NULL;
		struct batadv_neigh_node *router_orig = NULL;
		u8 gw_tq_avg, orig_tq_avg;
		bool ret = false;

		/* dynamic re-election is performed only on fast or late switch */
		if (atomic_read(&bat_priv->gw.sel_class) <= 2)
		return false;

		router_gw = batadv_orig_router_get(curr_gw_orig, BATADV_IF_DEFAULT);
		if (!router_gw) {
		ret = true;
		goto out;
		}

		tq1 = neigh1_ifinfo->bat_iv.tq_avg;
		tq2 = neigh2_ifinfo->bat_iv.tq_avg;
		ret = (tq1 - tq2) > -BATADV_TQ_SIMILARITY_THRESHOLD;
		router_gw_ifinfo = batadv_neigh_ifinfo_get(router_gw,
		BATADV_IF_DEFAULT);
		if (!router_gw_ifinfo) {
		ret = true;
		goto out;
		}

		router_orig = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
		if (!router_orig)
		goto out;

		router_orig_ifinfo = batadv_neigh_ifinfo_get(router_orig,
		BATADV_IF_DEFAULT);
		if (!router_orig_ifinfo)
		goto out;

		gw_tq_avg = router_gw_ifinfo->bat_iv.tq_avg;
		orig_tq_avg = router_orig_ifinfo->bat_iv.tq_avg;

		/* the TQ value has to be better */
		if (orig_tq_avg < gw_tq_avg)
		goto out;

		/* if the routing class is greater than 3 the value tells us how much
		* greater the TQ value of the new gateway must be
		*/
		if ((atomic_read(&bat_priv->gw.sel_class) > 3) &&
		(orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw.sel_class)))
		goto out;

		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n",
		gw_tq_avg, orig_tq_avg);

		ret = true;
		out:
		if (neigh1_ifinfo)
		batadv_neigh_ifinfo_put(neigh1_ifinfo);
		if (neigh2_ifinfo)
		batadv_neigh_ifinfo_put(neigh2_ifinfo);
		if (router_gw_ifinfo)
		batadv_neigh_ifinfo_put(router_gw_ifinfo);
		if (router_orig_ifinfo)
		batadv_neigh_ifinfo_put(router_orig_ifinfo);
		if (router_gw)
		batadv_neigh_node_put(router_gw);
		if (router_orig)
		batadv_neigh_node_put(router_orig);

		return ret;
		}

		static void batadv_iv_iface_activate(struct batadv_hard_iface *hard_iface)
		/* fails if orig_node has no router */
		static int batadv_iv_gw_write_buffer_text(struct batadv_priv *bat_priv,
		struct seq_file *seq,
		const struct batadv_gw_node *gw_node)
		{
		/* begin scheduling originator messages on that interface */
		batadv_iv_ogm_schedule(hard_iface);
		struct batadv_gw_node *curr_gw;
		struct batadv_neigh_node *router;
		struct batadv_neigh_ifinfo *router_ifinfo = NULL;
		int ret = -1;

		router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
		if (!router)
		goto out;

		router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
		if (!router_ifinfo)
		goto out;

		curr_gw = batadv_gw_get_selected_gw_node(bat_priv);

		seq_printf(seq, "%s %pM (%3i) %pM [%10s]: %u.%u/%u.%u MBit\n",
		(curr_gw == gw_node ? "=>" : " "),
		gw_node->orig_node->orig,
		router_ifinfo->bat_iv.tq_avg, router->addr,
		router->if_incoming->net_dev->name,
		gw_node->bandwidth_down / 10,
		gw_node->bandwidth_down % 10,
		gw_node->bandwidth_up / 10,
		gw_node->bandwidth_up % 10);
		ret = seq_has_overflowed(seq) ? -1 : 0;

		if (curr_gw)
		batadv_gw_node_put(curr_gw);
		out:
		if (router_ifinfo)
		batadv_neigh_ifinfo_put(router_ifinfo);
		if (router)
		batadv_neigh_node_put(router);
		return ret;
		}

		static void batadv_iv_gw_print(struct batadv_priv *bat_priv,
		struct seq_file *seq)
		{
		struct batadv_gw_node *gw_node;
		int gw_count = 0;

		seq_puts(seq,
		" Gateway (#/255) Nexthop [outgoingIF]: advertised uplink bandwidth\n");

		rcu_read_lock();
		hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
		/* fails if orig_node has no router */
		if (batadv_iv_gw_write_buffer_text(bat_priv, seq, gw_node) < 0)
		continue;

		gw_count++;
		}
		rcu_read_unlock();

		if (gw_count == 0)
		seq_puts(seq, "No gateways in range ...\n");
		}

		static struct batadv_algo_ops batadv_batman_iv __read_mostly = {
		@@ -2137,6 +2337,11 @@ static struct batadv_algo_ops batadv_batman_iv __read_mostly = {
		.add_if = batadv_iv_ogm_orig_add_if,
		.del_if = batadv_iv_ogm_orig_del_if,
		},
		.gw = {
		.get_best_gw_node = batadv_iv_gw_get_best_gw_node,
		.is_eligible = batadv_iv_gw_is_eligible,
		.print = batadv_iv_gw_print,
		},
		};

		int __init batadv_iv_init(void)

net/batman-adv/bat_v.c

+256 −1

Original line number	Diff line number	Diff line
		@@ -21,8 +21,11 @@
		#include <linux/atomic.h>
		#include <linux/bug.h>
		#include <linux/cache.h>
		#include <linux/errno.h>
		#include <linux/init.h>
		#include <linux/jiffies.h>
		#include <linux/kernel.h>
		#include <linux/kref.h>
		#include <linux/netdevice.h>
		#include <linux/rculist.h>
		#include <linux/rcupdate.h>
		@@ -34,8 +37,11 @@
		#include "bat_algo.h"
		#include "bat_v_elp.h"
		#include "bat_v_ogm.h"
		#include "gateway_client.h"
		#include "gateway_common.h"
		#include "hard-interface.h"
		#include "hash.h"
		#include "log.h"
		#include "originator.h"
		#include "packet.h"

		@@ -320,6 +326,239 @@ err_ifinfo1:
		return ret;
		}

		static ssize_t batadv_v_store_sel_class(struct batadv_priv *bat_priv,
		char *buff, size_t count)
		{
		u32 old_class, class;

		if (!batadv_parse_throughput(bat_priv->soft_iface, buff,
		"B.A.T.M.A.N. V GW selection class",
		&class))
		return -EINVAL;

		old_class = atomic_read(&bat_priv->gw.sel_class);
		atomic_set(&bat_priv->gw.sel_class, class);

		if (old_class != class)
		batadv_gw_reselect(bat_priv);

		return count;
		}

		static ssize_t batadv_v_show_sel_class(struct batadv_priv bat_priv, char buff)
		{
		u32 class = atomic_read(&bat_priv->gw.sel_class);

		return sprintf(buff, "%u.%u MBit\n", class / 10, class % 10);
		}

		/**
		* batadv_v_gw_throughput_get - retrieve the GW-bandwidth for a given GW
		* @gw_node: the GW to retrieve the metric for
		* @bw: the pointer where the metric will be stored. The metric is computed as
		* the minimum between the GW advertised throughput and the path throughput to
		* it in the mesh
		*
		* Return: 0 on success, -1 on failure
		*/
		static int batadv_v_gw_throughput_get(struct batadv_gw_node gw_node, u32 bw)
		{
		struct batadv_neigh_ifinfo *router_ifinfo = NULL;
		struct batadv_orig_node *orig_node;
		struct batadv_neigh_node *router;
		int ret = -1;

		orig_node = gw_node->orig_node;
		router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT);
		if (!router)
		goto out;

		router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
		if (!router_ifinfo)
		goto out;

		/* the GW metric is computed as the minimum between the path throughput
		* to reach the GW itself and the advertised bandwidth.
		* This gives us an approximation of the effective throughput that the
		* client can expect via this particular GW node
		*/
		*bw = router_ifinfo->bat_v.throughput;
		bw = min_t(u32, bw, gw_node->bandwidth_down);

		ret = 0;
		out:
		if (router)
		batadv_neigh_node_put(router);
		if (router_ifinfo)
		batadv_neigh_ifinfo_put(router_ifinfo);

		return ret;
		}

		/**
		* batadv_v_gw_get_best_gw_node - retrieve the best GW node
		* @bat_priv: the bat priv with all the soft interface information
		*
		* Return: the GW node having the best GW-metric, NULL if no GW is known
		*/
		static struct batadv_gw_node *
		batadv_v_gw_get_best_gw_node(struct batadv_priv *bat_priv)
		{
		struct batadv_gw_node gw_node, curr_gw = NULL;
		u32 max_bw = 0, bw;

		rcu_read_lock();
		hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
		if (!kref_get_unless_zero(&gw_node->refcount))
		continue;

		if (batadv_v_gw_throughput_get(gw_node, &bw) < 0)
		goto next;

		if (curr_gw && (bw <= max_bw))
		goto next;

		if (curr_gw)
		batadv_gw_node_put(curr_gw);

		curr_gw = gw_node;
		kref_get(&curr_gw->refcount);
		max_bw = bw;

		next:
		batadv_gw_node_put(gw_node);
		}
		rcu_read_unlock();

		return curr_gw;
		}

		/**
		* batadv_v_gw_is_eligible - check if a originator would be selected as GW
		* @bat_priv: the bat priv with all the soft interface information
		* @curr_gw_orig: originator representing the currently selected GW
		* @orig_node: the originator representing the new candidate
		*
		* Return: true if orig_node can be selected as current GW, false otherwise
		*/
		static bool batadv_v_gw_is_eligible(struct batadv_priv *bat_priv,
		struct batadv_orig_node *curr_gw_orig,
		struct batadv_orig_node *orig_node)
		{
		struct batadv_gw_node curr_gw = NULL, orig_gw = NULL;
		u32 gw_throughput, orig_throughput, threshold;
		bool ret = false;

		threshold = atomic_read(&bat_priv->gw.sel_class);

		curr_gw = batadv_gw_node_get(bat_priv, curr_gw_orig);
		if (!curr_gw) {
		ret = true;
		goto out;
		}

		if (batadv_v_gw_throughput_get(curr_gw, &gw_throughput) < 0) {
		ret = true;
		goto out;
		}

		orig_gw = batadv_gw_node_get(bat_priv, orig_node);
		if (!orig_node)
		goto out;

		if (batadv_v_gw_throughput_get(orig_gw, &orig_throughput) < 0)
		goto out;

		if (orig_throughput < gw_throughput)
		goto out;

		if ((orig_throughput - gw_throughput) < threshold)
		goto out;

		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"Restarting gateway selection: better gateway found (throughput curr: %u, throughput new: %u)\n",
		gw_throughput, orig_throughput);

		ret = true;
		out:
		if (curr_gw)
		batadv_gw_node_put(curr_gw);
		if (orig_gw)
		batadv_gw_node_put(orig_gw);

		return ret;
		}

		/* fails if orig_node has no router */
		static int batadv_v_gw_write_buffer_text(struct batadv_priv *bat_priv,
		struct seq_file *seq,
		const struct batadv_gw_node *gw_node)
		{
		struct batadv_gw_node *curr_gw;
		struct batadv_neigh_node *router;
		struct batadv_neigh_ifinfo *router_ifinfo = NULL;
		int ret = -1;

		router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT);
		if (!router)
		goto out;

		router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT);
		if (!router_ifinfo)
		goto out;

		curr_gw = batadv_gw_get_selected_gw_node(bat_priv);

		seq_printf(seq, "%s %pM (%9u.%1u) %pM [%10s]: %u.%u/%u.%u MBit\n",
		(curr_gw == gw_node ? "=>" : " "),
		gw_node->orig_node->orig,
		router_ifinfo->bat_v.throughput / 10,
		router_ifinfo->bat_v.throughput % 10, router->addr,
		router->if_incoming->net_dev->name,
		gw_node->bandwidth_down / 10,
		gw_node->bandwidth_down % 10,
		gw_node->bandwidth_up / 10,
		gw_node->bandwidth_up % 10);
		ret = seq_has_overflowed(seq) ? -1 : 0;

		if (curr_gw)
		batadv_gw_node_put(curr_gw);
		out:
		if (router_ifinfo)
		batadv_neigh_ifinfo_put(router_ifinfo);
		if (router)
		batadv_neigh_node_put(router);
		return ret;
		}

		/**
		* batadv_v_gw_print - print the gateway list
		* @bat_priv: the bat priv with all the soft interface information
		* @seq: gateway table seq_file struct
		*/
		static void batadv_v_gw_print(struct batadv_priv *bat_priv,
		struct seq_file *seq)
		{
		struct batadv_gw_node *gw_node;
		int gw_count = 0;

		seq_puts(seq,
		" Gateway ( throughput) Nexthop [outgoingIF]: advertised uplink bandwidth\n");

		rcu_read_lock();
		hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.list, list) {
		/* fails if orig_node has no router */
		if (batadv_v_gw_write_buffer_text(bat_priv, seq, gw_node) < 0)
		continue;

		gw_count++;
		}
		rcu_read_unlock();

		if (gw_count == 0)
		seq_puts(seq, "No gateways in range ...\n");
		}

		static struct batadv_algo_ops batadv_batman_v __read_mostly = {
		.name = "BATMAN_V",
		.iface = {
		@@ -338,6 +577,13 @@ static struct batadv_algo_ops batadv_batman_v __read_mostly = {
		.orig = {
		.print = batadv_v_orig_print,
		},
		.gw = {
		.store_sel_class = batadv_v_store_sel_class,
		.show_sel_class = batadv_v_show_sel_class,
		.get_best_gw_node = batadv_v_gw_get_best_gw_node,
		.is_eligible = batadv_v_gw_is_eligible,
		.print = batadv_v_gw_print,
		},
		};

		/**
		@@ -363,7 +609,16 @@ void batadv_v_hardif_init(struct batadv_hard_iface *hard_iface)
		*/
		int batadv_v_mesh_init(struct batadv_priv *bat_priv)
		{
		return batadv_v_ogm_init(bat_priv);
		int ret = 0;

		ret = batadv_v_ogm_init(bat_priv);
		if (ret < 0)
		return ret;

		/* set default throughput difference threshold to 5Mbps */
		atomic_set(&bat_priv->gw.sel_class, 50);

		return 0;
		}

		/**

net/batman-adv/bridge_loop_avoidance.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -1148,7 +1148,7 @@ static bool batadv_bla_process_claim(struct batadv_priv *bat_priv,

		/* Let the loopdetect frames on the mesh in any case. */
		if (bla_dst->type == BATADV_CLAIM_TYPE_LOOPDETECT)
		return 0;
		return false;

		/* check if it is a claim frame. */
		ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,

net/batman-adv/gateway_client.c

+30 −192

File changed.

Preview size limit exceeded, changes collapsed.

Admin message