batman-adv: Prefix main enum with BATADV_ (39c75a51) · Commits · e / devices / android_kernel_oneplus_sm7250

net/batman-adv/bat_iv_ogm.c

+24 −24

Original line number	Diff line number	Diff line
		@@ -188,7 +188,7 @@ static void batadv_iv_ogm_send_to_if(struct forw_packet *forw_packet,
		fwd_str = (packet_num > 0 ? "Forwarding" : (forw_packet->own ?
		"Sending own" :
		"Forwarding"));
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"%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 " : ""),
		batman_ogm_packet->orig,
		@@ -252,7 +252,7 @@ static void batadv_iv_ogm_emit(struct forw_packet *forw_packet)
		(forw_packet->own && (forw_packet->if_incoming != primary_if))) {

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

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

		@@ -561,7 +561,7 @@ static void batadv_iv_ogm_forward(struct orig_node *orig_node,
		batman_ogm_packet->tq = batadv_hop_penalty(batman_ogm_packet->tq,
		bat_priv);

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

		@@ -642,7 +642,7 @@ batadv_iv_ogm_orig_update(struct bat_priv *bat_priv,
		uint8_t bcast_own_sum_orig, bcast_own_sum_neigh;
		uint8_t *neigh_addr;

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

		rcu_read_lock();
		@@ -685,7 +685,7 @@ batadv_iv_ogm_orig_update(struct bat_priv *bat_priv,
		if (!neigh_node)
		goto unlock;
		} else
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"Updating existing last-hop neighbor of originator\n");

		rcu_read_unlock();
		@@ -866,7 +866,7 @@ static int batadv_iv_ogm_calc_tq(struct orig_node *orig_node,
		combined_tq /= BATADV_TQ_MAX_VALUE * BATADV_TQ_MAX_VALUE;
		batman_ogm_packet->tq = combined_tq;

		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_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",
		orig_node->orig, orig_neigh_node->orig, total_count,
		neigh_rq_count, tq_own,
		@@ -948,7 +948,7 @@ batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr,
		rcu_read_unlock();

		if (need_update) {
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"updating last_seqno: old %u, new %u\n",
		orig_node->last_real_seqno, seqno);
		orig_node->last_real_seqno = seqno;
		@@ -1007,7 +1007,7 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
		if (batadv_compare_eth(ethhdr->h_source, batman_ogm_packet->orig))
		is_single_hop_neigh = true;

		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_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",
		ethhdr->h_source, if_incoming->net_dev->name,
		if_incoming->net_dev->dev_addr, batman_ogm_packet->orig,
		@@ -1044,21 +1044,21 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
		rcu_read_unlock();

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

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

		if (is_broadcast) {
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"Drop packet: ignoring all packets with broadcast source addr (sender: %pM)\n",
		ethhdr->h_source);
		return;
		@@ -1097,21 +1097,21 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
		spin_unlock_bh(&orig_neigh_node->ogm_cnt_lock);
		}

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

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

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

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

		if (batman_ogm_packet->tq == 0) {
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"Drop packet: originator packet with tq equal 0\n");
		goto out;
		}
		@@ -1151,7 +1151,7 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
		(batadv_compare_eth(router->addr, prev_sender)) &&
		!(batadv_compare_eth(batman_ogm_packet->orig, prev_sender)) &&
		(batadv_compare_eth(router->addr, router_router->addr))) {
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n",
		ethhdr->h_source);
		goto out;
		@@ -1172,7 +1172,7 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
		* don't route towards it
		*/
		if (!is_single_hop_neigh && (!orig_neigh_router)) {
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"Drop packet: OGM via unknown neighbor!\n");
		goto out_neigh;
		}
		@@ -1201,25 +1201,25 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr,
		is_single_hop_neigh,
		is_from_best_next_hop, if_incoming);

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

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

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

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

net/batman-adv/bat_sysfs.c

+6 −6

Original line number	Diff line number	Diff line
		@@ -485,7 +485,7 @@ BATADV_ATTR_SIF_UINT(gw_sel_class, S_IRUGO \| S_IWUSR, 1, BATADV_TQ_MAX_VALUE,
		static BATADV_ATTR(gw_bandwidth, S_IRUGO \| S_IWUSR, batadv_show_gw_bwidth,
		batadv_store_gw_bwidth);
		#ifdef CONFIG_BATMAN_ADV_DEBUG
		BATADV_ATTR_SIF_UINT(log_level, S_IRUGO \| S_IWUSR, 0, DBG_ALL, NULL);
		BATADV_ATTR_SIF_UINT(log_level, S_IRUGO \| S_IWUSR, 0, BATADV_DBG_ALL, NULL);
		#endif

		static struct bat_attribute *batadv_mesh_attrs[] = {
		@@ -723,8 +723,8 @@ void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
		*hardif_obj = NULL;
		}

		int batadv_throw_uevent(struct bat_priv *bat_priv, enum uev_type type,
		enum uev_action action, const char *data)
		int batadv_throw_uevent(struct bat_priv *bat_priv, enum batadv_uev_type type,
		enum batadv_uev_action action, const char *data)
		{
		int ret = -ENOMEM;
		struct hard_iface *primary_if = NULL;
		@@ -756,7 +756,7 @@ int batadv_throw_uevent(struct bat_priv *bat_priv, enum uev_type type,
		batadv_uev_action_str[action]);

		/* If the event is DEL, ignore the data field */
		if (action != UEV_DEL) {
		if (action != BATADV_UEV_DEL) {
		uevent_env[2] = kmalloc(strlen(BATADV_UEV_DATA_VAR) +
		strlen(data) + 1, GFP_ATOMIC);
		if (!uevent_env[2])
		@@ -775,10 +775,10 @@ int batadv_throw_uevent(struct bat_priv *bat_priv, enum uev_type type,
		batadv_hardif_free_ref(primary_if);

		if (ret)
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
		batadv_uev_type_str[type],
		batadv_uev_action_str[action],
		(action == UEV_DEL ? "NULL" : data), ret);
		(action == BATADV_UEV_DEL ? "NULL" : data), ret);
		return ret;
		}

net/batman-adv/bat_sysfs.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -36,7 +36,7 @@ void batadv_sysfs_del_meshif(struct net_device *dev);
		int batadv_sysfs_add_hardif(struct kobject **hardif_obj,
		struct net_device *dev);
		void batadv_sysfs_del_hardif(struct kobject **hardif_obj);
		int batadv_throw_uevent(struct bat_priv *bat_priv, enum uev_type type,
		enum uev_action action, const char *data);
		int batadv_throw_uevent(struct bat_priv *bat_priv, enum batadv_uev_type type,
		enum batadv_uev_action action, const char *data);

		#endif /* _NET_BATMAN_ADV_SYSFS_H_ */

net/batman-adv/bitarray.c

+2 −2

Original line number	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 */
		if (seq_num_diff >= BATADV_TQ_LOCAL_WINDOW_SIZE &&
		seq_num_diff < BATADV_EXPECTED_SEQNO_RANGE) {
		batadv_dbg(DBG_BATMAN, bat_priv,
		batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
		"We missed a lot of packets (%i) !\n",
		seq_num_diff - 1);
		bitmap_zero(seq_bits, BATADV_TQ_LOCAL_WINDOW_SIZE);
		@@ -83,7 +83,7 @@ int batadv_bit_get_packet(void priv, unsigned long seq_bits,
		if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE \|\|
		seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {

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

		bitmap_zero(seq_bits, BATADV_TQ_LOCAL_WINDOW_SIZE);

net/batman-adv/bridge_loop_avoidance.c

+23 −23

Original line number	Diff line number	Diff line
		@@ -297,7 +297,7 @@ static void batadv_bla_send_claim(struct bat_priv bat_priv, uint8_t mac,
		* set Ethernet SRC to the clients mac
		*/
		memcpy(ethhdr->h_source, mac, ETH_ALEN);
		batadv_dbg(DBG_BLA, bat_priv,
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): CLAIM %pM on vid %d\n", mac, vid);
		break;
		case BATADV_CLAIM_TYPE_DEL:
		@@ -305,7 +305,7 @@ static void batadv_bla_send_claim(struct bat_priv bat_priv, uint8_t mac,
		* set HW SRC to the clients mac
		*/
		memcpy(hw_src, mac, ETH_ALEN);
		batadv_dbg(DBG_BLA, bat_priv,
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): UNCLAIM %pM on vid %d\n", mac,
		vid);
		break;
		@@ -314,7 +314,7 @@ static void batadv_bla_send_claim(struct bat_priv bat_priv, uint8_t mac,
		* set HW SRC to the special mac containg the crc
		*/
		memcpy(hw_src, mac, ETH_ALEN);
		batadv_dbg(DBG_BLA, bat_priv,
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): ANNOUNCE of %pM on vid %d\n",
		ethhdr->h_source, vid);
		break;
		@@ -324,7 +324,7 @@ static void batadv_bla_send_claim(struct bat_priv bat_priv, uint8_t mac,
		*/
		memcpy(hw_src, mac, ETH_ALEN);
		memcpy(ethhdr->h_dest, mac, ETH_ALEN);
		batadv_dbg(DBG_BLA, bat_priv,
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"bla_send_claim(): REQUEST of %pM to %pMon vid %d\n",
		ethhdr->h_source, ethhdr->h_dest, vid);
		break;
		@@ -365,7 +365,7 @@ static struct backbone_gw batadv_bla_get_backbone_gw(struct bat_priv bat_priv,
		if (entry)
		return entry;

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

		@@ -439,7 +439,7 @@ static void batadv_bla_answer_request(struct bat_priv *bat_priv,
		struct backbone_gw *backbone_gw;
		int i;

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

		backbone_gw = batadv_backbone_hash_find(bat_priv,
		@@ -480,8 +480,8 @@ static void batadv_bla_send_request(struct backbone_gw *backbone_gw)
		/* first, remove all old entries */
		batadv_bla_del_backbone_claims(backbone_gw);

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

		/* send request */
		batadv_bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig,
		@@ -546,7 +546,7 @@ static void batadv_bla_add_claim(struct bat_priv bat_priv, const uint8_t mac,
		claim->backbone_gw = backbone_gw;

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

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

		@@ -599,8 +599,8 @@ static void batadv_bla_del_claim(struct bat_priv bat_priv, const uint8_t mac,
		if (!claim)
		return;

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

		batadv_hash_remove(bat_priv->claim_hash, batadv_compare_claim,
		batadv_choose_claim, claim);
		@@ -633,12 +633,12 @@ static int batadv_handle_announce(struct bat_priv *bat_priv,
		backbone_gw->lasttime = jiffies;
		crc = ntohs(((__be16 )(&an_addr[4])));

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

		if (backbone_gw->crc != crc) {
		batadv_dbg(DBG_BLA, backbone_gw->bat_priv,
		batadv_dbg(BATADV_DBG_BLA, backbone_gw->bat_priv,
		"handle_announce(): CRC FAILED for %pM/%d (my = %04x, sent = %04x)\n",
		backbone_gw->orig, backbone_gw->vid,
		backbone_gw->crc, crc);
		@@ -674,7 +674,7 @@ static int batadv_handle_request(struct bat_priv *bat_priv,
		if (!batadv_compare_eth(ethhdr->h_dest, primary_if->net_dev->dev_addr))
		return 1;

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

		@@ -702,7 +702,7 @@ static int batadv_handle_unclaim(struct bat_priv *bat_priv,
		return 1;

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

		@@ -804,7 +804,7 @@ static int batadv_check_claim_group(struct bat_priv *bat_priv,

		/* if our mesh friends mac is bigger, use it for ourselves. */
		if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) {
		batadv_dbg(DBG_BLA, bat_priv,
		batadv_dbg(BATADV_DBG_BLA, bat_priv,
		"taking other backbones claim group: %04x\n",
		ntohs(bla_dst->group));
		bla_dst_own->group = bla_dst->group;
		@@ -882,7 +882,7 @@ static int batadv_bla_process_claim(struct bat_priv *bat_priv,
		ret = batadv_check_claim_group(bat_priv, primary_if, hw_src, hw_dst,
		ethhdr);
		if (ret == 1)
		batadv_dbg(DBG_BLA, bat_priv,
		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, vid, hw_src, hw_dst);

		@@ -917,7 +917,7 @@ static int batadv_bla_process_claim(struct bat_priv *bat_priv,
		break;
		}

		batadv_dbg(DBG_BLA, 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, vid, hw_src, hw_dst);
		return 1;
		@@ -952,7 +952,7 @@ static void batadv_bla_purge_backbone_gw(struct bat_priv *bat_priv, int now)
		BATADV_BLA_BACKBONE_TIMEOUT))
		continue;

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

		@@ -1004,7 +1004,7 @@ static void batadv_bla_purge_claims(struct bat_priv *bat_priv,
		BATADV_BLA_CLAIM_TIMEOUT))
		continue;

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

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

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

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

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

		batadv_bla_start_timer(bat_priv);
		return 0;