if (forw_packet->if_incoming->if_status != IF_ACTIVE)
                goto out;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 /* return true if new_packet can be aggregated with forw_packet */
                 *    a "global" packet as well as the base
                 *    packet
                 */
-               primary_if = primary_if_get_selected(bat_priv);
+               primary_if = batadv_primary_if_get_selected(bat_priv);
                if (!primary_if)
                        goto out;
 
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return res;
 }
 
 
        return;
 out:
-       hardif_free_ref(if_incoming);
+       batadv_hardif_free_ref(if_incoming);
 }
 
 /* aggregate a new packet into the existing ogm packet */
        int vis_server, tt_num_changes = 0;
 
        vis_server = atomic_read(&bat_priv->vis_mode);
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
 
        if (hard_iface == primary_if)
                tt_num_changes = batadv_tt_append_diff(bat_priv,
                             bat_iv_ogm_emit_send_time(bat_priv));
 
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 static void bat_iv_ogm_orig_update(struct bat_priv *bat_priv,
 
        length = __store_uint_attr(buff, count, _min, _max, _post_func, \
                                   attr, &hard_iface->_name, net_dev);  \
                                                                        \
-       hardif_free_ref(hard_iface);                                    \
+       batadv_hardif_free_ref(hard_iface);                             \
        return length;                                                  \
 }
 
                                                                        \
        length = sprintf(buff, "%i\n", atomic_read(&hard_iface->_name));\
                                                                        \
-       hardif_free_ref(hard_iface);                                    \
+       batadv_hardif_free_ref(hard_iface);                             \
        return length;                                                  \
 }
 
        length = sprintf(buff, "%s\n", hard_iface->if_status == IF_NOT_IN_USE ?
                         "none" : hard_iface->soft_iface->name);
 
-       hardif_free_ref(hard_iface);
+       batadv_hardif_free_ref(hard_iface);
 
        return length;
 }
        if (strlen(buff) >= IFNAMSIZ) {
                pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
                       buff);
-               hardif_free_ref(hard_iface);
+               batadv_hardif_free_ref(hard_iface);
                return -EINVAL;
        }
 
 unlock:
        rtnl_unlock();
 out:
-       hardif_free_ref(hard_iface);
+       batadv_hardif_free_ref(hard_iface);
        return ret;
 }
 
                break;
        }
 
-       hardif_free_ref(hard_iface);
+       batadv_hardif_free_ref(hard_iface);
 
        return length;
 }
        struct kobject *bat_kobj;
        char *uevent_env[4] = { NULL, NULL, NULL, NULL };
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
        kfree(uevent_env[2]);
 
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 
        if (ret)
                bat_dbg(DBG_BATMAN, bat_priv,
 
        struct bla_claim_dst local_claim_dest;
        __be32 zeroip = 0;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                return;
 
        netif_rx(skb);
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 /* @bat_priv: the bat priv with all the soft interface information
        struct hard_iface *primary_if;
        int i;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
        }
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 
        bla_start_timer(bat_priv);
 }
        /* setting claim destination address */
        memcpy(&bat_priv->claim_dest.magic, claim_dest, 3);
        bat_priv->claim_dest.type = 0;
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (primary_if) {
                bat_priv->claim_dest.group =
                        htons(crc16(0, primary_if->net_dev->dev_addr,
                                    ETH_ALEN));
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        } else {
                bat_priv->claim_dest.group = 0; /* will be set later */
        }
        struct hard_iface *primary_if;
 
        cancel_delayed_work_sync(&bat_priv->bla_work);
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
 
        if (bat_priv->claim_hash) {
                bla_purge_claims(bat_priv, primary_if, 1);
                bat_priv->backbone_hash = NULL;
        }
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 /* @bat_priv: the bat priv with all the soft interface information
 
        ethhdr = (struct ethhdr *)skb_mac_header(skb);
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto handled;
 
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        if (claim)
                claim_free_ref(claim);
        return ret;
        struct hard_iface *primary_if;
        int ret = 0;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
        ret = 1;
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        if (claim)
                claim_free_ref(claim);
        return ret;
        bool is_own;
        int ret = 0;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if) {
                ret = seq_printf(seq,
                                 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
        }
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return ret;
 }
 
        struct hlist_node *node;
        int gw_count = 0, ret = 0;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if) {
                ret = seq_printf(seq,
                                 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return ret;
 }
 
 
        struct vis_packet *vis_packet;
        struct hard_iface *primary_if;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
        batadv_bla_update_orig_address(bat_priv, primary_if, oldif);
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 static void primary_if_select(struct bat_priv *bat_priv,
 
 out:
        if (curr_hard_iface)
-               hardif_free_ref(curr_hard_iface);
+               batadv_hardif_free_ref(curr_hard_iface);
 }
 
 static bool hardif_is_iface_up(const struct hard_iface *hard_iface)
        /* the first active interface becomes our primary interface or
         * the next active interface after the old primary interface was removed
         */
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                primary_if_select(bat_priv, hard_iface);
 
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 static void hardif_deactivate_interface(struct hard_iface *hard_iface)
 err_dev:
        dev_put(soft_iface);
 err:
-       hardif_free_ref(hard_iface);
+       batadv_hardif_free_ref(hard_iface);
        return ret;
 }
 
        bat_priv->num_ifaces--;
        batadv_orig_hash_del_if(hard_iface, bat_priv->num_ifaces);
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (hard_iface == primary_if) {
                struct hard_iface *new_if;
 
                primary_if_select(bat_priv, new_if);
 
                if (new_if)
-                       hardif_free_ref(new_if);
+                       batadv_hardif_free_ref(new_if);
        }
 
        bat_priv->bat_algo_ops->bat_iface_disable(hard_iface);
                batadv_softif_destroy(hard_iface->soft_iface);
 
        hard_iface->soft_iface = NULL;
-       hardif_free_ref(hard_iface);
+       batadv_hardif_free_ref(hard_iface);
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 static struct hard_iface *hardif_add_interface(struct net_device *net_dev)
 
        hard_iface->if_status = IF_TO_BE_REMOVED;
        batadv_sysfs_del_hardif(&hard_iface->hardif_obj);
-       hardif_free_ref(hard_iface);
+       batadv_hardif_free_ref(hard_iface);
 }
 
 void batadv_hardif_remove_interfaces(void)
                bat_priv = netdev_priv(hard_iface->soft_iface);
                bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface);
 
-               primary_if = primary_if_get_selected(bat_priv);
+               primary_if = batadv_primary_if_get_selected(bat_priv);
                if (!primary_if)
                        goto hardif_put;
 
        }
 
 hardif_put:
-       hardif_free_ref(hard_iface);
+       batadv_hardif_free_ref(hard_iface);
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return NOTIFY_DONE;
 }
 
 
 void batadv_hardif_free_rcu(struct rcu_head *rcu);
 bool batadv_is_wifi_iface(int ifindex);
 
-static inline void hardif_free_ref(struct hard_iface *hard_iface)
+static inline void
+batadv_hardif_free_ref(struct hard_iface *hard_iface)
 {
        if (atomic_dec_and_test(&hard_iface->refcount))
                call_rcu(&hard_iface->rcu, batadv_hardif_free_rcu);
 }
 
-static inline struct hard_iface *primary_if_get_selected(
-                                               struct bat_priv *bat_priv)
+static inline struct hard_iface *
+batadv_primary_if_get_selected(struct bat_priv *bat_priv)
 {
        struct hard_iface *hard_iface;
 
 
                return -EINVAL;
        }
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
 
        if (!primary_if) {
                len = -EFAULT;
        kfree_skb(skb);
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        if (neigh_node)
                batadv_neigh_node_free_ref(neigh_node);
        if (orig_node)
 
        uint32_t i;
        int ret = 0;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
 
        if (!primary_if) {
                ret = seq_printf(seq,
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return ret;
 }
 
 
                goto out;
        }
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        if (router)
                batadv_neigh_node_free_ref(router);
        if (orig_node)
                goto out;
        }
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        if (router)
                batadv_neigh_node_free_ref(router);
        if (orig_node)
                if (!orig_node) {
                        if (!batadv_is_my_client(bat_priv, ethhdr->h_dest))
                                return 0;
-                       primary_if = primary_if_get_selected(bat_priv);
+                       primary_if = batadv_primary_if_get_selected(bat_priv);
                        if (!primary_if)
                                return 0;
                        memcpy(unicast_packet->dest,
                               primary_if->net_dev->dev_addr, ETH_ALEN);
-                       hardif_free_ref(primary_if);
+                       batadv_hardif_free_ref(primary_if);
                } else {
                        memcpy(unicast_packet->dest, orig_node->orig,
                               ETH_ALEN);
 
        if (forw_packet->skb)
                kfree_skb(forw_packet->skb);
        if (forw_packet->if_incoming)
-               hardif_free_ref(forw_packet->if_incoming);
+               batadv_hardif_free_ref(forw_packet->if_incoming);
        kfree(forw_packet);
 }
 
                goto out;
        }
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out_and_inc;
 
        atomic_inc(&bat_priv->bcast_queue_left);
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return NETDEV_TX_BUSY;
 }
 
 
 
        /* ethernet packet should be broadcasted */
        if (do_bcast) {
-               primary_if = primary_if_get_selected(bat_priv);
+               primary_if = batadv_primary_if_get_selected(bat_priv);
                if (!primary_if)
                        goto dropped;
 
        bat_priv->stats.tx_dropped++;
 end:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return NETDEV_TX_OK;
 }
 
 
        struct hard_iface *primary_if;
        int req_len;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
 
        req_len = min_packet_len;
        req_len += batadv_tt_len(atomic_read(&bat_priv->tt_local_changes));
                               min_packet_len, req_len);
 
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 static int tt_changes_fill_buff(struct bat_priv *bat_priv,
        uint32_t i;
        int ret = 0;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if) {
                ret = seq_printf(seq,
                                 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
        }
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return ret;
 }
 
        uint32_t i;
        int ret = 0;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if) {
                ret = seq_printf(seq,
                                 "BATMAN mesh %s disabled - please specify interfaces to enable it\n",
        }
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return ret;
 }
 
        struct tt_req_node *tt_req_node = NULL;
        int ret = 1;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
        if (neigh_node)
                batadv_neigh_node_free_ref(neigh_node);
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        if (ret)
                kfree_skb(skb);
        if (ret && tt_req_node) {
        if (!neigh_node)
                goto out;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
        if (neigh_node)
                batadv_neigh_node_free_ref(neigh_node);
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        if (!ret)
                kfree_skb(skb);
        return ret;
        if (!neigh_node)
                goto out;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
        if (neigh_node)
                batadv_neigh_node_free_ref(neigh_node);
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        if (!ret)
                kfree_skb(skb);
        /* This packet was for me, so it doesn't need to be re-routed */
        roam_adv_packet->header.packet_type = BAT_ROAM_ADV;
        roam_adv_packet->header.version = COMPAT_VERSION;
        roam_adv_packet->header.ttl = TTL;
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
        memcpy(roam_adv_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN);
-       hardif_free_ref(primary_if);
+       batadv_hardif_free_ref(primary_if);
        memcpy(roam_adv_packet->dst, orig_node->orig, ETH_ALEN);
        memcpy(roam_adv_packet->client, client, ETH_ALEN);
 
 
        int large_tail = 0, ret = NET_RX_DROP;
        uint16_t seqno;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto dropped;
 
        kfree_skb(skb);
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return ret;
 }
 
 
        size_t buff_pos, buf_size;
        char *buff;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
        return ret;
 }
 
        struct hard_iface *primary_if;
        struct vis_packet *packet;
 
-       primary_if = primary_if_get_selected(bat_priv);
+       primary_if = batadv_primary_if_get_selected(bat_priv);
        if (!primary_if)
                goto out;
 
 
 out:
        if (primary_if)
-               hardif_free_ref(primary_if);
+               batadv_hardif_free_ref(primary_if);
 }
 
 /* called from timer; send (and maybe generate) vis packet. */