Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bd414860 authored by David S. Miller's avatar David S. Miller
Browse files

Merge tag 'batadv-next-for-davem-20170406' of git://git.open-mesh.org/linux-merge 



Simon Wunderlich says:

====================
This feature/cleanup patchset includes the following patches:

 - bump version strings, by Simon Wunderlich

 - Code and Style cleanups, by Sven Eckelmann (5 patches)

 - Remove an unneccessary memset, by Tobias Klauser

 - DAT and BLA optimizations for various corner cases, by Andreas Pape
   (5 patches)

 - forward/rebroadcast packet restructuring, by Linus Luessing
   (2 patches)

 - ethtool cleanup and remove unncessary code, by Sven Eckelmann
   (4 patches)

 - use net_device_stats from net_device instead of private copy,
   by Tobias Klauser
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 54280168 ab044f8e

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 @@ int batadv_bla_backbone_dump(struct sk_buff *msg, struct netlink_callback *cb) 


	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 */