batman-adv: Prefix main static inline functions with batadv_ (1eda58bf) · Commits · e / devices / android_kernel_teracube_2e

net/batman-adv/bat_iv_ogm.c

+107 −99

Original line number	Original line	Diff line number	Diff line
	@@ -179,7 +179,7 @@ static void bat_iv_ogm_send_to_if(struct forw_packet *forw_packet,
	fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ?		fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ?
	"Sending own" :		"Sending own" :
	"Forwarding"));		"Forwarding"));
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s, ttvn %d) on interface %s [%pM]\n",		"%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s, ttvn %d) on interface %s [%pM]\n",
	fwd_str, (packet_num > 0 ? "aggregated " : ""),		fwd_str, (packet_num > 0 ? "aggregated " : ""),
	batman_ogm_packet->orig,		batman_ogm_packet->orig,
	@@ -243,7 +243,7 @@ static void bat_iv_ogm_emit(struct forw_packet *forw_packet)
	(forw_packet->own && (forw_packet->if_incoming != primary_if))) {		(forw_packet->own && (forw_packet->if_incoming != primary_if))) {

	/* FIXME: what about aggregated packets ? */		/* FIXME: what about aggregated packets ? */
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"%s packet (originator %pM, seqno %u, TTL %d) on interface %s [%pM]\n",		"%s packet (originator %pM, seqno %u, TTL %d) on interface %s [%pM]\n",
	(forw_packet->own ? "Sending own" : "Forwarding"),		(forw_packet->own ? "Sending own" : "Forwarding"),
	batman_ogm_packet->orig,		batman_ogm_packet->orig,
	@@ -373,7 +373,7 @@ static void bat_iv_ogm_aggregate_new(const unsigned char *packet_buff,
	/* own packet should always be scheduled */		/* own packet should always be scheduled */
	if (!own_packet) {		if (!own_packet) {
	if (!atomic_dec_not_zero(&bat_priv->batman_queue_left)) {		if (!atomic_dec_not_zero(&bat_priv->batman_queue_left)) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"batman packet queue full\n");		"batman packet queue full\n");
	goto out;		goto out;
	}		}
	@@ -521,7 +521,7 @@ static void bat_iv_ogm_forward(struct orig_node *orig_node,
	uint8_t tt_num_changes;		uint8_t tt_num_changes;

	if (batman_ogm_packet->header.ttl <= 1) {		if (batman_ogm_packet->header.ttl <= 1) {
	bat_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");		batadv_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n");
	return;		return;
	}		}

	@@ -546,7 +546,7 @@ static void bat_iv_ogm_forward(struct orig_node *orig_node,
	/* apply hop penalty */		/* apply hop penalty */
	batman_ogm_packet->tq = hop_penalty(batman_ogm_packet->tq, bat_priv);		batman_ogm_packet->tq = hop_penalty(batman_ogm_packet->tq, bat_priv);

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Forwarding packet: tq: %i, ttl: %i\n",		"Forwarding packet: tq: %i, ttl: %i\n",
	batman_ogm_packet->tq, batman_ogm_packet->header.ttl);		batman_ogm_packet->tq, batman_ogm_packet->header.ttl);

	@@ -625,15 +625,17 @@ static void bat_iv_ogm_orig_update(struct bat_priv *bat_priv,
	struct orig_node *orig_node_tmp;		struct orig_node *orig_node_tmp;
	struct hlist_node *node;		struct hlist_node *node;
	uint8_t bcast_own_sum_orig, bcast_own_sum_neigh;		uint8_t bcast_own_sum_orig, bcast_own_sum_neigh;
			uint8_t *neigh_addr;

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"update_originator(): Searching and updating originator entry of received packet\n");		"update_originator(): Searching and updating originator entry of received packet\n");

	rcu_read_lock();		rcu_read_lock();
	hlist_for_each_entry_rcu(tmp_neigh_node, node,		hlist_for_each_entry_rcu(tmp_neigh_node, node,
	&orig_node->neigh_list, list) {		&orig_node->neigh_list, list) {
	if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&		neigh_addr = tmp_neigh_node->addr;
	(tmp_neigh_node->if_incoming == if_incoming) &&		if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
			tmp_neigh_node->if_incoming == if_incoming &&
	atomic_inc_not_zero(&tmp_neigh_node->refcount)) {		atomic_inc_not_zero(&tmp_neigh_node->refcount)) {
	if (neigh_node)		if (neigh_node)
	batadv_neigh_node_free_ref(neigh_node);		batadv_neigh_node_free_ref(neigh_node);
	@@ -667,7 +669,7 @@ static void bat_iv_ogm_orig_update(struct bat_priv *bat_priv,
	if (!neigh_node)		if (!neigh_node)
	goto unlock;		goto unlock;
	} else		} else
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Updating existing last-hop neighbor of originator\n");		"Updating existing last-hop neighbor of originator\n");

	rcu_read_unlock();		rcu_read_unlock();
	@@ -774,7 +776,8 @@ static int bat_iv_ogm_calc_tq(struct orig_node *orig_node,
	hlist_for_each_entry_rcu(tmp_neigh_node, node,		hlist_for_each_entry_rcu(tmp_neigh_node, node,
	&orig_neigh_node->neigh_list, list) {		&orig_neigh_node->neigh_list, list) {

	if (!compare_eth(tmp_neigh_node->addr, orig_neigh_node->orig))		if (!batadv_compare_eth(tmp_neigh_node->addr,
			orig_neigh_node->orig))
	continue;		continue;

	if (tmp_neigh_node->if_incoming != if_incoming)		if (tmp_neigh_node->if_incoming != if_incoming)
	@@ -844,10 +847,11 @@ static int bat_iv_ogm_calc_tq(struct orig_node *orig_node,
	* tq_asym_penalty) /		* tq_asym_penalty) /
	(TQ_MAX_VALUE * TQ_MAX_VALUE));		(TQ_MAX_VALUE * TQ_MAX_VALUE));

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"bidirectional: orig = %-15pM neigh = %-15pM => own_bcast = %2i, real recv = %2i, local tq: %3i, asym_penalty: %3i, total tq: %3i\n",		"bidirectional: orig = %-15pM neigh = %-15pM => own_bcast = %2i, real recv = %2i, local tq: %3i, asym_penalty: %3i, total tq: %3i\n",
	orig_node->orig, orig_neigh_node->orig, total_count,		orig_node->orig, orig_neigh_node->orig, total_count,
	neigh_rq_count, tq_own, tq_asym_penalty, batman_ogm_packet->tq);		neigh_rq_count, tq_own,
			tq_asym_penalty, batman_ogm_packet->tq);

	/* if link has the minimum required transmission quality		/* if link has the minimum required transmission quality
	* consider it bidirectional		* consider it bidirectional
	@@ -883,6 +887,7 @@ static int bat_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
	int need_update = 0;		int need_update = 0;
	int set_mark, ret = -1;		int set_mark, ret = -1;
	uint32_t seqno = ntohl(batman_ogm_packet->seqno);		uint32_t seqno = ntohl(batman_ogm_packet->seqno);
			uint8_t *neigh_addr;

	orig_node = batadv_get_orig_node(bat_priv, batman_ogm_packet->orig);		orig_node = batadv_get_orig_node(bat_priv, batman_ogm_packet->orig);
	if (!orig_node)		if (!orig_node)
	@@ -905,8 +910,9 @@ static int bat_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
	orig_node->last_real_seqno,		orig_node->last_real_seqno,
	seqno);		seqno);

	if (compare_eth(tmp_neigh_node->addr, ethhdr->h_source) &&		neigh_addr = tmp_neigh_node->addr;
	(tmp_neigh_node->if_incoming == if_incoming))		if (batadv_compare_eth(neigh_addr, ethhdr->h_source) &&
			tmp_neigh_node->if_incoming == if_incoming)
	set_mark = 1;		set_mark = 1;
	else		else
	set_mark = 0;		set_mark = 0;
	@@ -923,7 +929,7 @@ static int bat_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
	rcu_read_unlock();		rcu_read_unlock();

	if (need_update) {		if (need_update) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"updating last_seqno: old %u, new %u\n",		"updating last_seqno: old %u, new %u\n",
	orig_node->last_real_seqno, seqno);		orig_node->last_real_seqno, seqno);
	orig_node->last_real_seqno = seqno;		orig_node->last_real_seqno = seqno;
	@@ -954,6 +960,7 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	bool is_from_best_next_hop = false;		bool is_from_best_next_hop = false;
	int is_duplicate;		int is_duplicate;
	uint32_t if_incoming_seqno;		uint32_t if_incoming_seqno;
			uint8_t *prev_sender;

	/* Silently drop when the batman packet is actually not a		/* Silently drop when the batman packet is actually not a
	* correct packet.		* correct packet.
	@@ -975,15 +982,16 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,

	has_directlink_flag = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0);		has_directlink_flag = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0);

	if (compare_eth(ethhdr->h_source, batman_ogm_packet->orig))		if (batadv_compare_eth(ethhdr->h_source, batman_ogm_packet->orig))
	is_single_hop_neigh = true;		is_single_hop_neigh = true;

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, ttvn %u, crc %u, changes %u, td %d, TTL %d, V %d, IDF %d)\n",		"Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, ttvn %u, crc %u, changes %u, td %d, TTL %d, V %d, IDF %d)\n",
	ethhdr->h_source, if_incoming->net_dev->name,		ethhdr->h_source, if_incoming->net_dev->name,
	if_incoming->net_dev->dev_addr, batman_ogm_packet->orig,		if_incoming->net_dev->dev_addr, batman_ogm_packet->orig,
	batman_ogm_packet->prev_sender, ntohl(batman_ogm_packet->seqno),		batman_ogm_packet->prev_sender,
	batman_ogm_packet->ttvn, ntohs(batman_ogm_packet->tt_crc),		ntohl(batman_ogm_packet->seqno), batman_ogm_packet->ttvn,
			ntohs(batman_ogm_packet->tt_crc),
	batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq,		batman_ogm_packet->tt_num_changes, batman_ogm_packet->tq,
	batman_ogm_packet->header.ttl,		batman_ogm_packet->header.ttl,
	batman_ogm_packet->header.version, has_directlink_flag);		batman_ogm_packet->header.version, has_directlink_flag);
	@@ -996,15 +1004,15 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	if (hard_iface->soft_iface != if_incoming->soft_iface)		if (hard_iface->soft_iface != if_incoming->soft_iface)
	continue;		continue;

	if (compare_eth(ethhdr->h_source,		if (batadv_compare_eth(ethhdr->h_source,
	hard_iface->net_dev->dev_addr))		hard_iface->net_dev->dev_addr))
	is_my_addr = 1;		is_my_addr = 1;

	if (compare_eth(batman_ogm_packet->orig,		if (batadv_compare_eth(batman_ogm_packet->orig,
	hard_iface->net_dev->dev_addr))		hard_iface->net_dev->dev_addr))
	is_my_orig = 1;		is_my_orig = 1;

	if (compare_eth(batman_ogm_packet->prev_sender,		if (batadv_compare_eth(batman_ogm_packet->prev_sender,
	hard_iface->net_dev->dev_addr))		hard_iface->net_dev->dev_addr))
	is_my_oldorig = 1;		is_my_oldorig = 1;

	@@ -1014,21 +1022,21 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	rcu_read_unlock();		rcu_read_unlock();

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

	if (is_my_addr) {		if (is_my_addr) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: received my own broadcast (sender: %pM)\n",		"Drop packet: received my own broadcast (sender: %pM)\n",
	ethhdr->h_source);		ethhdr->h_source);
	return;		return;
	}		}

	if (is_broadcast) {		if (is_broadcast) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: ignoring all packets with broadcast source addr (sender: %pM)\n",		"Drop packet: ignoring all packets with broadcast source addr (sender: %pM)\n",
	ethhdr->h_source);		ethhdr->h_source);
	return;		return;
	@@ -1049,7 +1057,7 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	* save packet seqno for bidirectional check		* save packet seqno for bidirectional check
	*/		*/
	if (has_directlink_flag &&		if (has_directlink_flag &&
	compare_eth(if_incoming->net_dev->dev_addr,		batadv_compare_eth(if_incoming->net_dev->dev_addr,
	batman_ogm_packet->orig)) {		batman_ogm_packet->orig)) {
	offset = if_incoming->if_num * NUM_WORDS;		offset = if_incoming->if_num * NUM_WORDS;

	@@ -1063,21 +1071,21 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);		spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);
	}		}

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: originator packet from myself (via neighbor)\n");		"Drop packet: originator packet from myself (via neighbor)\n");
	batadv_orig_node_free_ref(orig_neigh_node);		batadv_orig_node_free_ref(orig_neigh_node);
	return;		return;
	}		}

	if (is_my_oldorig) {		if (is_my_oldorig) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: ignoring all rebroadcast echos (sender: %pM)\n",		"Drop packet: ignoring all rebroadcast echos (sender: %pM)\n",
	ethhdr->h_source);		ethhdr->h_source);
	return;		return;
	}		}

	if (batman_ogm_packet->flags & NOT_BEST_NEXT_HOP) {		if (batman_ogm_packet->flags & NOT_BEST_NEXT_HOP) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",		"Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n",
	ethhdr->h_source);		ethhdr->h_source);
	return;		return;
	@@ -1091,14 +1099,14 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	if_incoming);		if_incoming);

	if (is_duplicate == -1) {		if (is_duplicate == -1) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: packet within seqno protection time (sender: %pM)\n",		"Drop packet: packet within seqno protection time (sender: %pM)\n",
	ethhdr->h_source);		ethhdr->h_source);
	goto out;		goto out;
	}		}

	if (batman_ogm_packet->tq == 0) {		if (batman_ogm_packet->tq == 0) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: originator packet with tq equal 0\n");		"Drop packet: originator packet with tq equal 0\n");
	goto out;		goto out;
	}		}
	@@ -1108,16 +1116,16 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	router_router = batadv_orig_node_get_router(router->orig_node);		router_router = batadv_orig_node_get_router(router->orig_node);

	if ((router && router->tq_avg != 0) &&		if ((router && router->tq_avg != 0) &&
	(compare_eth(router->addr, ethhdr->h_source)))		(batadv_compare_eth(router->addr, ethhdr->h_source)))
	is_from_best_next_hop = true;		is_from_best_next_hop = true;

			prev_sender = batman_ogm_packet->prev_sender;
	/* avoid temporary routing loops */		/* avoid temporary routing loops */
	if (router && router_router &&		if (router && router_router &&
	(compare_eth(router->addr, batman_ogm_packet->prev_sender)) &&		(batadv_compare_eth(router->addr, prev_sender)) &&
	!(compare_eth(batman_ogm_packet->orig,		!(batadv_compare_eth(batman_ogm_packet->orig, prev_sender)) &&
	batman_ogm_packet->prev_sender)) &&		(batadv_compare_eth(router->addr, router_router->addr))) {
	(compare_eth(router->addr, router_router->addr))) {		batadv_dbg(DBG_BATMAN, bat_priv,
	bat_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",		"Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",
	ethhdr->h_source);		ethhdr->h_source);
	goto out;		goto out;
	@@ -1138,7 +1146,7 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	* don't route towards it		* don't route towards it
	*/		*/
	if (!is_single_hop_neigh && (!orig_neigh_router)) {		if (!is_single_hop_neigh && (!orig_neigh_router)) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: OGM via unknown neighbor!\n");		"Drop packet: OGM via unknown neighbor!\n");
	goto out_neigh;		goto out_neigh;
	}		}
	@@ -1168,25 +1176,25 @@ static void bat_iv_ogm_process(const struct ethhdr *ethhdr,
	is_single_hop_neigh, is_from_best_next_hop,		is_single_hop_neigh, is_from_best_next_hop,
	if_incoming);		if_incoming);

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Forwarding packet: rebroadcast neighbor packet with direct link flag\n");		"Forwarding packet: rebroadcast neighbor packet with direct link flag\n");
	goto out_neigh;		goto out_neigh;
	}		}

	/* multihop originator */		/* multihop originator */
	if (!is_bidirectional) {		if (!is_bidirectional) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: not received via bidirectional link\n");		"Drop packet: not received via bidirectional link\n");
	goto out_neigh;		goto out_neigh;
	}		}

	if (is_duplicate) {		if (is_duplicate) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Drop packet: duplicate packet received\n");		"Drop packet: duplicate packet received\n");
	goto out_neigh;		goto out_neigh;
	}		}

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Forwarding packet: rebroadcast originator packet\n");		"Forwarding packet: rebroadcast originator packet\n");
	bat_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,		bat_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet,
	is_single_hop_neigh, is_from_best_next_hop,		is_single_hop_neigh, is_from_best_next_hop,

net/batman-adv/bat_sysfs.c

+4 −4

Original line number	Original line	Diff line number	Diff line
	@@ -730,7 +730,7 @@ int batadv_throw_uevent(struct bat_priv *bat_priv, enum uev_type type,
	batadv_hardif_free_ref(primary_if);		batadv_hardif_free_ref(primary_if);

	if (ret)		if (ret)
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",		"Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
	uev_type_str[type], uev_action_str[action],		uev_type_str[type], uev_action_str[action],
	(action == UEV_DEL ? "NULL" : data), ret);		(action == UEV_DEL ? "NULL" : data), ret);

net/batman-adv/bitarray.c

+5 −5

Original line number	Original line	Diff line number	Diff line
	@@ -66,7 +66,7 @@ int batadv_bit_get_packet(void priv, unsigned long seq_bits,
	/* sequence number is much newer, probably missed a lot of packets */		/* sequence number is much newer, probably missed a lot of packets */
	if ((seq_num_diff >= TQ_LOCAL_WINDOW_SIZE) &&		if ((seq_num_diff >= TQ_LOCAL_WINDOW_SIZE) &&
	(seq_num_diff < EXPECTED_SEQNO_RANGE)) {		(seq_num_diff < EXPECTED_SEQNO_RANGE)) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"We missed a lot of packets (%i) !\n",		"We missed a lot of packets (%i) !\n",
	seq_num_diff - 1);		seq_num_diff - 1);
	bitmap_zero(seq_bits, TQ_LOCAL_WINDOW_SIZE);		bitmap_zero(seq_bits, TQ_LOCAL_WINDOW_SIZE);
	@@ -83,7 +83,7 @@ int batadv_bit_get_packet(void priv, unsigned long seq_bits,
	if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE) \|\|		if ((seq_num_diff <= -TQ_LOCAL_WINDOW_SIZE) \|\|
	(seq_num_diff >= EXPECTED_SEQNO_RANGE)) {		(seq_num_diff >= EXPECTED_SEQNO_RANGE)) {

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Other host probably restarted!\n");		"Other host probably restarted!\n");

	bitmap_zero(seq_bits, TQ_LOCAL_WINDOW_SIZE);		bitmap_zero(seq_bits, TQ_LOCAL_WINDOW_SIZE);

net/batman-adv/bridge_loop_avoidance.c

+84 −81

Original line number	Original line	Diff line number	Diff line
	@@ -294,7 +294,7 @@ static void bla_send_claim(struct bat_priv bat_priv, uint8_t mac,
	* set Ethernet SRC to the clients mac		* set Ethernet SRC to the clients mac
	*/		*/
	memcpy(ethhdr->h_source, mac, ETH_ALEN);		memcpy(ethhdr->h_source, mac, ETH_ALEN);
	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_send_claim(): CLAIM %pM on vid %d\n", mac, vid);		"bla_send_claim(): CLAIM %pM on vid %d\n", mac, vid);
	break;		break;
	case CLAIM_TYPE_DEL:		case CLAIM_TYPE_DEL:
	@@ -302,15 +302,16 @@ static void bla_send_claim(struct bat_priv bat_priv, uint8_t mac,
	* set HW SRC to the clients mac		* set HW SRC to the clients mac
	*/		*/
	memcpy(hw_src, mac, ETH_ALEN);		memcpy(hw_src, mac, ETH_ALEN);
	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_send_claim(): UNCLAIM %pM on vid %d\n", mac, vid);		"bla_send_claim(): UNCLAIM %pM on vid %d\n", mac,
			vid);
	break;		break;
	case CLAIM_TYPE_ANNOUNCE:		case CLAIM_TYPE_ANNOUNCE:
	/* announcement frame		/* announcement frame
	* set HW SRC to the special mac containg the crc		* set HW SRC to the special mac containg the crc
	*/		*/
	memcpy(hw_src, mac, ETH_ALEN);		memcpy(hw_src, mac, ETH_ALEN);
	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_send_claim(): ANNOUNCE of %pM on vid %d\n",		"bla_send_claim(): ANNOUNCE of %pM on vid %d\n",
	ethhdr->h_source, vid);		ethhdr->h_source, vid);
	break;		break;
	@@ -320,7 +321,7 @@ static void bla_send_claim(struct bat_priv bat_priv, uint8_t mac,
	*/		*/
	memcpy(hw_src, mac, ETH_ALEN);		memcpy(hw_src, mac, ETH_ALEN);
	memcpy(ethhdr->h_dest, mac, ETH_ALEN);		memcpy(ethhdr->h_dest, mac, ETH_ALEN);
	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_send_claim(): REQUEST of %pM to %pMon vid %d\n",		"bla_send_claim(): REQUEST of %pM to %pMon vid %d\n",
	ethhdr->h_source, ethhdr->h_dest, vid);		ethhdr->h_source, ethhdr->h_dest, vid);
	break;		break;
	@@ -361,7 +362,7 @@ static struct backbone_gw bla_get_backbone_gw(struct bat_priv bat_priv,
	if (entry)		if (entry)
	return entry;		return entry;

	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_get_backbone_gw(): not found (%pM, %d), creating new entry\n",		"bla_get_backbone_gw(): not found (%pM, %d), creating new entry\n",
	orig, vid);		orig, vid);

	@@ -433,7 +434,7 @@ static void bla_answer_request(struct bat_priv *bat_priv,
	struct backbone_gw *backbone_gw;		struct backbone_gw *backbone_gw;
	int i;		int i;

	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_answer_request(): received a claim request, send all of our own claims again\n");		"bla_answer_request(): received a claim request, send all of our own claims again\n");

	backbone_gw = backbone_hash_find(bat_priv,		backbone_gw = backbone_hash_find(bat_priv,
	@@ -473,8 +474,7 @@ static void bla_send_request(struct backbone_gw *backbone_gw)
	/* first, remove all old entries */		/* first, remove all old entries */
	bla_del_backbone_claims(backbone_gw);		bla_del_backbone_claims(backbone_gw);

	bat_dbg(DBG_BLA, backbone_gw->bat_priv,		batadv_dbg(DBG_BLA, backbone_gw->bat_priv, "Sending REQUEST to %pM\n",
	"Sending REQUEST to %pM\n",
	backbone_gw->orig);		backbone_gw->orig);

	/* send request */		/* send request */
	@@ -538,7 +538,7 @@ static void bla_add_claim(struct bat_priv bat_priv, const uint8_t mac,
	claim->backbone_gw = backbone_gw;		claim->backbone_gw = backbone_gw;

	atomic_set(&claim->refcount, 2);		atomic_set(&claim->refcount, 2);
	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_add_claim(): adding new entry %pM, vid %d to hash ...\n",		"bla_add_claim(): adding new entry %pM, vid %d to hash ...\n",
	mac, vid);		mac, vid);
	hash_added = batadv_hash_add(bat_priv->claim_hash,		hash_added = batadv_hash_add(bat_priv->claim_hash,
	@@ -556,7 +556,7 @@ static void bla_add_claim(struct bat_priv bat_priv, const uint8_t mac,
	/* no need to register a new backbone */		/* no need to register a new backbone */
	goto claim_free_ref;		goto claim_free_ref;

	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_add_claim(): changing ownership for %pM, vid %d\n",		"bla_add_claim(): changing ownership for %pM, vid %d\n",
	mac, vid);		mac, vid);

	@@ -590,7 +590,8 @@ static void bla_del_claim(struct bat_priv bat_priv, const uint8_t mac,
	if (!claim)		if (!claim)
	return;		return;

	bat_dbg(DBG_BLA, bat_priv, "bla_del_claim(): %pM, vid %d\n", mac, vid);		batadv_dbg(DBG_BLA, bat_priv, "bla_del_claim(): %pM, vid %d\n", mac,
			vid);

	batadv_hash_remove(bat_priv->claim_hash, compare_claim, choose_claim,		batadv_hash_remove(bat_priv->claim_hash, compare_claim, choose_claim,
	claim);		claim);
	@@ -622,15 +623,15 @@ static int handle_announce(struct bat_priv *bat_priv,
	backbone_gw->lasttime = jiffies;		backbone_gw->lasttime = jiffies;
	crc = ntohs(((__be16 )(&an_addr[4])));		crc = ntohs(((__be16 )(&an_addr[4])));

	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"handle_announce(): ANNOUNCE vid %d (sent by %pM)... CRC = %04x\n",		"handle_announce(): ANNOUNCE vid %d (sent by %pM)... CRC = %04x\n",
	vid, backbone_gw->orig, crc);		vid, backbone_gw->orig, crc);

	if (backbone_gw->crc != crc) {		if (backbone_gw->crc != crc) {
	bat_dbg(DBG_BLA, backbone_gw->bat_priv,		batadv_dbg(DBG_BLA, backbone_gw->bat_priv,
	"handle_announce(): CRC FAILED for %pM/%d (my = %04x, sent = %04x)\n",		"handle_announce(): CRC FAILED for %pM/%d (my = %04x, sent = %04x)\n",
	backbone_gw->orig, backbone_gw->vid, backbone_gw->crc,		backbone_gw->orig, backbone_gw->vid,
	crc);		backbone_gw->crc, crc);

	bla_send_request(backbone_gw);		bla_send_request(backbone_gw);
	} else {		} else {
	@@ -654,16 +655,16 @@ static int handle_request(struct bat_priv *bat_priv,
	struct ethhdr *ethhdr, short vid)		struct ethhdr *ethhdr, short vid)
	{		{
	/* check for REQUEST frame */		/* check for REQUEST frame */
	if (!compare_eth(backbone_addr, ethhdr->h_dest))		if (!batadv_compare_eth(backbone_addr, ethhdr->h_dest))
	return 0;		return 0;

	/* sanity check, this should not happen on a normal switch,		/* sanity check, this should not happen on a normal switch,
	* we ignore it in this case.		* we ignore it in this case.
	*/		*/
	if (!compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))		if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
	return 1;		return 1;

	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"handle_request(): REQUEST vid %d (sent by %pM)...\n",		"handle_request(): REQUEST vid %d (sent by %pM)...\n",
	vid, ethhdr->h_source);		vid, ethhdr->h_source);

	@@ -680,7 +681,7 @@ static int handle_unclaim(struct bat_priv *bat_priv,
	struct backbone_gw *backbone_gw;		struct backbone_gw *backbone_gw;

	/* unclaim in any case if it is our own */		/* unclaim in any case if it is our own */
	if (primary_if && compare_eth(backbone_addr,		if (primary_if && batadv_compare_eth(backbone_addr,
	primary_if->net_dev->dev_addr))		primary_if->net_dev->dev_addr))
	bla_send_claim(bat_priv, claim_addr, vid, CLAIM_TYPE_DEL);		bla_send_claim(bat_priv, claim_addr, vid, CLAIM_TYPE_DEL);

	@@ -690,7 +691,7 @@ static int handle_unclaim(struct bat_priv *bat_priv,
	return 1;		return 1;

	/* this must be an UNCLAIM frame */		/* this must be an UNCLAIM frame */
	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"handle_unclaim(): UNCLAIM %pM on vid %d (sent by %pM)...\n",		"handle_unclaim(): UNCLAIM %pM on vid %d (sent by %pM)...\n",
	claim_addr, vid, backbone_gw->orig);		claim_addr, vid, backbone_gw->orig);

	@@ -715,7 +716,7 @@ static int handle_claim(struct bat_priv *bat_priv,

	/* this must be a CLAIM frame */		/* this must be a CLAIM frame */
	bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);		bla_add_claim(bat_priv, claim_addr, vid, backbone_gw);
	if (compare_eth(backbone_addr, primary_if->net_dev->dev_addr))		if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
	bla_send_claim(bat_priv, claim_addr, vid, CLAIM_TYPE_ADD);		bla_send_claim(bat_priv, claim_addr, vid, CLAIM_TYPE_ADD);

	/* TODO: we could call something like tt_local_del() here. */		/* TODO: we could call something like tt_local_del() here. */
	@@ -772,7 +773,7 @@ static int check_claim_group(struct bat_priv *bat_priv,
	}		}

	/* don't accept claim frames from ourselves */		/* don't accept claim frames from ourselves */
	if (compare_eth(backbone_addr, primary_if->net_dev->dev_addr))		if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr))
	return 0;		return 0;

	/* if its already the same group, it is fine. */		/* if its already the same group, it is fine. */
	@@ -790,7 +791,7 @@ static int check_claim_group(struct bat_priv *bat_priv,

	/* if our mesh friends mac is bigger, use it for ourselves. */		/* if our mesh friends mac is bigger, use it for ourselves. */
	if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {		if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"taking other backbones claim group: %04x\n",		"taking other backbones claim group: %04x\n",
	ntohs(bla_dst->group));		ntohs(bla_dst->group));
	bla_dst_own->group = bla_dst->group;		bla_dst_own->group = bla_dst->group;
	@@ -867,7 +868,7 @@ static int bla_process_claim(struct bat_priv *bat_priv,
	/* check if it is a claim frame. */		/* check if it is a claim frame. */
	ret = check_claim_group(bat_priv, primary_if, hw_src, hw_dst, ethhdr);		ret = check_claim_group(bat_priv, primary_if, hw_src, hw_dst, ethhdr);
	if (ret == 1)		if (ret == 1)
	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_process_claim(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",		"bla_process_claim(): received a claim frame from another group. From: %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
	ethhdr->h_source, vid, hw_src, hw_dst);		ethhdr->h_source, vid, hw_src, hw_dst);

	@@ -900,7 +901,7 @@ static int bla_process_claim(struct bat_priv *bat_priv,
	break;		break;
	}		}

	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_process_claim(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",		"bla_process_claim(): ERROR - this looks like a claim frame, but is useless. eth src %pM on vid %d ...(hw_src %pM, hw_dst %pM)\n",
	ethhdr->h_source, vid, hw_src, hw_dst);		ethhdr->h_source, vid, hw_src, hw_dst);
	return 1;		return 1;
	@@ -931,11 +932,11 @@ static void bla_purge_backbone_gw(struct bat_priv *bat_priv, int now)
	head, hash_entry) {		head, hash_entry) {
	if (now)		if (now)
	goto purge_now;		goto purge_now;
	if (!has_timed_out(backbone_gw->lasttime,		if (!batadv_has_timed_out(backbone_gw->lasttime,
	BLA_BACKBONE_TIMEOUT))		BLA_BACKBONE_TIMEOUT))
	continue;		continue;

	bat_dbg(DBG_BLA, backbone_gw->bat_priv,		batadv_dbg(DBG_BLA, backbone_gw->bat_priv,
	"bla_purge_backbone_gw(): backbone gw %pM timed out\n",		"bla_purge_backbone_gw(): backbone gw %pM timed out\n",
	backbone_gw->orig);		backbone_gw->orig);

	@@ -980,14 +981,14 @@ static void bla_purge_claims(struct bat_priv *bat_priv,
	hlist_for_each_entry_rcu(claim, node, head, hash_entry) {		hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
	if (now)		if (now)
	goto purge_now;		goto purge_now;
	if (!compare_eth(claim->backbone_gw->orig,		if (!batadv_compare_eth(claim->backbone_gw->orig,
	primary_if->net_dev->dev_addr))		primary_if->net_dev->dev_addr))
	continue;		continue;
	if (!has_timed_out(claim->lasttime,		if (!batadv_has_timed_out(claim->lasttime,
	BLA_CLAIM_TIMEOUT))		BLA_CLAIM_TIMEOUT))
	continue;		continue;

	bat_dbg(DBG_BLA, bat_priv,		batadv_dbg(DBG_BLA, bat_priv,
	"bla_purge_claims(): %pM, vid %d, time out\n",		"bla_purge_claims(): %pM, vid %d, time out\n",
	claim->addr, claim->vid);		claim->addr, claim->vid);

	@@ -1036,7 +1037,7 @@ void batadv_bla_update_orig_address(struct bat_priv *bat_priv,
	rcu_read_lock();		rcu_read_lock();
	hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {		hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
	/* own orig still holds the old value. */		/* own orig still holds the old value. */
	if (!compare_eth(backbone_gw->orig,		if (!batadv_compare_eth(backbone_gw->orig,
	oldif->net_dev->dev_addr))		oldif->net_dev->dev_addr))
	continue;		continue;

	@@ -1097,7 +1098,7 @@ static void bla_periodic_work(struct work_struct *work)

	rcu_read_lock();		rcu_read_lock();
	hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {		hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
	if (!compare_eth(backbone_gw->orig,		if (!batadv_compare_eth(backbone_gw->orig,
	primary_if->net_dev->dev_addr))		primary_if->net_dev->dev_addr))
	continue;		continue;

	@@ -1129,7 +1130,7 @@ int batadv_bla_init(struct bat_priv *bat_priv)
	uint8_t claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};		uint8_t claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
	struct hard_iface *primary_if;		struct hard_iface *primary_if;

	bat_dbg(DBG_BLA, bat_priv, "bla hash registering\n");		batadv_dbg(DBG_BLA, bat_priv, "bla hash registering\n");

	/* setting claim destination address */		/* setting claim destination address */
	memcpy(&bat_priv->claim_dest.magic, claim_dest, 3);		memcpy(&bat_priv->claim_dest.magic, claim_dest, 3);
	@@ -1164,7 +1165,7 @@ int batadv_bla_init(struct bat_priv *bat_priv)
	batadv_hash_set_lock_class(bat_priv->backbone_hash,		batadv_hash_set_lock_class(bat_priv->backbone_hash,
	&backbone_hash_lock_class_key);		&backbone_hash_lock_class_key);

	bat_dbg(DBG_BLA, bat_priv, "bla hashes initialized\n");		batadv_dbg(DBG_BLA, bat_priv, "bla hashes initialized\n");

	bla_start_timer(bat_priv);		bla_start_timer(bat_priv);
	return 0;		return 0;
	@@ -1206,13 +1207,13 @@ int batadv_bla_check_bcast_duplist(struct bat_priv *bat_priv,
	/* we can stop searching if the entry is too old ;		/* we can stop searching if the entry is too old ;
	* later entries will be even older		* later entries will be even older
	*/		*/
	if (has_timed_out(entry->entrytime, DUPLIST_TIMEOUT))		if (batadv_has_timed_out(entry->entrytime, DUPLIST_TIMEOUT))
	break;		break;

	if (entry->crc != crc)		if (entry->crc != crc)
	continue;		continue;

	if (compare_eth(entry->orig, bcast_packet->orig))		if (batadv_compare_eth(entry->orig, bcast_packet->orig))
	continue;		continue;

	/* this entry seems to match: same crc, not too old,		/* this entry seems to match: same crc, not too old,
	@@ -1260,7 +1261,7 @@ int batadv_bla_is_backbone_gw_orig(struct bat_priv bat_priv, uint8_t orig)

	rcu_read_lock();		rcu_read_lock();
	hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {		hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) {
	if (compare_eth(backbone_gw->orig, orig)) {		if (batadv_compare_eth(backbone_gw->orig, orig)) {
	rcu_read_unlock();		rcu_read_unlock();
	return 1;		return 1;
	}		}
	@@ -1387,7 +1388,7 @@ int batadv_bla_rx(struct bat_priv bat_priv, struct sk_buff skb, short vid)
	}		}

	/* if it is our own claim ... */		/* if it is our own claim ... */
	if (compare_eth(claim->backbone_gw->orig,		if (batadv_compare_eth(claim->backbone_gw->orig,
	primary_if->net_dev->dev_addr)) {		primary_if->net_dev->dev_addr)) {
	/* ... allow it in any case */		/* ... allow it in any case */
	claim->lasttime = jiffies;		claim->lasttime = jiffies;
	@@ -1474,7 +1475,7 @@ int batadv_bla_tx(struct bat_priv bat_priv, struct sk_buff skb, short vid)
	goto allow;		goto allow;

	/* check if we are responsible. */		/* check if we are responsible. */
	if (compare_eth(claim->backbone_gw->orig,		if (batadv_compare_eth(claim->backbone_gw->orig,
	primary_if->net_dev->dev_addr)) {		primary_if->net_dev->dev_addr)) {
	/* if yes, the client has roamed and we have		/* if yes, the client has roamed and we have
	* to unclaim it.		* to unclaim it.
	@@ -1523,6 +1524,7 @@ int batadv_bla_claim_table_seq_print_text(struct seq_file seq, void offset)
	uint32_t i;		uint32_t i;
	bool is_own;		bool is_own;
	int ret = 0;		int ret = 0;
			uint8_t *primary_addr;

	primary_if = batadv_primary_if_get_selected(bat_priv);		primary_if = batadv_primary_if_get_selected(bat_priv);
	if (!primary_if) {		if (!primary_if) {
	@@ -1539,9 +1541,10 @@ int batadv_bla_claim_table_seq_print_text(struct seq_file seq, void offset)
	goto out;		goto out;
	}		}

			primary_addr = primary_if->net_dev->dev_addr;
	seq_printf(seq,		seq_printf(seq,
	"Claims announced for the mesh %s (orig %pM, group id %04x)\n",		"Claims announced for the mesh %s (orig %pM, group id %04x)\n",
	net_dev->name, primary_if->net_dev->dev_addr,		net_dev->name, primary_addr,
	ntohs(bat_priv->claim_dest.group));		ntohs(bat_priv->claim_dest.group));
	seq_printf(seq, " %-17s %-5s %-17s [o] (%-4s)\n",		seq_printf(seq, " %-17s %-5s %-17s [o] (%-4s)\n",
	"Client", "VID", "Originator", "CRC");		"Client", "VID", "Originator", "CRC");
	@@ -1550,8 +1553,8 @@ int batadv_bla_claim_table_seq_print_text(struct seq_file seq, void offset)

	rcu_read_lock();		rcu_read_lock();
	hlist_for_each_entry_rcu(claim, node, head, hash_entry) {		hlist_for_each_entry_rcu(claim, node, head, hash_entry) {
	is_own = compare_eth(claim->backbone_gw->orig,		is_own = batadv_compare_eth(claim->backbone_gw->orig,
	primary_if->net_dev->dev_addr);		primary_addr);
	seq_printf(seq, " * %pM on % 5d by %pM [%c] (%04x)\n",		seq_printf(seq, " * %pM on % 5d by %pM [%c] (%04x)\n",
	claim->addr, claim->vid,		claim->addr, claim->vid,
	claim->backbone_gw->orig,		claim->backbone_gw->orig,

net/batman-adv/gateway_client.c

+27 −27

Original line number	Original line	Diff line number	Diff line
	@@ -217,20 +217,20 @@ void batadv_gw_election(struct bat_priv *bat_priv)
	}		}

	if ((curr_gw) && (!next_gw)) {		if ((curr_gw) && (!next_gw)) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Removing selected gateway - no gateway in range\n");		"Removing selected gateway - no gateway in range\n");
	batadv_throw_uevent(bat_priv, UEV_GW, UEV_DEL, NULL);		batadv_throw_uevent(bat_priv, UEV_GW, UEV_DEL, NULL);
	} else if ((!curr_gw) && (next_gw)) {		} else if ((!curr_gw) && (next_gw)) {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Adding route to gateway %pM (gw_flags: %i, tq: %i)\n",		"Adding route to gateway %pM (gw_flags: %i, tq: %i)\n",
	next_gw->orig_node->orig, next_gw->orig_node->gw_flags,		next_gw->orig_node->orig,
	router->tq_avg);		next_gw->orig_node->gw_flags, router->tq_avg);
	batadv_throw_uevent(bat_priv, UEV_GW, UEV_ADD, gw_addr);		batadv_throw_uevent(bat_priv, UEV_GW, UEV_ADD, gw_addr);
	} else {		} else {
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Changing route to gateway %pM (gw_flags: %i, tq: %i)\n",		"Changing route to gateway %pM (gw_flags: %i, tq: %i)\n",
	next_gw->orig_node->orig, next_gw->orig_node->gw_flags,		next_gw->orig_node->orig,
	router->tq_avg);		next_gw->orig_node->gw_flags, router->tq_avg);
	batadv_throw_uevent(bat_priv, UEV_GW, UEV_CHANGE, gw_addr);		batadv_throw_uevent(bat_priv, UEV_GW, UEV_CHANGE, gw_addr);
	}		}

	@@ -282,7 +282,7 @@ void batadv_gw_check_election(struct bat_priv *bat_priv,
	(orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw_sel_class)))		(orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw_sel_class)))
	goto out;		goto out;

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

	@@ -318,7 +318,7 @@ static void gw_node_add(struct bat_priv *bat_priv,
	spin_unlock_bh(&bat_priv->gw_list_lock);		spin_unlock_bh(&bat_priv->gw_list_lock);

	batadv_gw_bandwidth_to_kbit(new_gwflags, &down, &up);		batadv_gw_bandwidth_to_kbit(new_gwflags, &down, &up);
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Found new gateway %pM -> gw_class: %i - %i%s/%i%s\n",		"Found new gateway %pM -> gw_class: %i - %i%s/%i%s\n",
	orig_node->orig, new_gwflags,		orig_node->orig, new_gwflags,
	(down > 2048 ? down / 1024 : down),		(down > 2048 ? down / 1024 : down),
	@@ -345,7 +345,7 @@ void batadv_gw_node_update(struct bat_priv *bat_priv,
	if (gw_node->orig_node != orig_node)		if (gw_node->orig_node != orig_node)
	continue;		continue;

	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Gateway class of originator %pM changed from %i to %i\n",		"Gateway class of originator %pM changed from %i to %i\n",
	orig_node->orig, gw_node->orig_node->gw_flags,		orig_node->orig, gw_node->orig_node->gw_flags,
	new_gwflags);		new_gwflags);
	@@ -354,7 +354,7 @@ void batadv_gw_node_update(struct bat_priv *bat_priv,

	if (new_gwflags == NO_FLAGS) {		if (new_gwflags == NO_FLAGS) {
	gw_node->deleted = jiffies;		gw_node->deleted = jiffies;
	bat_dbg(DBG_BATMAN, bat_priv,		batadv_dbg(DBG_BATMAN, bat_priv,
	"Gateway %pM removed from gateway list\n",		"Gateway %pM removed from gateway list\n",
	orig_node->orig);		orig_node->orig);