Merge tag 'batman-adv-for-davem' of git://git.open-mesh.org/linux-merge (3ccdca77) · Commits · e / devices / android_kernel_fairphone_FP5

Documentation/ABI/testing/sysfs-class-net-mesh

+7 −0

Original line number	Diff line number	Diff line
		@@ -65,6 +65,13 @@ Description:
		Defines the penalty which will be applied to an
		originator message's tq-field on every hop.

		What: /sys/class/net/<mesh_iface>/mesh/routing_algo
		Date: Dec 2011
		Contact: Marek Lindner <lindner_marek@yahoo.de>
		Description:
		Defines the routing procotol this mesh instance
		uses to find the optimal paths through the mesh.

		What: /sys/class/net/<mesh_iface>/mesh/vis_mode
		Date: May 2010
		Contact: Marek Lindner <lindner_marek@yahoo.de>

net/batman-adv/bat_ogm.h→net/batman-adv/bat_algo.h

+6 −14

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2007-2011 B.A.T.M.A.N. contributors:
		* Copyright (C) 2011 B.A.T.M.A.N. contributors:
		*
		* Marek Lindner, Simon Wunderlich
		* Marek Lindner
		*
		* This program is free software; you can redistribute it and/or
		* modify it under the terms of version 2 of the GNU General Public
		@@ -19,17 +19,9 @@
		*
		*/

		#ifndef _NET_BATMAN_ADV_OGM_H_
		#define _NET_BATMAN_ADV_OGM_H_
		#ifndef _NET_BATMAN_ADV_BAT_ALGO_H_
		#define _NET_BATMAN_ADV_BAT_ALGO_H_

		#include "main.h"
		int bat_iv_init(void);

		void bat_ogm_init(struct hard_iface *hard_iface);
		void bat_ogm_init_primary(struct hard_iface *hard_iface);
		void bat_ogm_update_mac(struct hard_iface *hard_iface);
		void bat_ogm_schedule(struct hard_iface *hard_iface, int tt_num_changes);
		void bat_ogm_emit(struct forw_packet *forw_packet);
		void bat_ogm_receive(const struct ethhdr ethhdr, unsigned char packet_buff,
		int packet_len, struct hard_iface *if_incoming);

		#endif /* _NET_BATMAN_ADV_OGM_H_ */
		#endif /* _NET_BATMAN_ADV_BAT_ALGO_H_ */

net/batman-adv/bat_debugfs.c

+22 −0

Original line number	Diff line number	Diff line
		@@ -221,6 +221,11 @@ static void debug_log_cleanup(struct bat_priv *bat_priv)
		}
		#endif

		static int bat_algorithms_open(struct inode inode, struct file file)
		{
		return single_open(file, bat_algo_seq_print_text, NULL);
		}

		static int originators_open(struct inode inode, struct file file)
		{
		struct net_device net_dev = (struct net_device )inode->i_private;
		@@ -274,6 +279,7 @@ struct bat_debuginfo bat_debuginfo_##_name = { \
		} \
		};

		static BAT_DEBUGINFO(routing_algos, S_IRUGO, bat_algorithms_open);
		static BAT_DEBUGINFO(originators, S_IRUGO, originators_open);
		static BAT_DEBUGINFO(gateways, S_IRUGO, gateways_open);
		static BAT_DEBUGINFO(softif_neigh, S_IRUGO, softif_neigh_open);
		@@ -293,9 +299,25 @@ static struct bat_debuginfo *mesh_debuginfos[] = {

		void debugfs_init(void)
		{
		struct bat_debuginfo *bat_debug;
		struct dentry *file;

		bat_debugfs = debugfs_create_dir(DEBUGFS_BAT_SUBDIR, NULL);
		if (bat_debugfs == ERR_PTR(-ENODEV))
		bat_debugfs = NULL;

		if (!bat_debugfs)
		goto out;

		bat_debug = &bat_debuginfo_routing_algos;
		file = debugfs_create_file(bat_debug->attr.name,
		S_IFREG \| bat_debug->attr.mode,
		bat_debugfs, NULL, &bat_debug->fops);
		if (!file)
		pr_err("Can't add debugfs file: %s\n", bat_debug->attr.name);

		out:
		return;
		}

		void debugfs_destroy(void)

net/batman-adv/bat_iv_ogm.c

+134 −111

Original line number	Diff line number	Diff line
		@@ -20,7 +20,6 @@
		*/

		#include "main.h"
		#include "bat_ogm.h"
		#include "translation-table.h"
		#include "ring_buffer.h"
		#include "originator.h"
		@@ -29,8 +28,9 @@
		#include "gateway_client.h"
		#include "hard-interface.h"
		#include "send.h"
		#include "bat_algo.h"

		void bat_ogm_init(struct hard_iface *hard_iface)
		static void bat_iv_ogm_init(struct hard_iface *hard_iface)
		{
		struct batman_ogm_packet *batman_ogm_packet;

		@@ -38,25 +38,25 @@ void bat_ogm_init(struct hard_iface *hard_iface)
		hard_iface->packet_buff = kmalloc(hard_iface->packet_len, GFP_ATOMIC);

		batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
		batman_ogm_packet->packet_type = BAT_OGM;
		batman_ogm_packet->version = COMPAT_VERSION;
		batman_ogm_packet->header.packet_type = BAT_OGM;
		batman_ogm_packet->header.version = COMPAT_VERSION;
		batman_ogm_packet->header.ttl = 2;
		batman_ogm_packet->flags = NO_FLAGS;
		batman_ogm_packet->ttl = 2;
		batman_ogm_packet->tq = TQ_MAX_VALUE;
		batman_ogm_packet->tt_num_changes = 0;
		batman_ogm_packet->ttvn = 0;
		}

		void bat_ogm_init_primary(struct hard_iface *hard_iface)
		static void bat_iv_ogm_init_primary(struct hard_iface *hard_iface)
		{
		struct batman_ogm_packet *batman_ogm_packet;

		batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff;
		batman_ogm_packet->flags = PRIMARIES_FIRST_HOP;
		batman_ogm_packet->ttl = TTL;
		batman_ogm_packet->header.ttl = TTL;
		}

		void bat_ogm_update_mac(struct hard_iface *hard_iface)
		static void bat_iv_ogm_update_mac(struct hard_iface *hard_iface)
		{
		struct batman_ogm_packet *batman_ogm_packet;

		@@ -68,7 +68,7 @@ void bat_ogm_update_mac(struct hard_iface *hard_iface)
		}

		/* when do we schedule our own ogm to be sent */
		static unsigned long bat_ogm_emit_send_time(const struct bat_priv *bat_priv)
		static unsigned long bat_iv_ogm_emit_send_time(const struct bat_priv *bat_priv)
		{
		return jiffies + msecs_to_jiffies(
		atomic_read(&bat_priv->orig_interval) -
		@@ -76,7 +76,7 @@ static unsigned long bat_ogm_emit_send_time(const struct bat_priv *bat_priv)
		}

		/* when do we schedule a ogm packet to be sent */
		static unsigned long bat_ogm_fwd_send_time(void)
		static unsigned long bat_iv_ogm_fwd_send_time(void)
		{
		return jiffies + msecs_to_jiffies(random32() % (JITTER/2));
		}
		@@ -89,7 +89,7 @@ static uint8_t hop_penalty(uint8_t tq, const struct bat_priv *bat_priv)
		}

		/* is there another aggregated packet here? */
		static int bat_ogm_aggr_packet(int buff_pos, int packet_len,
		static int bat_iv_ogm_aggr_packet(int buff_pos, int packet_len,
		int tt_num_changes)
		{
		int next_buff_pos = buff_pos + BATMAN_OGM_LEN + tt_len(tt_num_changes);
		@@ -99,7 +99,7 @@ static int bat_ogm_aggr_packet(int buff_pos, int packet_len,
		}

		/* send a batman ogm to a given interface */
		static void bat_ogm_send_to_if(struct forw_packet *forw_packet,
		static void bat_iv_ogm_send_to_if(struct forw_packet *forw_packet,
		struct hard_iface *hard_iface)
		{
		struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
		@@ -117,7 +117,7 @@ static void bat_ogm_send_to_if(struct forw_packet *forw_packet,
		batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data;

		/* adjust all flags and log packets */
		while (bat_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
		while (bat_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len,
		batman_ogm_packet->tt_num_changes)) {

		/* we might have aggregated direct link packets with an
		@@ -137,7 +137,7 @@ static void bat_ogm_send_to_if(struct forw_packet *forw_packet,
		fwd_str, (packet_num > 0 ? "aggregated " : ""),
		batman_ogm_packet->orig,
		ntohl(batman_ogm_packet->seqno),
		batman_ogm_packet->tq, batman_ogm_packet->ttl,
		batman_ogm_packet->tq, batman_ogm_packet->header.ttl,
		(batman_ogm_packet->flags & DIRECTLINK ?
		"on" : "off"),
		batman_ogm_packet->ttvn, hard_iface->net_dev->name,
		@@ -157,7 +157,7 @@ static void bat_ogm_send_to_if(struct forw_packet *forw_packet,
		}

		/* send a batman ogm packet */
		void bat_ogm_emit(struct forw_packet *forw_packet)
		static void bat_iv_ogm_emit(struct forw_packet *forw_packet)
		{
		struct hard_iface *hard_iface;
		struct net_device *soft_iface;
		@@ -188,7 +188,7 @@ void bat_ogm_emit(struct forw_packet *forw_packet)

		/* multihomed peer assumed */
		/* non-primary OGMs are only broadcasted on their interface */
		if ((directlink && (batman_ogm_packet->ttl == 1)) \|\|
		if ((directlink && (batman_ogm_packet->header.ttl == 1)) \|\|
		(forw_packet->own && (forw_packet->if_incoming != primary_if))) {

		/* FIXME: what about aggregated packets ? */
		@@ -198,7 +198,7 @@ void bat_ogm_emit(struct forw_packet *forw_packet)
		(forw_packet->own ? "Sending own" : "Forwarding"),
		batman_ogm_packet->orig,
		ntohl(batman_ogm_packet->seqno),
		batman_ogm_packet->ttl,
		batman_ogm_packet->header.ttl,
		forw_packet->if_incoming->net_dev->name,
		forw_packet->if_incoming->net_dev->dev_addr);

		@@ -216,7 +216,7 @@ void bat_ogm_emit(struct forw_packet *forw_packet)
		if (hard_iface->soft_iface != soft_iface)
		continue;

		bat_ogm_send_to_if(forw_packet, hard_iface);
		bat_iv_ogm_send_to_if(forw_packet, hard_iface);
		}
		rcu_read_unlock();

		@@ -226,7 +226,7 @@ void bat_ogm_emit(struct forw_packet *forw_packet)
		}

		/* return true if new_packet can be aggregated with forw_packet */
		static bool bat_ogm_can_aggregate(const struct batman_ogm_packet
		static bool bat_iv_ogm_can_aggregate(const struct batman_ogm_packet
		*new_batman_ogm_packet,
		struct bat_priv *bat_priv,
		int packet_len, unsigned long send_time,
		@@ -272,7 +272,7 @@ static bool bat_ogm_can_aggregate(const struct batman_ogm_packet
		* are flooded through the net */
		if ((!directlink) &&
		(!(batman_ogm_packet->flags & DIRECTLINK)) &&
		(batman_ogm_packet->ttl != 1) &&
		(batman_ogm_packet->header.ttl != 1) &&

		/* own packets originating non-primary
		* interfaces leave only that interface */
		@@ -285,7 +285,7 @@ static bool bat_ogm_can_aggregate(const struct batman_ogm_packet
		/* if the incoming packet is sent via this one
		* interface only - we still can aggregate */
		if ((directlink) &&
		(new_batman_ogm_packet->ttl == 1) &&
		(new_batman_ogm_packet->header.ttl == 1) &&
		(forw_packet->if_incoming == if_incoming) &&

		/* packets from direct neighbors or
		@@ -306,7 +306,7 @@ static bool bat_ogm_can_aggregate(const struct batman_ogm_packet
		}

		/* create a new aggregated packet and add this packet to it */
		static void bat_ogm_aggregate_new(const unsigned char *packet_buff,
		static void bat_iv_ogm_aggregate_new(const unsigned char *packet_buff,
		int packet_len, unsigned long send_time,
		bool direct_link,
		struct hard_iface *if_incoming,
		@@ -385,7 +385,7 @@ static void bat_ogm_aggregate_new(const unsigned char *packet_buff,
		}

		/* aggregate a new packet into the existing ogm packet */
		static void bat_ogm_aggregate(struct forw_packet *forw_packet_aggr,
		static void bat_iv_ogm_aggregate(struct forw_packet *forw_packet_aggr,
		const unsigned char *packet_buff,
		int packet_len, bool direct_link)
		{
		@@ -402,7 +402,7 @@ static void bat_ogm_aggregate(struct forw_packet *forw_packet_aggr,
		(1 << forw_packet_aggr->num_packets);
		}

		static void bat_ogm_queue_add(struct bat_priv *bat_priv,
		static void bat_iv_ogm_queue_add(struct bat_priv *bat_priv,
		unsigned char *packet_buff,
		int packet_len, struct hard_iface *if_incoming,
		int own_packet, unsigned long send_time)
		@@ -425,7 +425,7 @@ static void bat_ogm_queue_add(struct bat_priv *bat_priv,
		if ((atomic_read(&bat_priv->aggregated_ogms)) && (!own_packet)) {
		hlist_for_each_entry(forw_packet_pos, tmp_node,
		&bat_priv->forw_bat_list, list) {
		if (bat_ogm_can_aggregate(batman_ogm_packet,
		if (bat_iv_ogm_can_aggregate(batman_ogm_packet,
		bat_priv, packet_len,
		send_time, direct_link,
		if_incoming,
		@@ -451,17 +451,17 @@ static void bat_ogm_queue_add(struct bat_priv *bat_priv,
		(atomic_read(&bat_priv->aggregated_ogms)))
		send_time += msecs_to_jiffies(MAX_AGGREGATION_MS);

		bat_ogm_aggregate_new(packet_buff, packet_len,
		bat_iv_ogm_aggregate_new(packet_buff, packet_len,
		send_time, direct_link,
		if_incoming, own_packet);
		} else {
		bat_ogm_aggregate(forw_packet_aggr, packet_buff, packet_len,
		direct_link);
		bat_iv_ogm_aggregate(forw_packet_aggr, packet_buff,
		packet_len, direct_link);
		spin_unlock_bh(&bat_priv->forw_bat_list_lock);
		}
		}

		static void bat_ogm_forward(struct orig_node *orig_node,
		static void bat_iv_ogm_forward(struct orig_node *orig_node,
		const struct ethhdr *ethhdr,
		struct batman_ogm_packet *batman_ogm_packet,
		int directlink, struct hard_iface *if_incoming)
		@@ -471,7 +471,7 @@ static void bat_ogm_forward(struct orig_node *orig_node,
		uint8_t in_tq, in_ttl, tq_avg = 0;
		uint8_t tt_num_changes;

		if (batman_ogm_packet->ttl <= 1) {
		if (batman_ogm_packet->header.ttl <= 1) {
		bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
		return;
		}
		@@ -479,10 +479,10 @@ static void bat_ogm_forward(struct orig_node *orig_node,
		router = orig_node_get_router(orig_node);

		in_tq = batman_ogm_packet->tq;
		in_ttl = batman_ogm_packet->ttl;
		in_ttl = batman_ogm_packet->header.ttl;
		tt_num_changes = batman_ogm_packet->tt_num_changes;

		batman_ogm_packet->ttl--;
		batman_ogm_packet->header.ttl--;
		memcpy(batman_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN);

		/* rebroadcast tq of our best ranking neighbor to ensure the rebroadcast
		@@ -494,7 +494,8 @@ static void bat_ogm_forward(struct orig_node *orig_node,
		batman_ogm_packet->tq = router->tq_avg;

		if (router->last_ttl)
		batman_ogm_packet->ttl = router->last_ttl - 1;
		batman_ogm_packet->header.ttl =
		router->last_ttl - 1;
		}

		tq_avg = router->tq_avg;
		@@ -510,7 +511,7 @@ static void bat_ogm_forward(struct orig_node *orig_node,
		"Forwarding packet: tq_orig: %i, tq_avg: %i, "
		"tq_forw: %i, ttl_orig: %i, ttl_forw: %i\n",
		in_tq, tq_avg, batman_ogm_packet->tq, in_ttl - 1,
		batman_ogm_packet->ttl);
		batman_ogm_packet->header.ttl);

		batman_ogm_packet->seqno = htonl(batman_ogm_packet->seqno);
		batman_ogm_packet->tt_crc = htons(batman_ogm_packet->tt_crc);
		@@ -522,12 +523,13 @@ static void bat_ogm_forward(struct orig_node *orig_node,
		else
		batman_ogm_packet->flags &= ~DIRECTLINK;

		bat_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet,
		bat_iv_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet,
		BATMAN_OGM_LEN + tt_len(tt_num_changes),
		if_incoming, 0, bat_ogm_fwd_send_time());
		if_incoming, 0, bat_iv_ogm_fwd_send_time());
		}

		void bat_ogm_schedule(struct hard_iface *hard_iface, int tt_num_changes)
		static void bat_iv_ogm_schedule(struct hard_iface *hard_iface,
		int tt_num_changes)
		{
		struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface);
		struct batman_ogm_packet *batman_ogm_packet;
		@@ -564,21 +566,22 @@ void bat_ogm_schedule(struct hard_iface *hard_iface, int tt_num_changes)
		atomic_inc(&hard_iface->seqno);

		slide_own_bcast_window(hard_iface);
		bat_ogm_queue_add(bat_priv, hard_iface->packet_buff,
		bat_iv_ogm_queue_add(bat_priv, hard_iface->packet_buff,
		hard_iface->packet_len, hard_iface, 1,
		bat_ogm_emit_send_time(bat_priv));
		bat_iv_ogm_emit_send_time(bat_priv));

		if (primary_if)
		hardif_free_ref(primary_if);
		}

		static void bat_ogm_orig_update(struct bat_priv *bat_priv,
		static void bat_iv_ogm_orig_update(struct bat_priv *bat_priv,
		struct orig_node *orig_node,
		const struct ethhdr *ethhdr,
		const struct batman_ogm_packet
		*batman_ogm_packet,
		struct hard_iface *if_incoming,
		const unsigned char *tt_buff, int is_duplicate)
		const unsigned char *tt_buff,
		int is_duplicate)
		{
		struct neigh_node neigh_node = NULL, tmp_neigh_node = NULL;
		struct neigh_node *router = NULL;
		@@ -642,8 +645,8 @@ static void bat_ogm_orig_update(struct bat_priv *bat_priv,
		spin_unlock_bh(&neigh_node->tq_lock);

		if (!is_duplicate) {
		orig_node->last_ttl = batman_ogm_packet->ttl;
		neigh_node->last_ttl = batman_ogm_packet->ttl;
		orig_node->last_ttl = batman_ogm_packet->header.ttl;
		neigh_node->last_ttl = batman_ogm_packet->header.ttl;
		}

		bonding_candidate_add(orig_node, neigh_node);
		@@ -683,7 +686,7 @@ static void bat_ogm_orig_update(struct bat_priv *bat_priv,
		/* I have to check for transtable changes only if the OGM has been
		* sent through a primary interface */
		if (((batman_ogm_packet->orig != ethhdr->h_source) &&
		(batman_ogm_packet->ttl > 2)) \|\|
		(batman_ogm_packet->header.ttl > 2)) \|\|
		(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP))
		tt_update_orig(bat_priv, orig_node, tt_buff,
		batman_ogm_packet->tt_num_changes,
		@@ -713,7 +716,7 @@ static void bat_ogm_orig_update(struct bat_priv *bat_priv,
		neigh_node_free_ref(router);
		}

		static int bat_ogm_calc_tq(struct orig_node *orig_node,
		static int bat_iv_ogm_calc_tq(struct orig_node *orig_node,
		struct orig_node *orig_neigh_node,
		struct batman_ogm_packet *batman_ogm_packet,
		struct hard_iface *if_incoming)
		@@ -825,7 +828,7 @@ static int bat_ogm_calc_tq(struct orig_node *orig_node,
		* -1 the packet is old and has been received while the seqno window
		* was protected. Caller should drop it.
		*/
		static int bat_ogm_update_seqnos(const struct ethhdr *ethhdr,
		static int bat_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
		const struct batman_ogm_packet
		*batman_ogm_packet,
		const struct hard_iface *if_incoming)
		@@ -890,7 +893,7 @@ static int bat_ogm_update_seqnos(const struct ethhdr *ethhdr,
		return ret;
		}

		static void bat_ogm_process(const struct ethhdr *ethhdr,
		static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
		struct batman_ogm_packet *batman_ogm_packet,
		const unsigned char *tt_buff,
		struct hard_iface *if_incoming)
		@@ -918,7 +921,7 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,
		* packet in an aggregation. Here we expect that the padding
		* is always zero (or not 0x01)
		*/
		if (batman_ogm_packet->packet_type != BAT_OGM)
		if (batman_ogm_packet->header.packet_type != BAT_OGM)
		return;

		/* could be changed by schedule_own_packet() */
		@@ -938,8 +941,8 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,
		batman_ogm_packet->prev_sender, batman_ogm_packet->seqno,
		batman_ogm_packet->ttvn, batman_ogm_packet->tt_crc,
		batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq,
		batman_ogm_packet->ttl, batman_ogm_packet->version,
		has_directlink_flag);
		batman_ogm_packet->header.ttl,
		batman_ogm_packet->header.version, has_directlink_flag);

		rcu_read_lock();
		list_for_each_entry_rcu(hard_iface, &hardif_list, list) {
		@@ -966,10 +969,10 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,
		}
		rcu_read_unlock();

		if (batman_ogm_packet->version != COMPAT_VERSION) {
		if (batman_ogm_packet->header.version != COMPAT_VERSION) {
		bat_dbg(DBG_BATMAN, bat_priv,
		"Drop packet: incompatible batman version (%i)\n",
		batman_ogm_packet->version);
		batman_ogm_packet->header.version);
		return;
		}

		@@ -1031,7 +1034,7 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,
		if (!orig_node)
		return;

		is_duplicate = bat_ogm_update_seqnos(ethhdr, batman_ogm_packet,
		is_duplicate = bat_iv_ogm_update_seqnos(ethhdr, batman_ogm_packet,
		if_incoming);

		if (is_duplicate == -1) {
		@@ -1081,7 +1084,7 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,
		goto out_neigh;
		}

		is_bidirectional = bat_ogm_calc_tq(orig_node, orig_neigh_node,
		is_bidirectional = bat_iv_ogm_calc_tq(orig_node, orig_neigh_node,
		batman_ogm_packet, if_incoming);

		bonding_save_primary(orig_node, orig_neigh_node, batman_ogm_packet);
		@@ -1091,8 +1094,8 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,
		if (is_bidirectional &&
		(!is_duplicate \|\|
		((orig_node->last_real_seqno == batman_ogm_packet->seqno) &&
		(orig_node->last_ttl - 3 <= batman_ogm_packet->ttl))))
		bat_ogm_orig_update(bat_priv, orig_node, ethhdr,
		(orig_node->last_ttl - 3 <= batman_ogm_packet->header.ttl))))
		bat_iv_ogm_orig_update(bat_priv, orig_node, ethhdr,
		batman_ogm_packet, if_incoming,
		tt_buff, is_duplicate);

		@@ -1100,7 +1103,7 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,
		if (is_single_hop_neigh) {

		/* mark direct link on incoming interface */
		bat_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
		bat_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
		1, if_incoming);

		bat_dbg(DBG_BATMAN, bat_priv, "Forwarding packet: "
		@@ -1123,7 +1126,8 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,

		bat_dbg(DBG_BATMAN, bat_priv,
		"Forwarding packet: rebroadcast originator packet\n");
		bat_ogm_forward(orig_node, ethhdr, batman_ogm_packet, 0, if_incoming);
		bat_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
		0, if_incoming);

		out_neigh:
		if ((orig_neigh_node) && (!is_single_hop_neigh))
		@@ -1139,13 +1143,17 @@ static void bat_ogm_process(const struct ethhdr *ethhdr,
		orig_node_free_ref(orig_node);
		}

		void bat_ogm_receive(const struct ethhdr ethhdr, unsigned char packet_buff,
		int packet_len, struct hard_iface *if_incoming)
		static void bat_iv_ogm_receive(struct hard_iface *if_incoming,
		struct sk_buff *skb)
		{
		struct batman_ogm_packet *batman_ogm_packet;
		int buff_pos = 0;
		unsigned char *tt_buff;
		struct ethhdr *ethhdr;
		int buff_pos = 0, packet_len;
		unsigned char tt_buff, packet_buff;

		packet_len = skb_headlen(skb);
		ethhdr = (struct ethhdr *)skb_mac_header(skb);
		packet_buff = skb->data;
		batman_ogm_packet = (struct batman_ogm_packet *)packet_buff;

		/* unpack the aggregated packets and process them one by one */
		@@ -1157,7 +1165,7 @@ void bat_ogm_receive(const struct ethhdr ethhdr, unsigned char packet_buff,

		tt_buff = packet_buff + buff_pos + BATMAN_OGM_LEN;

		bat_ogm_process(ethhdr, batman_ogm_packet,
		bat_iv_ogm_process(ethhdr, batman_ogm_packet,
		tt_buff, if_incoming);

		buff_pos += BATMAN_OGM_LEN +
		@@ -1165,6 +1173,21 @@ void bat_ogm_receive(const struct ethhdr ethhdr, unsigned char packet_buff,

		batman_ogm_packet = (struct batman_ogm_packet *)
		(packet_buff + buff_pos);
		} while (bat_ogm_aggr_packet(buff_pos, packet_len,
		} while (bat_iv_ogm_aggr_packet(buff_pos, packet_len,
		batman_ogm_packet->tt_num_changes));
		}

		static struct bat_algo_ops batman_iv __read_mostly = {
		.name = "BATMAN IV",
		.bat_ogm_init = bat_iv_ogm_init,
		.bat_ogm_init_primary = bat_iv_ogm_init_primary,
		.bat_ogm_update_mac = bat_iv_ogm_update_mac,
		.bat_ogm_schedule = bat_iv_ogm_schedule,
		.bat_ogm_emit = bat_iv_ogm_emit,
		.bat_ogm_receive = bat_iv_ogm_receive,
		};

		int __init bat_iv_init(void)
		{
		return bat_algo_register(&batman_iv);
		}

net/batman-adv/bat_sysfs.c

+9 −0

Original line number	Diff line number	Diff line
		@@ -272,6 +272,13 @@ static ssize_t store_vis_mode(struct kobject kobj, struct attribute attr,
		return count;
		}

		static ssize_t show_bat_algo(struct kobject kobj, struct attribute attr,
		char *buff)
		{
		struct bat_priv *bat_priv = kobj_to_batpriv(kobj);
		return sprintf(buff, "%s\n", bat_priv->bat_algo_ops->name);
		}

		static void post_gw_deselect(struct net_device *net_dev)
		{
		struct bat_priv *bat_priv = netdev_priv(net_dev);
		@@ -382,6 +389,7 @@ BAT_ATTR_BOOL(bonding, S_IRUGO \| S_IWUSR, NULL);
		BAT_ATTR_BOOL(fragmentation, S_IRUGO \| S_IWUSR, update_min_mtu);
		BAT_ATTR_BOOL(ap_isolation, S_IRUGO \| S_IWUSR, NULL);
		static BAT_ATTR(vis_mode, S_IRUGO \| S_IWUSR, show_vis_mode, store_vis_mode);
		static BAT_ATTR(routing_algo, S_IRUGO, show_bat_algo, NULL);
		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(hop_penalty, S_IRUGO \| S_IWUSR, 0, TQ_MAX_VALUE, NULL);
		@@ -399,6 +407,7 @@ static struct bat_attribute *mesh_attrs[] = {
		&bat_attr_fragmentation,
		&bat_attr_ap_isolation,
		&bat_attr_vis_mode,
		&bat_attr_routing_algo,
		&bat_attr_gw_mode,
		&bat_attr_orig_interval,
		&bat_attr_hop_penalty,