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

net/batman-adv/bat_iv_ogm.c

+9 −8

Original line number	Diff line number	Diff line
		@@ -679,15 +679,11 @@ static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff,
		{
		struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface);
		struct batadv_forw_packet *forw_packet_aggr;
		struct sk_buff *skb;
		unsigned char *skb_buff;
		unsigned int skb_size;
		atomic_t *queue_left = own_packet ? NULL : &bat_priv->batman_queue_left;

		forw_packet_aggr = batadv_forw_packet_alloc(if_incoming, if_outgoing,
		queue_left, bat_priv);
		if (!forw_packet_aggr)
		return;

		if (atomic_read(&bat_priv->aggregated_ogms) &&
		packet_len < BATADV_MAX_AGGREGATION_BYTES)
		skb_size = BATADV_MAX_AGGREGATION_BYTES;
		@@ -696,9 +692,14 @@ 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) {
		batadv_forw_packet_free(forw_packet_aggr, true);
		skb = netdev_alloc_skb_ip_align(NULL, skb_size);
		if (!skb)
		return;

		forw_packet_aggr = batadv_forw_packet_alloc(if_incoming, if_outgoing,
		queue_left, bat_priv, skb);
		if (!forw_packet_aggr) {
		kfree_skb(skb);
		return;
		}

net/batman-adv/bridge_loop_avoidance.c

+97 −26

Original line number	Diff line number	Diff line
		@@ -395,7 +395,7 @@ static void batadv_bla_send_claim(struct batadv_priv bat_priv, u8 mac,
		ether_addr_copy(ethhdr->h_source, mac);
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): CLAIM %pM on vid %d\n", mac,
		BATADV_PRINT_VID(vid));
		batadv_print_vid(vid));
		break;
		case BATADV_CLAIM_TYPE_UNCLAIM:
		/* unclaim frame
		@@ -404,7 +404,7 @@ static void batadv_bla_send_claim(struct batadv_priv bat_priv, u8 mac,
		ether_addr_copy(hw_src, mac);
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): UNCLAIM %pM on vid %d\n", mac,
		BATADV_PRINT_VID(vid));
		batadv_print_vid(vid));
		break;
		case BATADV_CLAIM_TYPE_ANNOUNCE:
		/* announcement frame
		@@ -413,7 +413,7 @@ static void batadv_bla_send_claim(struct batadv_priv bat_priv, u8 mac,
		ether_addr_copy(hw_src, mac);
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): ANNOUNCE of %pM on vid %d\n",
		ethhdr->h_source, BATADV_PRINT_VID(vid));
		ethhdr->h_source, batadv_print_vid(vid));
		break;
		case BATADV_CLAIM_TYPE_REQUEST:
		/* request frame
		@@ -425,14 +425,14 @@ static void batadv_bla_send_claim(struct batadv_priv bat_priv, u8 mac,
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): REQUEST of %pM to %pM on vid %d\n",
		ethhdr->h_source, ethhdr->h_dest,
		BATADV_PRINT_VID(vid));
		batadv_print_vid(vid));
		break;
		case BATADV_CLAIM_TYPE_LOOPDETECT:
		ether_addr_copy(ethhdr->h_source, mac);
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): LOOPDETECT of %pM to %pM on vid %d\n",
		ethhdr->h_source, ethhdr->h_dest,
		BATADV_PRINT_VID(vid));
		batadv_print_vid(vid));

		break;
		}
		@@ -475,9 +475,9 @@ static void batadv_bla_loopdetect_report(struct work_struct *work)

		batadv_info(bat_priv->soft_iface,
		"Possible loop on VLAN %d detected which can't be handled by BLA - please check your network setup!\n",
		BATADV_PRINT_VID(backbone_gw->vid));
		batadv_print_vid(backbone_gw->vid));
		snprintf(vid_str, sizeof(vid_str), "%d",
		BATADV_PRINT_VID(backbone_gw->vid));
		batadv_print_vid(backbone_gw->vid));
		vid_str[sizeof(vid_str) - 1] = 0;

		batadv_throw_uevent(bat_priv, BATADV_UEV_BLA, BATADV_UEV_LOOPDETECT,
		@@ -510,7 +510,7 @@ batadv_bla_get_backbone_gw(struct batadv_priv bat_priv, u8 orig,

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

		entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
		if (!entry)
		@@ -719,7 +719,7 @@ static void batadv_bla_add_claim(struct batadv_priv *bat_priv,

		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_add_claim(): adding new entry %pM, vid %d to hash ...\n",
		mac, BATADV_PRINT_VID(vid));
		mac, batadv_print_vid(vid));

		kref_get(&claim->refcount);
		hash_added = batadv_hash_add(bat_priv->bla.claim_hash,
		@@ -739,8 +739,8 @@ static void batadv_bla_add_claim(struct batadv_priv *bat_priv,
		goto claim_free_ref;

		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_add_claim(): changing ownership for %pM, vid %d\n",
		mac, BATADV_PRINT_VID(vid));
		"bla_add_claim(): changing ownership for %pM, vid %d to gw %pM\n",
		mac, batadv_print_vid(vid), backbone_gw->orig);

		remove_crc = true;
		}
		@@ -809,7 +809,7 @@ static void batadv_bla_del_claim(struct batadv_priv *bat_priv,
		return;

		batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla_del_claim(): %pM, vid %d\n",
		mac, BATADV_PRINT_VID(vid));
		mac, batadv_print_vid(vid));

		batadv_hash_remove(bat_priv->bla.claim_hash, batadv_compare_claim,
		batadv_choose_claim, claim);
		@@ -849,7 +849,7 @@ static bool batadv_handle_announce(struct batadv_priv bat_priv, u8 an_addr,

		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"handle_announce(): ANNOUNCE vid %d (sent by %pM)... CRC = %#.4x\n",
		BATADV_PRINT_VID(vid), backbone_gw->orig, crc);
		batadv_print_vid(vid), backbone_gw->orig, crc);

		spin_lock_bh(&backbone_gw->crc_lock);
		backbone_crc = backbone_gw->crc;
		@@ -859,7 +859,7 @@ static bool batadv_handle_announce(struct batadv_priv bat_priv, u8 an_addr,
		batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
		"handle_announce(): CRC FAILED for %pM/%d (my = %#.4x, sent = %#.4x)\n",
		backbone_gw->orig,
		BATADV_PRINT_VID(backbone_gw->vid),
		batadv_print_vid(backbone_gw->vid),
		backbone_crc, crc);

		batadv_bla_send_request(backbone_gw);
		@@ -904,7 +904,7 @@ static bool batadv_handle_request(struct batadv_priv *bat_priv,

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

		batadv_bla_answer_request(bat_priv, primary_if, vid);
		return true;
		@@ -941,7 +941,7 @@ static bool batadv_handle_unclaim(struct batadv_priv *bat_priv,
		/* this must be an UNCLAIM frame */
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"handle_unclaim(): UNCLAIM %pM on vid %d (sent by %pM)...\n",
		claim_addr, BATADV_PRINT_VID(vid), backbone_gw->orig);
		claim_addr, batadv_print_vid(vid), backbone_gw->orig);

		batadv_bla_del_claim(bat_priv, claim_addr, vid);
		batadv_backbone_gw_put(backbone_gw);
		@@ -1161,7 +1161,7 @@ static bool batadv_bla_process_claim(struct batadv_priv *bat_priv,
		if (ret == 1)
		batadv_dbg(BATADV_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",
		ethhdr->h_source, BATADV_PRINT_VID(vid), hw_src,
		ethhdr->h_source, batadv_print_vid(vid), hw_src,
		hw_dst);

		if (ret < 2)
		@@ -1197,7 +1197,7 @@ static bool batadv_bla_process_claim(struct batadv_priv *bat_priv,

		batadv_dbg(BATADV_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",
		ethhdr->h_source, BATADV_PRINT_VID(vid), hw_src, hw_dst);
		ethhdr->h_source, batadv_print_vid(vid), hw_src, hw_dst);
		return true;
		}

		@@ -1295,10 +1295,13 @@ static void batadv_bla_purge_claims(struct batadv_priv *bat_priv,
		goto skip;

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

		purge_now:
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_purge_claims(): %pM, vid %d\n",
		claim->addr, claim->vid);

		batadv_handle_unclaim(bat_priv, primary_if,
		backbone_gw->orig,
		claim->addr, claim->vid);
		@@ -1846,6 +1849,13 @@ bool batadv_bla_rx(struct batadv_priv bat_priv, struct sk_buff skb,
		/* possible optimization: race for a claim */
		/* No claim exists yet, claim it for us!
		*/

		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_rx(): Unclaimed MAC %pM found. Claim it. Local: %s\n",
		ethhdr->h_source,
		batadv_is_my_client(bat_priv,
		ethhdr->h_source, vid) ?
		"yes" : "no");
		batadv_handle_claim(bat_priv, primary_if,
		primary_if->net_dev->dev_addr,
		ethhdr->h_source, vid);
		@@ -1963,10 +1973,22 @@ bool batadv_bla_tx(struct batadv_priv bat_priv, struct sk_buff skb,
		/* if yes, the client has roamed and we have
		* to unclaim it.
		*/
		if (batadv_has_timed_out(claim->lasttime, 100)) {
		/* only unclaim if the last claim entry is
		* older than 100 ms to make sure we really
		* have a roaming client here.
		*/
		batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla_tx(): Roaming client %pM detected. Unclaim it.\n",
		ethhdr->h_source);
		batadv_handle_unclaim(bat_priv, primary_if,
		primary_if->net_dev->dev_addr,
		ethhdr->h_source, vid);
		goto allow;
		} else {
		batadv_dbg(BATADV_DBG_BLA, bat_priv, "bla_tx(): Race for claim %pM detected. Drop packet.\n",
		ethhdr->h_source);
		goto handled;
		}
		}

		/* check if it is a multicast/broadcast frame */
		@@ -2042,7 +2064,7 @@ int batadv_bla_claim_table_seq_print_text(struct seq_file seq, void offset)
		backbone_crc = backbone_gw->crc;
		spin_unlock_bh(&backbone_gw->crc_lock);
		seq_printf(seq, " * %pM on %5d by %pM [%c] (%#.4x)\n",
		claim->addr, BATADV_PRINT_VID(claim->vid),
		claim->addr, batadv_print_vid(claim->vid),
		backbone_gw->orig,
		(is_own ? 'x' : ' '),
		backbone_crc);
		@@ -2274,7 +2296,7 @@ int batadv_bla_backbone_table_seq_print_text(struct seq_file seq, void offset)

		seq_printf(seq, " * %pM on %5d %4i.%03is (%#.4x)\n",
		backbone_gw->orig,
		BATADV_PRINT_VID(backbone_gw->vid), secs,
		batadv_print_vid(backbone_gw->vid), secs,
		msecs, backbone_crc);
		}
		rcu_read_unlock();
		@@ -2449,3 +2471,52 @@ out:

		return ret;
		}

		#ifdef CONFIG_BATMAN_ADV_DAT
		/**
		* batadv_bla_check_claim - check if address is claimed
		*
		* @bat_priv: the bat priv with all the soft interface information
		* @addr: mac address of which the claim status is checked
		* @vid: the VLAN ID
		*
		* addr is checked if this address is claimed by the local device itself.
		*
		* Return: true if bla is disabled or the mac is claimed by the device,
		* false if the device addr is already claimed by another gateway
		*/
		bool batadv_bla_check_claim(struct batadv_priv *bat_priv,
		u8 *addr, unsigned short vid)
		{
		struct batadv_bla_claim search_claim;
		struct batadv_bla_claim *claim = NULL;
		struct batadv_hard_iface *primary_if = NULL;
		bool ret = true;

		if (!atomic_read(&bat_priv->bridge_loop_avoidance))
		return ret;

		primary_if = batadv_primary_if_get_selected(bat_priv);
		if (!primary_if)
		return ret;

		/* First look if the mac address is claimed */
		ether_addr_copy(search_claim.addr, addr);
		search_claim.vid = vid;

		claim = batadv_claim_hash_find(bat_priv, &search_claim);

		/* If there is a claim and we are not owner of the claim,
		* return false.
		*/
		if (claim) {
		if (!batadv_compare_eth(claim->backbone_gw->orig,
		primary_if->net_dev->dev_addr))
		ret = false;
		batadv_claim_put(claim);
		}

		batadv_hardif_put(primary_if);
		return ret;
		}
		#endif

net/batman-adv/bridge_loop_avoidance.h

+11 −0

Original line number	Diff line number	Diff line
		@@ -69,6 +69,10 @@ void batadv_bla_status_update(struct net_device *net_dev);
		int batadv_bla_init(struct batadv_priv *bat_priv);
		void batadv_bla_free(struct batadv_priv *bat_priv);
		int batadv_bla_claim_dump(struct sk_buff msg, struct netlink_callback cb);
		#ifdef CONFIG_BATMAN_ADV_DAT
		bool batadv_bla_check_claim(struct batadv_priv bat_priv, u8 addr,
		unsigned short vid);
		#endif
		#define BATADV_BLA_CRC_INIT 0
		#else /* ifdef CONFIG_BATMAN_ADV_BLA */

		@@ -145,6 +149,13 @@ static inline int batadv_bla_backbone_dump(struct sk_buff *msg,
		return -EOPNOTSUPP;
		}

		static inline
		bool batadv_bla_check_claim(struct batadv_priv bat_priv, u8 addr,
		unsigned short vid)
		{
		return true;
		}

		#endif /* ifdef CONFIG_BATMAN_ADV_BLA */

		#endif /* ifndef _NET_BATMAN_ADV_BLA_H_ */

net/batman-adv/distributed-arp-table.c

+56 −8

Original line number	Diff line number	Diff line
		@@ -43,6 +43,7 @@
		#include <linux/workqueue.h>
		#include <net/arp.h>

		#include "bridge_loop_avoidance.h"
		#include "hard-interface.h"
		#include "hash.h"
		#include "log.h"
		@@ -330,7 +331,7 @@ static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip,
		batadv_dbg(BATADV_DBG_DAT, bat_priv,
		"Entry updated: %pI4 %pM (vid: %d)\n",
		&dat_entry->ip, dat_entry->mac_addr,
		BATADV_PRINT_VID(vid));
		batadv_print_vid(vid));
		goto out;
		}

		@@ -356,7 +357,7 @@ static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip,
		}

		batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n",
		&dat_entry->ip, dat_entry->mac_addr, BATADV_PRINT_VID(vid));
		&dat_entry->ip, dat_entry->mac_addr, batadv_print_vid(vid));

		out:
		if (dat_entry)
		@@ -835,7 +836,7 @@ int batadv_dat_cache_seq_print_text(struct seq_file seq, void offset)

		seq_printf(seq, " * %15pI4 %14pM %4i %6i:%02i\n",
		&dat_entry->ip, dat_entry->mac_addr,
		BATADV_PRINT_VID(dat_entry->vid),
		batadv_print_vid(dat_entry->vid),
		last_seen_mins, last_seen_secs);
		}
		rcu_read_unlock();
		@@ -1002,6 +1003,7 @@ bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
		bool ret = false;
		struct batadv_dat_entry *dat_entry = NULL;
		struct sk_buff *skb_new;
		struct net_device *soft_iface = bat_priv->soft_iface;
		int hdr_size = 0;
		unsigned short vid;

		@@ -1040,16 +1042,30 @@ bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv,
		goto out;
		}

		/* If BLA is enabled, only send ARP replies if we have claimed
		* the destination for the ARP request or if no one else of
		* the backbone gws belonging to our backbone has claimed the
		* destination.
		*/
		if (!batadv_bla_check_claim(bat_priv,
		dat_entry->mac_addr, vid)) {
		batadv_dbg(BATADV_DBG_DAT, bat_priv,
		"Device %pM claimed by another backbone gw. Don't send ARP reply!",
		dat_entry->mac_addr);
		ret = true;
		goto out;
		}

		skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src,
		dat_entry->mac_addr,
		hw_src, vid);
		if (!skb_new)
		goto out;

		skb_new->protocol = eth_type_trans(skb_new,
		bat_priv->soft_iface);
		bat_priv->stats.rx_packets++;
		bat_priv->stats.rx_bytes += skb->len + ETH_HLEN + hdr_size;
		skb_new->protocol = eth_type_trans(skb_new, soft_iface);

		soft_iface->stats.rx_packets++;
		soft_iface->stats.rx_bytes += skb->len + ETH_HLEN + hdr_size;

		netif_rx(skb_new);
		batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n");
		@@ -1188,6 +1204,7 @@ void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv,
		bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
		struct sk_buff *skb, int hdr_size)
		{
		struct batadv_dat_entry *dat_entry = NULL;
		u16 type;
		__be32 ip_src, ip_dst;
		u8 hw_src, hw_dst;
		@@ -1210,12 +1227,41 @@ bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
		hw_dst = batadv_arp_hw_dst(skb, hdr_size);
		ip_dst = batadv_arp_ip_dst(skb, hdr_size);

		/* If ip_dst is already in cache and has the right mac address,
		* drop this frame if this ARP reply is destined for us because it's
		* most probably an ARP reply generated by another node of the DHT.
		* We have most probably received already a reply earlier. Delivering
		* this frame would lead to doubled receive of an ARP reply.
		*/
		dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_src, vid);
		if (dat_entry && batadv_compare_eth(hw_src, dat_entry->mac_addr)) {
		batadv_dbg(BATADV_DBG_DAT, bat_priv, "Doubled ARP reply removed: ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]; dat_entry: %pM-%pI4\n",
		hw_src, &ip_src, hw_dst, &ip_dst,
		dat_entry->mac_addr, &dat_entry->ip);
		dropped = true;
		goto out;
		}

		/* Update our internal cache with both the IP addresses the node got
		* within the ARP reply
		*/
		batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid);
		batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid);

		/* If BLA is enabled, only forward ARP replies if we have claimed the
		* source of the ARP reply or if no one else of the same backbone has
		* already claimed that client. This prevents that different gateways
		* to the same backbone all forward the ARP reply leading to multiple
		* replies in the backbone.
		*/
		if (!batadv_bla_check_claim(bat_priv, hw_src, vid)) {
		batadv_dbg(BATADV_DBG_DAT, bat_priv,
		"Device %pM claimed by another backbone gw. Drop ARP reply.\n",
		hw_src);
		dropped = true;
		goto out;
		}

		/* if this REPLY is directed to a client of mine, let's deliver the
		* packet to the interface
		*/
		@@ -1228,6 +1274,8 @@ bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv,
		out:
		if (dropped)
		kfree_skb(skb);
		if (dat_entry)
		batadv_dat_entry_put(dat_entry);
		/* if dropped == false -> deliver to the interface */
		return dropped;
		}
		@@ -1256,7 +1304,7 @@ bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv,
		/* If this packet is an ARP_REQUEST and the node already has the
		* information that it is going to ask, then the packet can be dropped
		*/
		if (forw_packet->num_packets)
		if (batadv_forw_packet_is_rebroadcast(forw_packet))
		goto out;

		vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size);

net/batman-adv/log.h

+3 −2

Original line number	Diff line number	Diff line
		@@ -73,9 +73,10 @@ __printf(2, 3);
		/* possibly ratelimited debug output */
		#define _batadv_dbg(type, bat_priv, ratelimited, fmt, arg...) \
		do { \
		if (atomic_read(&(bat_priv)->log_level) & (type) && \
		struct batadv_priv *__batpriv = (bat_priv); \
		if (atomic_read(&__batpriv->log_level) & (type) && \
		(!(ratelimited) \|\| net_ratelimit())) \
		batadv_debug_log(bat_priv, fmt, ## arg); \
		batadv_debug_log(__batpriv, fmt, ## arg); \
		} \
		while (0)
		#else /* !CONFIG_BATMAN_ADV_DEBUG */

Admin message