diff options
37 files changed, 2011 insertions, 1844 deletions
diff --git a/net/batman-adv/Makefile b/net/batman-adv/Makefile index 6d5c1940667d..8676d2b1d574 100644 --- a/net/batman-adv/Makefile +++ b/net/batman-adv/Makefile @@ -19,11 +19,10 @@ # obj-$(CONFIG_BATMAN_ADV) += batman-adv.o -batman-adv-y += bat_debugfs.o batman-adv-y += bat_iv_ogm.o -batman-adv-y += bat_sysfs.o batman-adv-y += bitarray.o batman-adv-$(CONFIG_BATMAN_ADV_BLA) += bridge_loop_avoidance.o +batman-adv-y += debugfs.o batman-adv-y += gateway_client.o batman-adv-y += gateway_common.o batman-adv-y += hard-interface.o @@ -35,6 +34,7 @@ batman-adv-y += ring_buffer.o batman-adv-y += routing.o batman-adv-y += send.o batman-adv-y += soft-interface.o +batman-adv-y += sysfs.o batman-adv-y += translation-table.o batman-adv-y += unicast.o batman-adv-y += vis.o diff --git a/net/batman-adv/bat_iv_ogm.c b/net/batman-adv/bat_iv_ogm.c index bbe0f123d2a5..e877af8bdd1e 100644 --- a/net/batman-adv/bat_iv_ogm.c +++ b/net/batman-adv/bat_iv_ogm.c @@ -28,13 +28,13 @@ #include "send.h" #include "bat_algo.h" -static struct neigh_node *batadv_iv_ogm_neigh_new(struct hard_iface *hard_iface, - const uint8_t *neigh_addr, - struct orig_node *orig_node, - struct orig_node *orig_neigh, - __be32 seqno) +static struct batadv_neigh_node * +batadv_iv_ogm_neigh_new(struct batadv_hard_iface *hard_iface, + const uint8_t *neigh_addr, + struct batadv_orig_node *orig_node, + struct batadv_orig_node *orig_neigh, __be32 seqno) { - struct neigh_node *neigh_node; + struct batadv_neigh_node *neigh_node; neigh_node = batadv_neigh_node_new(hard_iface, neigh_addr, ntohl(seqno)); @@ -54,9 +54,9 @@ out: return neigh_node; } -static int batadv_iv_ogm_iface_enable(struct hard_iface *hard_iface) +static int batadv_iv_ogm_iface_enable(struct batadv_hard_iface *hard_iface) { - struct batman_ogm_packet *batman_ogm_packet; + struct batadv_ogm_packet *batadv_ogm_packet; uint32_t random_seqno; int res = -ENOMEM; @@ -70,14 +70,14 @@ static int batadv_iv_ogm_iface_enable(struct hard_iface *hard_iface) if (!hard_iface->packet_buff) goto out; - batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff; - batman_ogm_packet->header.packet_type = BAT_IV_OGM; - batman_ogm_packet->header.version = BATADV_COMPAT_VERSION; - batman_ogm_packet->header.ttl = 2; - batman_ogm_packet->flags = BATADV_NO_FLAGS; - batman_ogm_packet->tq = BATADV_TQ_MAX_VALUE; - batman_ogm_packet->tt_num_changes = 0; - batman_ogm_packet->ttvn = 0; + batadv_ogm_packet = (struct batadv_ogm_packet *)hard_iface->packet_buff; + batadv_ogm_packet->header.packet_type = BATADV_IV_OGM; + batadv_ogm_packet->header.version = BATADV_COMPAT_VERSION; + batadv_ogm_packet->header.ttl = 2; + batadv_ogm_packet->flags = BATADV_NO_FLAGS; + batadv_ogm_packet->tq = BATADV_TQ_MAX_VALUE; + batadv_ogm_packet->tt_num_changes = 0; + batadv_ogm_packet->ttvn = 0; res = 0; @@ -85,35 +85,36 @@ out: return res; } -static void batadv_iv_ogm_iface_disable(struct hard_iface *hard_iface) +static void batadv_iv_ogm_iface_disable(struct batadv_hard_iface *hard_iface) { kfree(hard_iface->packet_buff); hard_iface->packet_buff = NULL; } -static void batadv_iv_ogm_iface_update_mac(struct hard_iface *hard_iface) +static void batadv_iv_ogm_iface_update_mac(struct batadv_hard_iface *hard_iface) { - struct batman_ogm_packet *batman_ogm_packet; + struct batadv_ogm_packet *batadv_ogm_packet; - batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff; - memcpy(batman_ogm_packet->orig, + batadv_ogm_packet = (struct batadv_ogm_packet *)hard_iface->packet_buff; + memcpy(batadv_ogm_packet->orig, hard_iface->net_dev->dev_addr, ETH_ALEN); - memcpy(batman_ogm_packet->prev_sender, + memcpy(batadv_ogm_packet->prev_sender, hard_iface->net_dev->dev_addr, ETH_ALEN); } -static void batadv_iv_ogm_primary_iface_set(struct hard_iface *hard_iface) +static void +batadv_iv_ogm_primary_iface_set(struct batadv_hard_iface *hard_iface) { - struct batman_ogm_packet *batman_ogm_packet; + struct batadv_ogm_packet *batadv_ogm_packet; - batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff; - batman_ogm_packet->flags = PRIMARIES_FIRST_HOP; - batman_ogm_packet->header.ttl = BATADV_TTL; + batadv_ogm_packet = (struct batadv_ogm_packet *)hard_iface->packet_buff; + batadv_ogm_packet->flags = BATADV_PRIMARIES_FIRST_HOP; + batadv_ogm_packet->header.ttl = BATADV_TTL; } /* when do we schedule our own ogm to be sent */ static unsigned long -batadv_iv_ogm_emit_send_time(const struct bat_priv *bat_priv) +batadv_iv_ogm_emit_send_time(const struct batadv_priv *bat_priv) { unsigned int msecs; @@ -130,7 +131,8 @@ static unsigned long batadv_iv_ogm_fwd_send_time(void) } /* apply hop penalty for a normal link */ -static uint8_t batadv_hop_penalty(uint8_t tq, const struct bat_priv *bat_priv) +static uint8_t batadv_hop_penalty(uint8_t tq, + const struct batadv_priv *bat_priv) { int hop_penalty = atomic_read(&bat_priv->hop_penalty); int new_tq; @@ -155,80 +157,80 @@ static int batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len, } /* send a batman ogm to a given interface */ -static void batadv_iv_ogm_send_to_if(struct forw_packet *forw_packet, - struct hard_iface *hard_iface) +static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet, + struct batadv_hard_iface *hard_iface) { - struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); + struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); char *fwd_str; uint8_t packet_num; int16_t buff_pos; - struct batman_ogm_packet *batman_ogm_packet; + struct batadv_ogm_packet *batadv_ogm_packet; struct sk_buff *skb; - if (hard_iface->if_status != IF_ACTIVE) + if (hard_iface->if_status != BATADV_IF_ACTIVE) return; packet_num = 0; buff_pos = 0; - batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data; + batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data; /* adjust all flags and log packets */ while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len, - batman_ogm_packet->tt_num_changes)) { + batadv_ogm_packet->tt_num_changes)) { /* we might have aggregated direct link packets with an * ordinary base packet */ if ((forw_packet->direct_link_flags & (1 << packet_num)) && (forw_packet->if_incoming == hard_iface)) - batman_ogm_packet->flags |= DIRECTLINK; + batadv_ogm_packet->flags |= BATADV_DIRECTLINK; else - batman_ogm_packet->flags &= ~DIRECTLINK; + batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK; 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, - ntohl(batman_ogm_packet->seqno), - batman_ogm_packet->tq, batman_ogm_packet->header.ttl, - (batman_ogm_packet->flags & DIRECTLINK ? + batadv_ogm_packet->orig, + ntohl(batadv_ogm_packet->seqno), + batadv_ogm_packet->tq, batadv_ogm_packet->header.ttl, + (batadv_ogm_packet->flags & BATADV_DIRECTLINK ? "on" : "off"), - batman_ogm_packet->ttvn, hard_iface->net_dev->name, + batadv_ogm_packet->ttvn, hard_iface->net_dev->name, hard_iface->net_dev->dev_addr); buff_pos += BATADV_OGM_HLEN; - buff_pos += batadv_tt_len(batman_ogm_packet->tt_num_changes); + buff_pos += batadv_tt_len(batadv_ogm_packet->tt_num_changes); packet_num++; - batman_ogm_packet = (struct batman_ogm_packet *) + batadv_ogm_packet = (struct batadv_ogm_packet *) (forw_packet->skb->data + buff_pos); } /* create clone because function is called more than once */ skb = skb_clone(forw_packet->skb, GFP_ATOMIC); if (skb) { - batadv_inc_counter(bat_priv, BAT_CNT_MGMT_TX); - batadv_add_counter(bat_priv, BAT_CNT_MGMT_TX_BYTES, + batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_TX); + batadv_add_counter(bat_priv, BATADV_CNT_MGMT_TX_BYTES, skb->len + ETH_HLEN); batadv_send_skb_packet(skb, hard_iface, batadv_broadcast_addr); } } /* send a batman ogm packet */ -static void batadv_iv_ogm_emit(struct forw_packet *forw_packet) +static void batadv_iv_ogm_emit(struct batadv_forw_packet *forw_packet) { - struct hard_iface *hard_iface; + struct batadv_hard_iface *hard_iface; struct net_device *soft_iface; - struct bat_priv *bat_priv; - struct hard_iface *primary_if = NULL; - struct batman_ogm_packet *batman_ogm_packet; + struct batadv_priv *bat_priv; + struct batadv_hard_iface *primary_if = NULL; + struct batadv_ogm_packet *batadv_ogm_packet; unsigned char directlink; - batman_ogm_packet = (struct batman_ogm_packet *) + batadv_ogm_packet = (struct batadv_ogm_packet *) (forw_packet->skb->data); - directlink = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0); + directlink = (batadv_ogm_packet->flags & BATADV_DIRECTLINK ? 1 : 0); if (!forw_packet->if_incoming) { pr_err("Error - can't forward packet: incoming iface not specified\n"); @@ -238,7 +240,7 @@ static void batadv_iv_ogm_emit(struct forw_packet *forw_packet) soft_iface = forw_packet->if_incoming->soft_iface; bat_priv = netdev_priv(soft_iface); - if (forw_packet->if_incoming->if_status != IF_ACTIVE) + if (forw_packet->if_incoming->if_status != BATADV_IF_ACTIVE) goto out; primary_if = batadv_primary_if_get_selected(bat_priv); @@ -248,16 +250,16 @@ static void batadv_iv_ogm_emit(struct forw_packet *forw_packet) /* multihomed peer assumed * non-primary OGMs are only broadcasted on their interface */ - if ((directlink && (batman_ogm_packet->header.ttl == 1)) || + if ((directlink && (batadv_ogm_packet->header.ttl == 1)) || (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, - ntohl(batman_ogm_packet->seqno), - batman_ogm_packet->header.ttl, + batadv_ogm_packet->orig, + ntohl(batadv_ogm_packet->seqno), + batadv_ogm_packet->header.ttl, forw_packet->if_incoming->net_dev->name, forw_packet->if_incoming->net_dev->dev_addr); @@ -287,20 +289,20 @@ out: /* return true if new_packet can be aggregated with forw_packet */ static bool -batadv_iv_ogm_can_aggregate(const struct batman_ogm_packet *new_bat_ogm_packet, - struct bat_priv *bat_priv, +batadv_iv_ogm_can_aggregate(const struct batadv_ogm_packet *new_bat_ogm_packet, + struct batadv_priv *bat_priv, int packet_len, unsigned long send_time, bool directlink, - const struct hard_iface *if_incoming, - const struct forw_packet *forw_packet) + const struct batadv_hard_iface *if_incoming, + const struct batadv_forw_packet *forw_packet) { - struct batman_ogm_packet *batman_ogm_packet; + struct batadv_ogm_packet *batadv_ogm_packet; int aggregated_bytes = forw_packet->packet_len + packet_len; - struct hard_iface *primary_if = NULL; + struct batadv_hard_iface *primary_if = NULL; bool res = false; unsigned long aggregation_end_time; - batman_ogm_packet = (struct batman_ogm_packet *)forw_packet->skb->data; + batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data; aggregation_end_time = send_time; aggregation_end_time += msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS); @@ -330,8 +332,8 @@ batadv_iv_ogm_can_aggregate(const struct batman_ogm_packet *new_bat_ogm_packet, * are flooded through the net */ if ((!directlink) && - (!(batman_ogm_packet->flags & DIRECTLINK)) && - (batman_ogm_packet->header.ttl != 1) && + (!(batadv_ogm_packet->flags & BATADV_DIRECTLINK)) && + (batadv_ogm_packet->header.ttl != 1) && /* own packets originating non-primary * interfaces leave only that interface @@ -353,7 +355,7 @@ batadv_iv_ogm_can_aggregate(const struct batman_ogm_packet *new_bat_ogm_packet, * own secondary interface packets * (= secondary interface packets in general) */ - (batman_ogm_packet->flags & DIRECTLINK || + (batadv_ogm_packet->flags & BATADV_DIRECTLINK || (forw_packet->own && forw_packet->if_incoming != primary_if))) { res = true; @@ -371,11 +373,11 @@ out: static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff, int packet_len, unsigned long send_time, bool direct_link, - struct hard_iface *if_incoming, + struct batadv_hard_iface *if_incoming, int own_packet) { - struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); - struct forw_packet *forw_packet_aggr; + struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); + struct batadv_forw_packet *forw_packet_aggr; unsigned char *skb_buff; unsigned int skb_size; @@ -385,7 +387,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; } @@ -447,7 +449,7 @@ out: } /* aggregate a new packet into the existing ogm packet */ -static void batadv_iv_ogm_aggregate(struct forw_packet *forw_packet_aggr, +static void batadv_iv_ogm_aggregate(struct batadv_forw_packet *forw_packet_aggr, const unsigned char *packet_buff, int packet_len, bool direct_link) { @@ -464,23 +466,24 @@ static void batadv_iv_ogm_aggregate(struct forw_packet *forw_packet_aggr, (1 << forw_packet_aggr->num_packets); } -static void batadv_iv_ogm_queue_add(struct bat_priv *bat_priv, +static void batadv_iv_ogm_queue_add(struct batadv_priv *bat_priv, unsigned char *packet_buff, int packet_len, - struct hard_iface *if_incoming, + struct batadv_hard_iface *if_incoming, int own_packet, unsigned long send_time) { /* _aggr -> pointer to the packet we want to aggregate with * _pos -> pointer to the position in the queue */ - struct forw_packet *forw_packet_aggr = NULL, *forw_packet_pos = NULL; + struct batadv_forw_packet *forw_packet_aggr = NULL; + struct batadv_forw_packet *forw_packet_pos = NULL; struct hlist_node *tmp_node; - struct batman_ogm_packet *batman_ogm_packet; + struct batadv_ogm_packet *batadv_ogm_packet; bool direct_link; unsigned long max_aggregation_jiffies; - batman_ogm_packet = (struct batman_ogm_packet *)packet_buff; - direct_link = batman_ogm_packet->flags & DIRECTLINK ? 1 : 0; + batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff; + direct_link = batadv_ogm_packet->flags & BATADV_DIRECTLINK ? 1 : 0; max_aggregation_jiffies = msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS); /* find position for the packet in the forward queue */ @@ -489,7 +492,7 @@ static void batadv_iv_ogm_queue_add(struct bat_priv *bat_priv, if ((atomic_read(&bat_priv->aggregated_ogms)) && (!own_packet)) { hlist_for_each_entry(forw_packet_pos, tmp_node, &bat_priv->forw_bat_list, list) { - if (batadv_iv_ogm_can_aggregate(batman_ogm_packet, + if (batadv_iv_ogm_can_aggregate(batadv_ogm_packet, bat_priv, packet_len, send_time, direct_link, if_incoming, @@ -524,18 +527,18 @@ static void batadv_iv_ogm_queue_add(struct bat_priv *bat_priv, } } -static void batadv_iv_ogm_forward(struct orig_node *orig_node, +static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node, const struct ethhdr *ethhdr, - struct batman_ogm_packet *batman_ogm_packet, + struct batadv_ogm_packet *batadv_ogm_packet, bool is_single_hop_neigh, bool is_from_best_next_hop, - struct hard_iface *if_incoming) + struct batadv_hard_iface *if_incoming) { - struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); + struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); uint8_t tt_num_changes; - if (batman_ogm_packet->header.ttl <= 1) { - batadv_dbg(DBG_BATMAN, bat_priv, "ttl exceeded\n"); + if (batadv_ogm_packet->header.ttl <= 1) { + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "ttl exceeded\n"); return; } @@ -547,41 +550,41 @@ static void batadv_iv_ogm_forward(struct orig_node *orig_node, * simply drop the ogm. */ if (is_single_hop_neigh) - batman_ogm_packet->flags |= NOT_BEST_NEXT_HOP; + batadv_ogm_packet->flags |= BATADV_NOT_BEST_NEXT_HOP; else return; } - tt_num_changes = batman_ogm_packet->tt_num_changes; + tt_num_changes = batadv_ogm_packet->tt_num_changes; - batman_ogm_packet->header.ttl--; - memcpy(batman_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN); + batadv_ogm_packet->header.ttl--; + memcpy(batadv_ogm_packet->prev_sender, ethhdr->h_source, ETH_ALEN); /* apply hop penalty */ - batman_ogm_packet->tq = batadv_hop_penalty(batman_ogm_packet->tq, + batadv_ogm_packet->tq = batadv_hop_penalty(batadv_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); + batadv_ogm_packet->tq, batadv_ogm_packet->header.ttl); /* switch of primaries first hop flag when forwarding */ - batman_ogm_packet->flags &= ~PRIMARIES_FIRST_HOP; + batadv_ogm_packet->flags &= ~BATADV_PRIMARIES_FIRST_HOP; if (is_single_hop_neigh) - batman_ogm_packet->flags |= DIRECTLINK; + batadv_ogm_packet->flags |= BATADV_DIRECTLINK; else - batman_ogm_packet->flags &= ~DIRECTLINK; + batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK; - batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batman_ogm_packet, + batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batadv_ogm_packet, BATADV_OGM_HLEN + batadv_tt_len(tt_num_changes), if_incoming, 0, batadv_iv_ogm_fwd_send_time()); } -static void batadv_iv_ogm_schedule(struct hard_iface *hard_iface) +static void batadv_iv_ogm_schedule(struct batadv_hard_iface *hard_iface) { - struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); - struct batman_ogm_packet *batman_ogm_packet; - struct hard_iface *primary_if; + struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); + struct batadv_ogm_packet *batadv_ogm_packet; + struct batadv_hard_iface *primary_if; int vis_server, tt_num_changes = 0; vis_server = atomic_read(&bat_priv->vis_mode); @@ -593,29 +596,29 @@ static void batadv_iv_ogm_schedule(struct hard_iface *hard_iface) &hard_iface->packet_len, BATADV_OGM_HLEN); - batman_ogm_packet = (struct batman_ogm_packet *)hard_iface->packet_buff; + batadv_ogm_packet = (struct batadv_ogm_packet *)hard_iface->packet_buff; /* change sequence number to network order */ - batman_ogm_packet->seqno = + batadv_ogm_packet->seqno = htonl((uint32_t)atomic_read(&hard_iface->seqno)); atomic_inc(&hard_iface->seqno); - batman_ogm_packet->ttvn = atomic_read(&bat_priv->ttvn); - batman_ogm_packet->tt_crc = htons(bat_priv->tt_crc); + batadv_ogm_packet->ttvn = atomic_read(&bat_priv->ttvn); + batadv_ogm_packet->tt_crc = htons(bat_priv->tt_crc); if (tt_num_changes >= 0) - batman_ogm_packet->tt_num_changes = tt_num_changes; + batadv_ogm_packet->tt_num_changes = tt_num_changes; - if (vis_server == VIS_TYPE_SERVER_SYNC) - batman_ogm_packet->flags |= VIS_SERVER; + if (vis_server == BATADV_VIS_TYPE_SERVER_SYNC) + batadv_ogm_packet->flags |= BATADV_VIS_SERVER; else - batman_ogm_packet->flags &= ~VIS_SERVER; + batadv_ogm_packet->flags &= ~BATADV_VIS_SERVER; if ((hard_iface == primary_if) && - (atomic_read(&bat_priv->gw_mode) == GW_MODE_SERVER)) - batman_ogm_packet->gw_flags = + (atomic_read(&bat_priv->gw_mode) == BATADV_GW_MODE_SERVER)) + batadv_ogm_packet->gw_flags = (uint8_t)atomic_read(&bat_priv->gw_bandwidth); else - batman_ogm_packet->gw_flags = BATADV_NO_FLAGS; + batadv_ogm_packet->gw_flags = BATADV_NO_FLAGS; batadv_slide_own_bcast_window(hard_iface); batadv_iv_ogm_queue_add(bat_priv, hard_iface->packet_buff, @@ -627,22 +630,22 @@ static void batadv_iv_ogm_schedule(struct hard_iface *hard_iface) } static void -batadv_iv_ogm_orig_update(struct bat_priv *bat_priv, - struct orig_node *orig_node, +batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const struct ethhdr *ethhdr, - const struct batman_ogm_packet *batman_ogm_packet, - struct hard_iface *if_incoming, + const struct batadv_ogm_packet *batadv_ogm_packet, + struct batadv_hard_iface *if_incoming, const unsigned char *tt_buff, int is_duplicate) { - struct neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL; - struct neigh_node *router = NULL; - struct orig_node *orig_node_tmp; + struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node = NULL; + struct batadv_neigh_node *router = NULL; + struct batadv_orig_node *orig_node_tmp; struct hlist_node *node; 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(); @@ -670,7 +673,7 @@ batadv_iv_ogm_orig_update(struct bat_priv *bat_priv, } if (!neigh_node) { - struct orig_node *orig_tmp; + struct batadv_orig_node *orig_tmp; orig_tmp = batadv_get_orig_node(bat_priv, ethhdr->h_source); if (!orig_tmp) @@ -679,30 +682,30 @@ batadv_iv_ogm_orig_update(struct bat_priv *bat_priv, neigh_node = batadv_iv_ogm_neigh_new(if_incoming, ethhdr->h_source, orig_node, orig_tmp, - batman_ogm_packet->seqno); + batadv_ogm_packet->seqno); batadv_orig_node_free_ref(orig_tmp); 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(); - orig_node->flags = batman_ogm_packet->flags; + orig_node->flags = batadv_ogm_packet->flags; neigh_node->last_seen = jiffies; spin_lock_bh(&neigh_node->lq_update_lock); batadv_ring_buffer_set(neigh_node->tq_recv, &neigh_node->tq_index, - batman_ogm_packet->tq); + batadv_ogm_packet->tq); neigh_node->tq_avg = batadv_ring_buffer_avg(neigh_node->tq_recv); spin_unlock_bh(&neigh_node->lq_update_lock); if (!is_duplicate) { - orig_node->last_ttl = batman_ogm_packet->header.ttl; - neigh_node->last_ttl = batman_ogm_packet->header.ttl; + orig_node->last_ttl = batadv_ogm_packet->header.ttl; + neigh_node->last_ttl = batadv_ogm_packet->header.ttl; } batadv_bonding_candidate_add(orig_node, neigh_node); @@ -744,23 +747,23 @@ update_tt: /* I have to check for transtable changes only if the OGM has been * sent through a primary interface */ - if (((batman_ogm_packet->orig != ethhdr->h_source) && - (batman_ogm_packet->header.ttl > 2)) || - (batman_ogm_packet->flags & PRIMARIES_FIRST_HOP)) + if (((batadv_ogm_packet->orig != ethhdr->h_source) && + (batadv_ogm_packet->header.ttl > 2)) || + (batadv_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP)) batadv_tt_update_orig(bat_priv, orig_node, tt_buff, - batman_ogm_packet->tt_num_changes, - batman_ogm_packet->ttvn, - ntohs(batman_ogm_packet->tt_crc)); + batadv_ogm_packet->tt_num_changes, + batadv_ogm_packet->ttvn, + ntohs(batadv_ogm_packet->tt_crc)); - if (orig_node->gw_flags != batman_ogm_packet->gw_flags) + if (orig_node->gw_flags != batadv_ogm_packet->gw_flags) batadv_gw_node_update(bat_priv, orig_node, - batman_ogm_packet->gw_flags); + batadv_ogm_packet->gw_flags); - orig_node->gw_flags = batman_ogm_packet->gw_flags; + orig_node->gw_flags = batadv_ogm_packet->gw_flags; /* restart gateway selection if fast or late switching was enabled */ if ((orig_node->gw_flags) && - (atomic_read(&bat_priv->gw_mode) == GW_MODE_CLIENT) && + (atomic_read(&bat_priv->gw_mode) == BATADV_GW_MODE_CLIENT) && (atomic_read(&bat_priv->gw_sel_class) > 2)) batadv_gw_check_election(bat_priv, orig_node); @@ -775,13 +778,13 @@ out: batadv_neigh_node_free_ref(router); } -static int batadv_iv_ogm_calc_tq(struct orig_node *orig_node, - struct orig_node *orig_neigh_node, - struct batman_ogm_packet *batman_ogm_packet, - struct hard_iface *if_incoming) +static int batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node, + struct batadv_orig_node *orig_neigh_node, + struct batadv_ogm_packet *batadv_ogm_packet, + struct batadv_hard_iface *if_incoming) { - struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); - struct neigh_node *neigh_node = NULL, *tmp_neigh_node; + struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); + struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node; struct hlist_node *node; uint8_t total_count; uint8_t orig_eq_count, neigh_rq_count, neigh_rq_inv, tq_own; @@ -814,7 +817,7 @@ static int batadv_iv_ogm_calc_tq(struct orig_node *orig_node, orig_neigh_node->orig, orig_neigh_node, orig_neigh_node, - batman_ogm_packet->seqno); + batadv_ogm_packet->seqno); if (!neigh_node) goto out; @@ -862,20 +865,20 @@ static int batadv_iv_ogm_calc_tq(struct orig_node *orig_node, inv_asym_penalty /= neigh_rq_max_cube; tq_asym_penalty = BATADV_TQ_MAX_VALUE - inv_asym_penalty; - combined_tq = batman_ogm_packet->tq * tq_own * tq_asym_penalty; + combined_tq = batadv_ogm_packet->tq * tq_own * tq_asym_penalty; combined_tq /= BATADV_TQ_MAX_VALUE * BATADV_TQ_MAX_VALUE; - batman_ogm_packet->tq = combined_tq; + batadv_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, - tq_asym_penalty, batman_ogm_packet->tq); + tq_asym_penalty, batadv_ogm_packet->tq); /* if link has the minimum required transmission quality * consider it bidirectional */ - if (batman_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT) + if (batadv_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT) ret = 1; out: @@ -894,21 +897,21 @@ out: */ static int batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr, - const struct batman_ogm_packet *batman_ogm_packet, - const struct hard_iface *if_incoming) + const struct batadv_ogm_packet *batadv_ogm_packet, + const struct batadv_hard_iface *if_incoming) { - struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); - struct orig_node *orig_node; - struct neigh_node *tmp_neigh_node; + struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); + struct batadv_orig_node *orig_node; + struct batadv_neigh_node *tmp_neigh_node; struct hlist_node *node; int is_duplicate = 0; int32_t seq_diff; int need_update = 0; int set_mark, ret = -1; - uint32_t seqno = ntohl(batman_ogm_packet->seqno); + uint32_t seqno = ntohl(batadv_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, batadv_ogm_packet->orig); if (!orig_node) return 0; @@ -948,7 +951,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; @@ -963,15 +966,15 @@ out: } static void batadv_iv_ogm_process(const struct ethhdr *ethhdr, - struct batman_ogm_packet *batman_ogm_packet, + struct batadv_ogm_packet *batadv_ogm_packet, const unsigned char *tt_buff, - struct hard_iface *if_incoming) + struct batadv_hard_iface *if_incoming) { - struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); - struct hard_iface *hard_iface; - struct orig_node *orig_neigh_node, *orig_node; - struct neigh_node *router = NULL, *router_router = NULL; - struct neigh_node *orig_neigh_router = NULL; + struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); + struct batadv_hard_iface *hard_iface; + struct batadv_orig_node *orig_neigh_node, *orig_node; + struct batadv_neigh_node *router = NULL, *router_router = NULL; + struct batadv_neigh_node *orig_neigh_router = NULL; int has_directlink_flag; int is_my_addr = 0, is_my_orig = 0, is_my_oldorig = 0; int is_broadcast = 0, is_bidirect; @@ -989,35 +992,38 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr, * it as an additional length. * * TODO: A more sane solution would be to have a bit in the - * batman_ogm_packet to detect whether the packet is the last + * batadv_ogm_packet to detect whether the packet is the last * packet in an aggregation. Here we expect that the padding * is always zero (or not 0x01) */ - if (batman_ogm_packet->header.packet_type != BAT_IV_OGM) + if (batadv_ogm_packet->header.packet_type != BATADV_IV_OGM) return; /* could be changed by schedule_own_packet() */ if_incoming_seqno = atomic_read(&if_incoming->seqno); - has_directlink_flag = (batman_ogm_packet->flags & DIRECTLINK ? 1 : 0); + if (batadv_ogm_packet->flags & BATADV_DIRECTLINK) + has_directlink_flag = 1; + else + has_directlink_flag = 0; - if (batadv_compare_eth(ethhdr->h_source, batman_ogm_packet->orig)) + if (batadv_compare_eth(ethhdr->h_source, batadv_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, - batman_ogm_packet->prev_sender, - 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->header.ttl, - batman_ogm_packet->header.version, has_directlink_flag); + if_incoming->net_dev->dev_addr, batadv_ogm_packet->orig, + batadv_ogm_packet->prev_sender, + ntohl(batadv_ogm_packet->seqno), batadv_ogm_packet->ttvn, + ntohs(batadv_ogm_packet->tt_crc), + batadv_ogm_packet->tt_num_changes, batadv_ogm_packet->tq, + batadv_ogm_packet->header.ttl, + batadv_ogm_packet->header.version, has_directlink_flag); rcu_read_lock(); list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { - if (hard_iface->if_status != IF_ACTIVE) + if (hard_iface->if_status != BATADV_IF_ACTIVE) continue; if (hard_iface->soft_iface != if_incoming->soft_iface) @@ -1027,11 +1033,11 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr, hard_iface->net_dev->dev_addr)) is_my_addr = 1; - if (batadv_compare_eth(batman_ogm_packet->orig, + if (batadv_compare_eth(batadv_ogm_packet->orig, hard_iface->net_dev->dev_addr)) is_my_orig = 1; - if (batadv_compare_eth(batman_ogm_packet->prev_sender, + if (batadv_compare_eth(batadv_ogm_packet->prev_sender, hard_iface->net_dev->dev_addr)) is_my_oldorig = 1; @@ -1040,22 +1046,22 @@ 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, + if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) { + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Drop packet: incompatible batman version (%i)\n", - batman_ogm_packet->header.version); + batadv_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; @@ -1079,14 +1085,14 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr, */ if (has_directlink_flag && batadv_compare_eth(if_incoming->net_dev->dev_addr, - batman_ogm_packet->orig)) { + batadv_ogm_packet->orig)) { if_num = if_incoming->if_num; offset = if_num * BATADV_NUM_WORDS; spin_lock_bh(&orig_neigh_node->ogm_cnt_lock); word = &(orig_neigh_node->bcast_own[offset]); bit_pos = if_incoming_seqno - 2; - bit_pos -= ntohl(batman_ogm_packet->seqno); + bit_pos -= ntohl(batadv_ogm_packet->seqno); batadv_set_bit(word, bit_pos); weight = &orig_neigh_node->bcast_own_sum[if_num]; *weight = bitmap_weight(word, @@ -1094,42 +1100,42 @@ 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 & NOT_BEST_NEXT_HOP) { - batadv_dbg(DBG_BATMAN, bat_priv, + if (batadv_ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP) { + 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; } - orig_node = batadv_get_orig_node(bat_priv, batman_ogm_packet->orig); + orig_node = batadv_get_orig_node(bat_priv, batadv_ogm_packet->orig); if (!orig_node) return; - is_duplicate = batadv_iv_ogm_update_seqnos(ethhdr, batman_ogm_packet, + is_duplicate = batadv_iv_ogm_update_seqnos(ethhdr, batadv_ogm_packet, 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, + if (batadv_ogm_packet->tq == 0) { + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Drop packet: originator packet with tq equal 0\n"); goto out; } @@ -1142,13 +1148,13 @@ static void batadv_iv_ogm_process(const struct ethhdr *ethhdr, (batadv_compare_eth(router->addr, ethhdr->h_source))) is_from_best_next_hop = true; - prev_sender = batman_ogm_packet->prev_sender; + prev_sender = batadv_ogm_packet->prev_sender; /* avoid temporary routing loops */ if (router && router_router && (batadv_compare_eth(router->addr, prev_sender)) && - !(batadv_compare_eth(batman_ogm_packet->orig, prev_sender)) && + !(batadv_compare_eth(batadv_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; @@ -1169,56 +1175,56 @@ 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; } is_bidirect = batadv_iv_ogm_calc_tq(orig_node, orig_neigh_node, - batman_ogm_packet, if_incoming); + batadv_ogm_packet, if_incoming); batadv_bonding_save_primary(orig_node, orig_neigh_node, - batman_ogm_packet); + batadv_ogm_packet); /* update ranking if it is not a duplicate or has the same * seqno and similar ttl as the non-duplicate */ - sameseq = orig_node->last_real_seqno == ntohl(batman_ogm_packet->seqno); - simlar_ttl = orig_node->last_ttl - 3 <= batman_ogm_packet->header.ttl; + sameseq = orig_node->last_real_seqno == ntohl(batadv_ogm_packet->seqno); + simlar_ttl = orig_node->last_ttl - 3 <= batadv_ogm_packet->header.ttl; if (is_bidirect && (!is_duplicate || (sameseq && simlar_ttl))) batadv_iv_ogm_orig_update(bat_priv, orig_node, ethhdr, - batman_ogm_packet, if_incoming, + batadv_ogm_packet, if_incoming, tt_buff, is_duplicate); /* is single hop (direct) neighbor */ if (is_single_hop_neigh) { /* mark direct link on incoming interface */ - batadv_iv_ogm_forward(orig_node, ethhdr, batman_ogm_packet, + batadv_iv_ogm_forward(orig_node, ethhdr, batadv_ogm_packet, 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, + batadv_iv_ogm_forward(orig_node, ethhdr, batadv_ogm_packet, is_single_hop_neigh, is_from_best_next_hop, if_incoming); @@ -1237,10 +1243,10 @@ out: } static int batadv_iv_ogm_receive(struct sk_buff *skb, - struct hard_iface *if_incoming) + struct batadv_hard_iface *if_incoming) { - struct bat_priv *bat_priv = netdev_priv(if_incoming->soft_iface); - struct batman_ogm_packet *batman_ogm_packet; + struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); + struct batadv_ogm_packet *batadv_ogm_packet; struct ethhdr *ethhdr; int buff_pos = 0, packet_len; unsigned char *tt_buff, *packet_buff; @@ -1256,35 +1262,35 @@ static int batadv_iv_ogm_receive(struct sk_buff *skb, if (bat_priv->bat_algo_ops->bat_ogm_emit != batadv_iv_ogm_emit) return NET_RX_DROP; - batadv_inc_counter(bat_priv, BAT_CNT_MGMT_RX); - batadv_add_counter(bat_priv, BAT_CNT_MGMT_RX_BYTES, + batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_RX); + batadv_add_counter(bat_priv, BATADV_CNT_MGMT_RX_BYTES, skb->len + ETH_HLEN); packet_len = skb_headlen(skb); ethhdr = (struct ethhdr *)skb_mac_header(skb); packet_buff = skb->data; - batman_ogm_packet = (struct batman_ogm_packet *)packet_buff; + batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff; /* unpack the aggregated packets and process them one by one */ do { tt_buff = packet_buff + buff_pos + BATADV_OGM_HLEN; - batadv_iv_ogm_process(ethhdr, batman_ogm_packet, tt_buff, + batadv_iv_ogm_process(ethhdr, batadv_ogm_packet, tt_buff, if_incoming); buff_pos += BATADV_OGM_HLEN; - buff_pos += batadv_tt_len(batman_ogm_packet->tt_num_changes); + buff_pos += batadv_tt_len(batadv_ogm_packet->tt_num_changes); - batman_ogm_packet = (struct batman_ogm_packet *) + batadv_ogm_packet = (struct batadv_ogm_packet *) (packet_buff + buff_pos); } while (batadv_iv_ogm_aggr_packet(buff_pos, packet_len, - batman_ogm_packet->tt_num_changes)); + batadv_ogm_packet->tt_num_changes)); kfree_skb(skb); return NET_RX_SUCCESS; } -static struct bat_algo_ops batadv_batman_iv __read_mostly = { +static struct batadv_algo_ops batadv_batman_iv __read_mostly = { .name = "BATMAN_IV", .bat_iface_enable = batadv_iv_ogm_iface_enable, .bat_iface_disable = batadv_iv_ogm_iface_disable, @@ -1299,7 +1305,8 @@ int __init batadv_iv_init(void) int ret; /* batman originator packet */ - ret = batadv_recv_handler_register(BAT_IV_OGM, batadv_iv_ogm_receive); + ret = batadv_recv_handler_register(BATADV_IV_OGM, + batadv_iv_ogm_receive); if (ret < 0) goto out; @@ -1310,7 +1317,7 @@ int __init batadv_iv_init(void) goto out; handler_unregister: - batadv_recv_handler_unregister(BAT_IV_OGM); + batadv_recv_handler_unregister(BATADV_IV_OGM); out: return ret; } diff --git a/net/batman-adv/bitarray.c b/net/batman-adv/bitarray.c index 4a009b550895..aea174cdbfbd 100644 --- a/net/batman-adv/bitarray.c +++ b/net/batman-adv/bitarray.c @@ -41,7 +41,7 @@ static void batadv_bitmap_shift_left(unsigned long *seq_bits, int32_t n) int batadv_bit_get_packet(void *priv, unsigned long *seq_bits, int32_t seq_num_diff, int set_mark) { - struct bat_priv *bat_priv = priv; + struct batadv_priv *bat_priv = priv; /* sequence number is slightly older. We already got a sequence number * higher than this one, so we just mark it. @@ -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); diff --git a/net/batman-adv/bridge_loop_avoidance.c b/net/batman-adv/bridge_loop_avoidance.c index db20b688ee25..49e10d91c00b 100644 --- a/net/batman-adv/bridge_loop_avoidance.c +++ b/net/batman-adv/bridge_loop_avoidance.c @@ -34,8 +34,8 @@ static const uint8_t batadv_announce_mac[4] = {0x43, 0x05, 0x43, 0x05}; static void batadv_bla_periodic_work(struct work_struct *work); -static void batadv_bla_send_announce(struct bat_priv *bat_priv, - struct backbone_gw *backbone_gw); +static void batadv_bla_send_announce(struct batadv_priv *bat_priv, + struct batadv_backbone_gw *backbone_gw); /* return the index of the claim */ static inline uint32_t batadv_choose_claim(const void *data, uint32_t size) @@ -83,7 +83,7 @@ static inline uint32_t batadv_choose_backbone_gw(const void *data, static int batadv_compare_backbone_gw(const struct hlist_node *node, const void *data2) { - const void *data1 = container_of(node, struct backbone_gw, + const void *data1 = container_of(node, struct batadv_backbone_gw, hash_entry); return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0); @@ -93,14 +93,14 @@ static int batadv_compare_backbone_gw(const struct hlist_node *node, static int batadv_compare_claim(const struct hlist_node *node, const void *data2) { - const void *data1 = container_of(node, struct claim, + const void *data1 = container_of(node, struct batadv_claim, hash_entry); return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0); } /* free a backbone gw */ -static void batadv_backbone_gw_free_ref(struct backbone_gw *backbone_gw) +static void batadv_backbone_gw_free_ref(struct batadv_backbone_gw *backbone_gw) { if (atomic_dec_and_test(&backbone_gw->refcount)) kfree_rcu(backbone_gw, rcu); @@ -109,16 +109,16 @@ static void batadv_backbone_gw_free_ref(struct backbone_gw *backbone_gw) /* finally deinitialize the claim */ static void batadv_claim_free_rcu(struct rcu_head *rcu) { - struct claim *claim; + struct batadv_claim *claim; - claim = container_of(rcu, struct claim, rcu); + claim = container_of(rcu, struct batadv_claim, rcu); batadv_backbone_gw_free_ref(claim->backbone_gw); kfree(claim); } /* free a claim, call claim_free_rcu if its the last reference */ -static void batadv_claim_free_ref(struct claim *claim) +static void batadv_claim_free_ref(struct batadv_claim *claim) { if (atomic_dec_and_test(&claim->refcount)) call_rcu(&claim->rcu, batadv_claim_free_rcu); @@ -130,14 +130,14 @@ static void batadv_claim_free_ref(struct claim *claim) * looks for a claim in the hash, and returns it if found * or NULL otherwise. */ -static struct claim *batadv_claim_hash_find(struct bat_priv *bat_priv, - struct claim *data) +static struct batadv_claim *batadv_claim_hash_find(struct batadv_priv *bat_priv, + struct batadv_claim *data) { - struct hashtable_t *hash = bat_priv->claim_hash; + struct batadv_hashtable *hash = bat_priv->claim_hash; struct hlist_head *head; struct hlist_node *node; - struct claim *claim; - struct claim *claim_tmp = NULL; + struct batadv_claim *claim; + struct batadv_claim *claim_tmp = NULL; int index; if (!hash) @@ -169,14 +169,15 @@ static struct claim *batadv_claim_hash_find(struct bat_priv *bat_priv, * looks for a claim in the hash, and returns it if found * or NULL otherwise. */ -static struct backbone_gw *batadv_backbone_hash_find(struct bat_priv *bat_priv, - uint8_t *addr, short vid) +static struct batadv_backbone_gw * +batadv_backbone_hash_find(struct batadv_priv *bat_priv, + uint8_t *addr, short vid) { - struct hashtable_t *hash = bat_priv->backbone_hash; + struct batadv_hashtable *hash = bat_priv->backbone_hash; struct hlist_head *head; struct hlist_node *node; - struct backbone_gw search_entry, *backbone_gw; - struct backbone_gw *backbone_gw_tmp = NULL; + struct batadv_backbone_gw search_entry, *backbone_gw; + struct batadv_backbone_gw *backbone_gw_tmp = NULL; int index; if (!hash) @@ -206,12 +207,13 @@ static struct backbone_gw *batadv_backbone_hash_find(struct bat_priv *bat_priv, } /* delete all claims for a backbone */ -static void batadv_bla_del_backbone_claims(struct backbone_gw *backbone_gw) +static void +batadv_bla_del_backbone_claims(struct batadv_backbone_gw *backbone_gw) { - struct hashtable_t *hash; + struct batadv_hashtable *hash; struct hlist_node *node, *node_tmp; struct hlist_head *head; - struct claim *claim; + struct batadv_claim *claim; int i; spinlock_t *list_lock; /* protects write access to the hash lists */ @@ -247,15 +249,15 @@ static void batadv_bla_del_backbone_claims(struct backbone_gw *backbone_gw) * * sends a claim frame according to the provided info. */ -static void batadv_bla_send_claim(struct bat_priv *bat_priv, uint8_t *mac, +static void batadv_bla_send_claim(struct batadv_priv *bat_priv, uint8_t *mac, short vid, int claimtype) { struct sk_buff *skb; struct ethhdr *ethhdr; - struct hard_iface *primary_if; + struct batadv_hard_iface *primary_if; struct net_device *soft_iface; uint8_t *hw_src; - struct bla_claim_dst local_claim_dest; + struct batadv_bla_claim_dst local_claim_dest; __be32 zeroip = 0; primary_if = batadv_primary_if_get_selected(bat_priv); @@ -292,39 +294,39 @@ static void batadv_bla_send_claim(struct bat_priv *bat_priv, uint8_t *mac, /* now we pretend that the client would have sent this ... */ switch (claimtype) { - case CLAIM_TYPE_ADD: + case BATADV_CLAIM_TYPE_ADD: /* normal claim frame * 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 CLAIM_TYPE_DEL: + case BATADV_CLAIM_TYPE_DEL: /* unclaim frame * 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; - case CLAIM_TYPE_ANNOUNCE: + case BATADV_CLAIM_TYPE_ANNOUNCE: /* announcement frame * 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; - case CLAIM_TYPE_REQUEST: + case BATADV_CLAIM_TYPE_REQUEST: /* request frame * set HW SRC to the special mac containg the crc */ 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; @@ -353,11 +355,12 @@ out: * searches for the backbone gw or creates a new one if it could not * be found. */ -static struct backbone_gw *batadv_bla_get_backbone_gw(struct bat_priv *bat_priv, - uint8_t *orig, short vid) +static struct batadv_backbone_gw * +batadv_bla_get_backbone_gw(struct batadv_priv *bat_priv, uint8_t *orig, + short vid) { - struct backbone_gw *entry; - struct orig_node *orig_node; + struct batadv_backbone_gw *entry; + struct batadv_orig_node *orig_node; int hash_added; entry = batadv_backbone_hash_find(bat_priv, orig, vid); @@ -365,7 +368,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); @@ -407,11 +410,12 @@ static struct backbone_gw *batadv_bla_get_backbone_gw(struct bat_priv *bat_priv, /* update or add the own backbone gw to make sure we announce * where we receive other backbone gws */ -static void batadv_bla_update_own_backbone_gw(struct bat_priv *bat_priv, - struct hard_iface *primary_if, - short vid) +static void +batadv_bla_update_own_backbone_gw(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, + short vid) { - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; backbone_gw = batadv_bla_get_backbone_gw(bat_priv, primary_if->net_dev->dev_addr, @@ -429,17 +433,18 @@ static void batadv_bla_update_own_backbone_gw(struct bat_priv *bat_priv, * Repeat all of our own claims, and finally send an ANNOUNCE frame * to allow the requester another check if the CRC is correct now. */ -static void batadv_bla_answer_request(struct bat_priv *bat_priv, - struct hard_iface *primary_if, short vid) +static void batadv_bla_answer_request(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, + short vid) { struct hlist_node *node; struct hlist_head *head; - struct hashtable_t *hash; - struct claim *claim; - struct backbone_gw *backbone_gw; + struct batadv_hashtable *hash; + struct batadv_claim *claim; + struct batadv_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, @@ -459,7 +464,7 @@ static void batadv_bla_answer_request(struct bat_priv *bat_priv, continue; batadv_bla_send_claim(bat_priv, claim->addr, claim->vid, - CLAIM_TYPE_ADD); + BATADV_CLAIM_TYPE_ADD); } rcu_read_unlock(); } @@ -475,17 +480,17 @@ static void batadv_bla_answer_request(struct bat_priv *bat_priv, * After the request, it will repeat all of his own claims and finally * send an announcement claim with which we can check again. */ -static void batadv_bla_send_request(struct backbone_gw *backbone_gw) +static void batadv_bla_send_request(struct batadv_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, - backbone_gw->vid, CLAIM_TYPE_REQUEST); + backbone_gw->vid, BATADV_CLAIM_TYPE_REQUEST); /* no local broadcasts should be sent or received, for now. */ if (!atomic_read(&backbone_gw->request_sent)) { @@ -500,8 +505,8 @@ static void batadv_bla_send_request(struct backbone_gw *backbone_gw) * This function sends an announcement. It is called from multiple * places. */ -static void batadv_bla_send_announce(struct bat_priv *bat_priv, - struct backbone_gw *backbone_gw) +static void batadv_bla_send_announce(struct batadv_priv *bat_priv, + struct batadv_backbone_gw *backbone_gw) { uint8_t mac[ETH_ALEN]; __be16 crc; @@ -511,7 +516,7 @@ static void batadv_bla_send_announce(struct bat_priv *bat_priv, memcpy(&mac[4], &crc, 2); batadv_bla_send_claim(bat_priv, mac, backbone_gw->vid, - CLAIM_TYPE_ANNOUNCE); + BATADV_CLAIM_TYPE_ANNOUNCE); } @@ -522,12 +527,12 @@ static void batadv_bla_send_announce(struct bat_priv *bat_priv, * * Adds a claim in the claim hash. */ -static void batadv_bla_add_claim(struct bat_priv *bat_priv, const uint8_t *mac, - const short vid, - struct backbone_gw *backbone_gw) +static void batadv_bla_add_claim(struct batadv_priv *bat_priv, + const uint8_t *mac, const short vid, + struct batadv_backbone_gw *backbone_gw) { - struct claim *claim; - struct claim search_claim; + struct batadv_claim *claim; + struct batadv_claim search_claim; int hash_added; memcpy(search_claim.addr, mac, ETH_ALEN); @@ -546,7 +551,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 +570,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); @@ -588,10 +593,10 @@ claim_free_ref: /* Delete a claim from the claim hash which has the * given mac address and vid. */ -static void batadv_bla_del_claim(struct bat_priv *bat_priv, const uint8_t *mac, - const short vid) +static void batadv_bla_del_claim(struct batadv_priv *bat_priv, + const uint8_t *mac, const short vid) { - struct claim search_claim, *claim; + struct batadv_claim search_claim, *claim; memcpy(search_claim.addr, mac, ETH_ALEN); search_claim.vid = vid; @@ -599,8 +604,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); @@ -613,11 +618,11 @@ static void batadv_bla_del_claim(struct bat_priv *bat_priv, const uint8_t *mac, } /* check for ANNOUNCE frame, return 1 if handled */ -static int batadv_handle_announce(struct bat_priv *bat_priv, +static int batadv_handle_announce(struct batadv_priv *bat_priv, uint8_t *an_addr, uint8_t *backbone_addr, short vid) { - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; uint16_t crc; if (memcmp(an_addr, batadv_announce_mac, 4) != 0) @@ -633,12 +638,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); @@ -659,8 +664,8 @@ static int batadv_handle_announce(struct bat_priv *bat_priv, } /* check for REQUEST frame, return 1 if handled */ -static int batadv_handle_request(struct bat_priv *bat_priv, - struct hard_iface *primary_if, +static int batadv_handle_request(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, uint8_t *backbone_addr, struct ethhdr *ethhdr, short vid) { @@ -674,7 +679,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); @@ -683,18 +688,18 @@ static int batadv_handle_request(struct bat_priv *bat_priv, } /* check for UNCLAIM frame, return 1 if handled */ -static int batadv_handle_unclaim(struct bat_priv *bat_priv, - struct hard_iface *primary_if, +static int batadv_handle_unclaim(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, uint8_t *backbone_addr, uint8_t *claim_addr, short vid) { - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; /* unclaim in any case if it is our own */ if (primary_if && batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr)) batadv_bla_send_claim(bat_priv, claim_addr, vid, - CLAIM_TYPE_DEL); + BATADV_CLAIM_TYPE_DEL); backbone_gw = batadv_backbone_hash_find(bat_priv, backbone_addr, vid); @@ -702,7 +707,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); @@ -712,12 +717,12 @@ static int batadv_handle_unclaim(struct bat_priv *bat_priv, } /* check for CLAIM frame, return 1 if handled */ -static int batadv_handle_claim(struct bat_priv *bat_priv, - struct hard_iface *primary_if, +static int batadv_handle_claim(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, uint8_t *backbone_addr, uint8_t *claim_addr, short vid) { - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; /* register the gateway if not yet available, and add the claim. */ @@ -730,7 +735,7 @@ static int batadv_handle_claim(struct bat_priv *bat_priv, batadv_bla_add_claim(bat_priv, claim_addr, vid, backbone_gw); if (batadv_compare_eth(backbone_addr, primary_if->net_dev->dev_addr)) batadv_bla_send_claim(bat_priv, claim_addr, vid, - CLAIM_TYPE_ADD); + BATADV_CLAIM_TYPE_ADD); /* TODO: we could call something like tt_local_del() here. */ @@ -752,16 +757,16 @@ static int batadv_handle_claim(struct bat_priv *bat_priv, * 1 - if is a claim packet from another group * 0 - if it is not a claim packet */ -static int batadv_check_claim_group(struct bat_priv *bat_priv, - struct hard_iface *primary_if, +static int batadv_check_claim_group(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, uint8_t *hw_src, uint8_t *hw_dst, struct ethhdr *ethhdr) { uint8_t *backbone_addr; - struct orig_node *orig_node; - struct bla_claim_dst *bla_dst, *bla_dst_own; + struct batadv_orig_node *orig_node; + struct batadv_bla_claim_dst *bla_dst, *bla_dst_own; - bla_dst = (struct bla_claim_dst *)hw_dst; + bla_dst = (struct batadv_bla_claim_dst *)hw_dst; bla_dst_own = &bat_priv->claim_dest; /* check if it is a claim packet in general */ @@ -773,12 +778,12 @@ static int batadv_check_claim_group(struct bat_priv *bat_priv, * otherwise assume it is in the hw_src */ switch (bla_dst->type) { - case CLAIM_TYPE_ADD: + case BATADV_CLAIM_TYPE_ADD: backbone_addr = hw_src; break; - case CLAIM_TYPE_REQUEST: - case CLAIM_TYPE_ANNOUNCE: - case CLAIM_TYPE_DEL: + case BATADV_CLAIM_TYPE_REQUEST: + case BATADV_CLAIM_TYPE_ANNOUNCE: + case BATADV_CLAIM_TYPE_DEL: backbone_addr = ethhdr->h_source; break; default: @@ -804,7 +809,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; @@ -824,15 +829,15 @@ static int batadv_check_claim_group(struct bat_priv *bat_priv, * returns 1 if it was a claim frame, otherwise return 0 to * tell the callee that it can use the frame on its own. */ -static int batadv_bla_process_claim(struct bat_priv *bat_priv, - struct hard_iface *primary_if, +static int batadv_bla_process_claim(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, struct sk_buff *skb) { struct ethhdr *ethhdr; struct vlan_ethhdr *vhdr; struct arphdr *arphdr; uint8_t *hw_src, *hw_dst; - struct bla_claim_dst *bla_dst; + struct batadv_bla_claim_dst *bla_dst; uint16_t proto; int headlen; short vid = -1; @@ -876,13 +881,13 @@ static int batadv_bla_process_claim(struct bat_priv *bat_priv, hw_src = (uint8_t *)arphdr + sizeof(struct arphdr); hw_dst = hw_src + ETH_ALEN + 4; - bla_dst = (struct bla_claim_dst *)hw_dst; + bla_dst = (struct batadv_bla_claim_dst *)hw_dst; /* check if it is a claim frame. */ 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); @@ -894,30 +899,30 @@ static int batadv_bla_process_claim(struct bat_priv *bat_priv, /* check for the different types of claim frames ... */ switch (bla_dst->type) { - case CLAIM_TYPE_ADD: + case BATADV_CLAIM_TYPE_ADD: if (batadv_handle_claim(bat_priv, primary_if, hw_src, ethhdr->h_source, vid)) return 1; break; - case CLAIM_TYPE_DEL: + case BATADV_CLAIM_TYPE_DEL: if (batadv_handle_unclaim(bat_priv, primary_if, ethhdr->h_source, hw_src, vid)) return 1; break; - case CLAIM_TYPE_ANNOUNCE: + case BATADV_CLAIM_TYPE_ANNOUNCE: if (batadv_handle_announce(bat_priv, hw_src, ethhdr->h_source, vid)) return 1; break; - case CLAIM_TYPE_REQUEST: + case BATADV_CLAIM_TYPE_REQUEST: if (batadv_handle_request(bat_priv, primary_if, hw_src, ethhdr, vid)) return 1; 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; @@ -926,12 +931,12 @@ static int batadv_bla_process_claim(struct bat_priv *bat_priv, /* Check when we last heard from other nodes, and remove them in case of * a time out, or clean all backbone gws if now is set. */ -static void batadv_bla_purge_backbone_gw(struct bat_priv *bat_priv, int now) +static void batadv_bla_purge_backbone_gw(struct batadv_priv *bat_priv, int now) { - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; struct hlist_node *node, *node_tmp; struct hlist_head *head; - struct hashtable_t *hash; + struct batadv_hashtable *hash; spinlock_t *list_lock; /* protects write access to the hash lists */ int i; @@ -952,7 +957,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); @@ -977,13 +982,14 @@ purge_now: * Check when we heard last time from our own claims, and remove them in case of * a time out, or clean all claims if now is set */ -static void batadv_bla_purge_claims(struct bat_priv *bat_priv, - struct hard_iface *primary_if, int now) +static void batadv_bla_purge_claims(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, + int now) { - struct claim *claim; + struct batadv_claim *claim; struct hlist_node *node; struct hlist_head *head; - struct hashtable_t *hash; + struct batadv_hashtable *hash; int i; hash = bat_priv->claim_hash; @@ -1004,7 +1010,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); @@ -1023,14 +1029,14 @@ purge_now: * * Update the backbone gateways when the own orig address changes. */ -void batadv_bla_update_orig_address(struct bat_priv *bat_priv, - struct hard_iface *primary_if, - struct hard_iface *oldif) +void batadv_bla_update_orig_address(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, + struct batadv_hard_iface *oldif) { - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; struct hlist_node *node; struct hlist_head *head; - struct hashtable_t *hash; + struct batadv_hashtable *hash; int i; /* reset bridge loop avoidance group id */ @@ -1071,7 +1077,7 @@ void batadv_bla_update_orig_address(struct bat_priv *bat_priv, /* (re)start the timer */ -static void batadv_bla_start_timer(struct bat_priv *bat_priv) +static void batadv_bla_start_timer(struct batadv_priv *bat_priv) { INIT_DELAYED_WORK(&bat_priv->bla_work, batadv_bla_periodic_work); queue_delayed_work(batadv_event_workqueue, &bat_priv->bla_work, @@ -1086,15 +1092,15 @@ static void batadv_bla_periodic_work(struct work_struct *work) { struct delayed_work *delayed_work = container_of(work, struct delayed_work, work); - struct bat_priv *bat_priv = - container_of(delayed_work, struct bat_priv, bla_work); + struct batadv_priv *bat_priv; struct hlist_node *node; struct hlist_head *head; - struct backbone_gw *backbone_gw; - struct hashtable_t *hash; - struct hard_iface *primary_if; + struct batadv_backbone_gw *backbone_gw; + struct batadv_hashtable *hash; + struct batadv_hard_iface *primary_if; int i; + bat_priv = container_of(delayed_work, struct batadv_priv, bla_work); primary_if = batadv_primary_if_get_selected(bat_priv); if (!primary_if) goto out; @@ -1140,13 +1146,13 @@ static struct lock_class_key batadv_claim_hash_lock_class_key; static struct lock_class_key batadv_backbone_hash_lock_class_key; /* initialize all bla structures */ -int batadv_bla_init(struct bat_priv *bat_priv) +int batadv_bla_init(struct batadv_priv *bat_priv) { int i; uint8_t claim_dest[ETH_ALEN] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00}; - struct hard_iface *primary_if; + struct batadv_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 +1187,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; @@ -1200,14 +1206,14 @@ int batadv_bla_init(struct bat_priv *bat_priv) * sent by another host, drop it. We allow equal packets from * the same host however as this might be intended. */ -int batadv_bla_check_bcast_duplist(struct bat_priv *bat_priv, - struct bcast_packet *bcast_packet, +int batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv, + struct batadv_bcast_packet *bcast_packet, int hdr_size) { int i, length, curr; uint8_t *content; uint16_t crc; - struct bcast_duplist_entry *entry; + struct batadv_bcast_duplist_entry *entry; length = hdr_size - sizeof(*bcast_packet); content = (uint8_t *)bcast_packet; @@ -1260,12 +1266,12 @@ int batadv_bla_check_bcast_duplist(struct bat_priv *bat_priv, * * returns 1 if it is found, 0 otherwise */ -int batadv_bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig) +int batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, uint8_t *orig) { - struct hashtable_t *hash = bat_priv->backbone_hash; + struct batadv_hashtable *hash = bat_priv->backbone_hash; struct hlist_head *head; struct hlist_node *node; - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; int i; if (!atomic_read(&bat_priv->bridge_loop_avoidance)) @@ -1300,11 +1306,11 @@ int batadv_bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig) * returns 0. */ int batadv_bla_is_backbone_gw(struct sk_buff *skb, - struct orig_node *orig_node, int hdr_size) + struct batadv_orig_node *orig_node, int hdr_size) { struct ethhdr *ethhdr; struct vlan_ethhdr *vhdr; - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; short vid = -1; if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance)) @@ -1336,9 +1342,9 @@ int batadv_bla_is_backbone_gw(struct sk_buff *skb, } /* free all bla structures (for softinterface free or module unload) */ -void batadv_bla_free(struct bat_priv *bat_priv) +void batadv_bla_free(struct batadv_priv *bat_priv) { - struct hard_iface *primary_if; + struct batadv_hard_iface *primary_if; cancel_delayed_work_sync(&bat_priv->bla_work); primary_if = batadv_primary_if_get_selected(bat_priv); @@ -1369,11 +1375,11 @@ void batadv_bla_free(struct bat_priv *bat_priv) * returns 1, otherwise it returns 0 and the caller shall further * process the skb. */ -int batadv_bla_rx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid) +int batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb, short vid) { struct ethhdr *ethhdr; - struct claim search_claim, *claim = NULL; - struct hard_iface *primary_if; + struct batadv_claim search_claim, *claim = NULL; + struct batadv_hard_iface *primary_if; int ret; ethhdr = (struct ethhdr *)skb_mac_header(skb); @@ -1456,11 +1462,11 @@ out: * returns 1, otherwise it returns 0 and the caller shall further * process the skb. */ -int batadv_bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid) +int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb, short vid) { struct ethhdr *ethhdr; - struct claim search_claim, *claim = NULL; - struct hard_iface *primary_if; + struct batadv_claim search_claim, *claim = NULL; + struct batadv_hard_iface *primary_if; int ret = 0; primary_if = batadv_primary_if_get_selected(bat_priv); @@ -1533,10 +1539,10 @@ out: int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset) { struct net_device *net_dev = (struct net_device *)seq->private; - struct bat_priv *bat_priv = netdev_priv(net_dev); - struct hashtable_t *hash = bat_priv->claim_hash; - struct claim *claim; - struct hard_iface *primary_if; + struct batadv_priv *bat_priv = netdev_priv(net_dev); + struct batadv_hashtable *hash = bat_priv->claim_hash; + struct batadv_claim *claim; + struct batadv_hard_iface *primary_if; struct hlist_node *node; struct hlist_head *head; uint32_t i; @@ -1552,7 +1558,7 @@ int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset) goto out; } - if (primary_if->if_status != IF_ACTIVE) { + if (primary_if->if_status != BATADV_IF_ACTIVE) { ret = seq_printf(seq, "BATMAN mesh %s disabled - primary interface not active\n", net_dev->name); diff --git a/net/batman-adv/bridge_loop_avoidance.h b/net/batman-adv/bridge_loop_avoidance.h index 58563f0cf61d..08d13cb1e3df 100644 --- a/net/batman-adv/bridge_loop_avoidance.h +++ b/net/batman-adv/bridge_loop_avoidance.h @@ -21,38 +21,38 @@ #define _NET_BATMAN_ADV_BLA_H_ #ifdef CONFIG_BATMAN_ADV_BLA -int batadv_bla_rx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid); -int batadv_bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid); +int batadv_bla_rx(struct batadv_priv *bat_priv, struct sk_buff *skb, short vid); +int batadv_bla_tx(struct batadv_priv *bat_priv, struct sk_buff *skb, short vid); int batadv_bla_is_backbone_gw(struct sk_buff *skb, - struct orig_node *orig_node, int hdr_size); + struct batadv_orig_node *orig_node, int hdr_size); int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, void *offset); -int batadv_bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig); -int batadv_bla_check_bcast_duplist(struct bat_priv *bat_priv, - struct bcast_packet *bcast_packet, +int batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, uint8_t *orig); +int batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv, + struct batadv_bcast_packet *bcast_packet, int hdr_size); -void batadv_bla_update_orig_address(struct bat_priv *bat_priv, - struct hard_iface *primary_if, - struct hard_iface *oldif); -int batadv_bla_init(struct bat_priv *bat_priv); -void batadv_bla_free(struct bat_priv *bat_priv); +void batadv_bla_update_orig_address(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, + struct batadv_hard_iface *oldif); +int batadv_bla_init(struct batadv_priv *bat_priv); +void batadv_bla_free(struct batadv_priv *bat_priv); #define BATADV_BLA_CRC_INIT 0 #else /* ifdef CONFIG_BATMAN_ADV_BLA */ -static inline int batadv_bla_rx(struct bat_priv *bat_priv, struct sk_buff *skb, - short vid) +static inline int batadv_bla_rx(struct batadv_priv *bat_priv, + struct sk_buff *skb, short vid) { return 0; } -static inline int batadv_bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, - short vid) +static inline int batadv_bla_tx(struct batadv_priv *bat_priv, + struct sk_buff *skb, short vid) { return 0; } static inline int batadv_bla_is_backbone_gw(struct sk_buff *skb, - struct orig_node *orig_node, + struct batadv_orig_node *orig_node, int hdr_size) { return 0; @@ -64,33 +64,33 @@ static inline int batadv_bla_claim_table_seq_print_text(struct seq_file *seq, return 0; } -static inline int batadv_bla_is_backbone_gw_orig(struct bat_priv *bat_priv, +static inline int batadv_bla_is_backbone_gw_orig(struct batadv_priv *bat_priv, uint8_t *orig) { return 0; } static inline int -batadv_bla_check_bcast_duplist(struct bat_priv *bat_priv, - struct bcast_packet *bcast_packet, +batadv_bla_check_bcast_duplist(struct batadv_priv *bat_priv, + struct batadv_bcast_packet *bcast_packet, int hdr_size) { return 0; } static inline void -batadv_bla_update_orig_address(struct bat_priv *bat_priv, - struct hard_iface *primary_if, - struct hard_iface *oldif) +batadv_bla_update_orig_address(struct batadv_priv *bat_priv, + struct batadv_hard_iface *primary_if, + struct batadv_hard_iface *oldif) { } -static inline int batadv_bla_init(struct bat_priv *bat_priv) +static inline int batadv_bla_init(struct batadv_priv *bat_priv) { return 1; } -static inline void batadv_bla_free(struct bat_priv *bat_priv) +static inline void batadv_bla_free(struct batadv_priv *bat_priv) { } diff --git a/net/batman-adv/bat_debugfs.c b/net/batman-adv/debugfs.c index 4dcda43d6822..34fbb1667bcd 100644 --- a/net/batman-adv/bat_debugfs.c +++ b/net/batman-adv/debugfs.c @@ -21,7 +21,7 @@ #include <linux/debugfs.h> -#include "bat_debugfs.h" +#include "debugfs.h" #include "translation-table.h" #include "originator.h" #include "hard-interface.h" @@ -36,13 +36,21 @@ static struct dentry *batadv_debugfs; #ifdef CONFIG_BATMAN_ADV_DEBUG #define BATADV_LOG_BUFF_MASK (batadv_log_buff_len - 1) -#define BATADV_LOG_BUFF(idx) (debug_log->log_buff[(idx) & BATADV_LOG_BUFF_MASK]) -static int batadv_log_buff_len = BATADV_LOG_BUF_LEN; +static const int batadv_log_buff_len = BATADV_LOG_BUF_LEN; -static void batadv_emit_log_char(struct debug_log *debug_log, char c) +static char *batadv_log_char_addr(struct batadv_debug_log *debug_log, + size_t idx) { - BATADV_LOG_BUFF(debug_log->log_end) = c; + return &debug_log->log_buff[idx & BATADV_LOG_BUFF_MASK]; +} + +static void batadv_emit_log_char(struct batadv_debug_log *debug_log, char c) +{ + char *char_addr; + + char_addr = batadv_log_char_addr(debug_log, debug_log->log_end); + *char_addr = c; debug_log->log_end++; if (debug_log->log_end - debug_log->log_start > batadv_log_buff_len) @@ -50,7 +58,8 @@ static void batadv_emit_log_char(struct debug_log *debug_log, char c) } __printf(2, 3) -static int batadv_fdebug_log(struct debug_log *debug_log, const char *fmt, ...) +static int batadv_fdebug_log(struct batadv_debug_log *debug_log, + const char *fmt, ...) { va_list args; static char debug_log_buf[256]; @@ -74,7 +83,7 @@ static int batadv_fdebug_log(struct debug_log *debug_log, const char *fmt, ...) return 0; } -int batadv_debug_log(struct bat_priv *bat_priv, const char *fmt, ...) +int batadv_debug_log(struct batadv_priv *bat_priv, const char *fmt, ...) { va_list args; char tmp_log_buf[256]; @@ -102,16 +111,21 @@ static int batadv_log_release(struct inode *inode, struct file *file) return 0; } +static int batadv_log_empty(struct batadv_debug_log *debug_log) +{ + return !(debug_log->log_start - debug_log->log_end); +} + static ssize_t batadv_log_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { - struct bat_priv *bat_priv = file->private_data; - struct debug_log *debug_log = bat_priv->debug_log; + struct batadv_priv *bat_priv = file->private_data; + struct batadv_debug_log *debug_log = bat_priv->debug_log; int error, i = 0; + char *char_addr; char c; - if ((file->f_flags & O_NONBLOCK) && - !(debug_log->log_end - debug_log->log_start)) + if ((file->f_flags & O_NONBLOCK) && batadv_log_empty(debug_log)) return -EAGAIN; if (!buf) @@ -124,7 +138,7 @@ static ssize_t batadv_log_read(struct file *file, char __user *buf, return -EFAULT; error = wait_event_interruptible(debug_log->queue_wait, - (debug_log->log_start - debug_log->log_end)); + (!batadv_log_empty(debug_log))); if (error) return error; @@ -133,7 +147,9 @@ static ssize_t batadv_log_read(struct file *file, char __user *buf, while ((!error) && (i < count) && (debug_log->log_start != debug_log->log_end)) { - c = BATADV_LOG_BUFF(debug_log->log_start); + char_addr = batadv_log_char_addr(debug_log, + debug_log->log_start); + c = *char_addr; debug_log->log_start++; @@ -158,12 +174,12 @@ static ssize_t batadv_log_read(struct file *file, char __user *buf, static unsigned int batadv_log_poll(struct file *file, poll_table *wait) { - struct bat_priv *bat_priv = file->private_data; - struct debug_log *debug_log = bat_priv->debug_log; + struct batadv_priv *bat_priv = file->private_data; + struct batadv_debug_log *debug_log = bat_priv->debug_log; poll_wait(file, &debug_log->queue_wait, wait); - if (debug_log->log_end - debug_log->log_start) + if (!batadv_log_empty(debug_log)) return POLLIN | POLLRDNORM; return 0; @@ -177,7 +193,7 @@ static const struct file_operations batadv_log_fops = { .llseek = no_llseek, }; -static int batadv_debug_log_setup(struct bat_priv *bat_priv) +static int batadv_debug_log_setup(struct batadv_priv *bat_priv) { struct dentry *d; @@ -203,19 +219,19 @@ err: return -ENOMEM; } -static void batadv_debug_log_cleanup(struct bat_priv *bat_priv) +static void batadv_debug_log_cleanup(struct batadv_priv *bat_priv) { kfree(bat_priv->debug_log); bat_priv->debug_log = NULL; } #else /* CONFIG_BATMAN_ADV_DEBUG */ -static int batadv_debug_log_setup(struct bat_priv *bat_priv) +static int batadv_debug_log_setup(struct batadv_priv *bat_priv) { bat_priv->debug_log = NULL; return 0; } -static void batadv_debug_log_cleanup(struct bat_priv *bat_priv) +static void batadv_debug_log_cleanup(struct batadv_priv *bat_priv) { return; } @@ -265,13 +281,13 @@ static int batadv_vis_data_open(struct inode *inode, struct file *file) return single_open(file, batadv_vis_seq_print_text, net_dev); } -struct bat_debuginfo { +struct batadv_debuginfo { struct attribute attr; const struct file_operations fops; }; #define BATADV_DEBUGINFO(_name, _mode, _open) \ -struct bat_debuginfo batadv_debuginfo_##_name = { \ +struct batadv_debuginfo batadv_debuginfo_##_name = { \ .attr = { .name = __stringify(_name), \ .mode = _mode, }, \ .fops = { .owner = THIS_MODULE, \ @@ -294,7 +310,7 @@ static BATADV_DEBUGINFO(transtable_local, S_IRUGO, batadv_transtable_local_open); static BATADV_DEBUGINFO(vis_data, S_IRUGO, batadv_vis_data_open); -static struct bat_debuginfo *batadv_mesh_debuginfos[] = { +static struct batadv_debuginfo *batadv_mesh_debuginfos[] = { &batadv_debuginfo_originators, &batadv_debuginfo_gateways, &batadv_debuginfo_transtable_global, @@ -308,7 +324,7 @@ static struct bat_debuginfo *batadv_mesh_debuginfos[] = { void batadv_debugfs_init(void) { - struct bat_debuginfo *bat_debug; + struct batadv_debuginfo *bat_debug; struct dentry *file; batadv_debugfs = debugfs_create_dir(BATADV_DEBUGFS_SUBDIR, NULL); @@ -339,8 +355,8 @@ void batadv_debugfs_destroy(void) int batadv_debugfs_add_meshif(struct net_device *dev) { - struct bat_priv *bat_priv = netdev_priv(dev); - struct bat_debuginfo **bat_debug; + struct batadv_priv *bat_priv = netdev_priv(dev); + struct batadv_debuginfo **bat_debug; struct dentry *file; if (!batadv_debugfs) @@ -358,9 +374,9 @@ int batadv_debugfs_add_meshif(struct net_device *dev) for (bat_debug = batadv_mesh_debuginfos; *bat_debug; ++bat_debug) { file = debugfs_create_file(((*bat_debug)->attr).name, - S_IFREG | ((*bat_debug)->attr).mode, - bat_priv->debug_dir, - dev, &(*bat_debug)->fops); + S_IFREG | ((*bat_debug)->attr).mode, + bat_priv->debug_dir, + dev, &(*bat_debug)->fops); if (!file) { batadv_err(dev, "Can't add debugfs file: %s/%s\n", dev->name, ((*bat_debug)->attr).name); @@ -382,7 +398,7 @@ out: void batadv_debugfs_del_meshif(struct net_device *dev) { - struct bat_priv *bat_priv = netdev_priv(dev); + struct batadv_priv *bat_priv = netdev_priv(dev); batadv_debug_log_cleanup(bat_priv); diff --git a/net/batman-adv/bat_debugfs.h b/net/batman-adv/debugfs.h index 3319e1f21f55..3319e1f21f55 100644 --- a/net/batman-adv/bat_debugfs.h +++ b/net/batman-adv/debugfs.h diff --git a/net/batman-adv/gateway_client.c b/net/batman-adv/gateway_client.c index 5fc162c8425a..b421cc49d2cd 100644 --- a/net/batman-adv/gateway_client.c +++ b/net/batman-adv/gateway_client.c @@ -18,7 +18,7 @@ */ #include "main.h" -#include "bat_sysfs.h" +#include "sysfs.h" #include "gateway_client.h" #include "gateway_common.h" #include "hard-interface.h" @@ -36,15 +36,16 @@ #define BATADV_DHCP_OPTIONS_OFFSET 240 #define BATADV_DHCP_REQUEST 3 -static void batadv_gw_node_free_ref(struct gw_node *gw_node) +static void batadv_gw_node_free_ref(struct batadv_gw_node *gw_node) { if (atomic_dec_and_test(&gw_node->refcount)) kfree_rcu(gw_node, rcu); } -static struct gw_node *batadv_gw_get_selected_gw_node(struct bat_priv *bat_priv) +static struct batadv_gw_node * +batadv_gw_get_selected_gw_node(struct batadv_priv *bat_priv) { - struct gw_node *gw_node; + struct batadv_gw_node *gw_node; rcu_read_lock(); gw_node = rcu_dereference(bat_priv->curr_gw); @@ -59,10 +60,11 @@ out: return gw_node; } -struct orig_node *batadv_gw_get_selected_orig(struct bat_priv *bat_priv) +struct batadv_orig_node * +batadv_gw_get_selected_orig(struct batadv_priv *bat_priv) { - struct gw_node *gw_node; - struct orig_node *orig_node = NULL; + struct batadv_gw_node *gw_node; + struct batadv_orig_node *orig_node = NULL; gw_node = batadv_gw_get_selected_gw_node(bat_priv); if (!gw_node) @@ -84,10 +86,10 @@ out: return orig_node; } -static void batadv_gw_select(struct bat_priv *bat_priv, - struct gw_node *new_gw_node) +static void batadv_gw_select(struct batadv_priv *bat_priv, + struct batadv_gw_node *new_gw_node) { - struct gw_node *curr_gw_node; + struct batadv_gw_node *curr_gw_node; spin_lock_bh(&bat_priv->gw_list_lock); @@ -103,20 +105,21 @@ static void batadv_gw_select(struct bat_priv *bat_priv, spin_unlock_bh(&bat_priv->gw_list_lock); } -void batadv_gw_deselect(struct bat_priv *bat_priv) +void batadv_gw_deselect(struct batadv_priv *bat_priv) { atomic_set(&bat_priv->gw_reselect, 1); } -static struct gw_node *batadv_gw_get_best_gw_node(struct bat_priv *bat_priv) +static struct batadv_gw_node * +batadv_gw_get_best_gw_node(struct batadv_priv *bat_priv) { - struct neigh_node *router; + struct batadv_neigh_node *router; struct hlist_node *node; - struct gw_node *gw_node, *curr_gw = NULL; + struct batadv_gw_node *gw_node, *curr_gw = NULL; uint32_t max_gw_factor = 0, tmp_gw_factor = 0; uint8_t max_tq = 0; int down, up; - struct orig_node *orig_node; + struct batadv_orig_node *orig_node; rcu_read_lock(); hlist_for_each_entry_rcu(gw_node, node, &bat_priv->gw_list, list) { @@ -183,10 +186,10 @@ next: return curr_gw; } -void batadv_gw_election(struct bat_priv *bat_priv) +void batadv_gw_election(struct batadv_priv *bat_priv) { - struct gw_node *curr_gw = NULL, *next_gw = NULL; - struct neigh_node *router = NULL; + struct batadv_gw_node *curr_gw = NULL, *next_gw = NULL; + struct batadv_neigh_node *router = NULL; char gw_addr[18] = { '\0' }; /* The batman daemon checks here if we already passed a full originator @@ -194,7 +197,7 @@ void batadv_gw_election(struct bat_priv *bat_priv) * hear about. This check is based on the daemon's uptime which we * don't have. */ - if (atomic_read(&bat_priv->gw_mode) != GW_MODE_CLIENT) + if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_CLIENT) goto out; if (!batadv_atomic_dec_not_zero(&bat_priv->gw_reselect)) @@ -218,21 +221,24 @@ void batadv_gw_election(struct bat_priv *bat_priv) } if ((curr_gw) && (!next_gw)) { - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Removing selected gateway - no gateway in range\n"); - batadv_throw_uevent(bat_priv, UEV_GW, UEV_DEL, NULL); + batadv_throw_uevent(bat_priv, BATADV_UEV_GW, BATADV_UEV_DEL, + NULL); } else if ((!curr_gw) && (next_gw)) { - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Adding route to gateway %pM (gw_flags: %i, tq: %i)\n", next_gw->orig_node->orig, 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, BATADV_UEV_GW, BATADV_UEV_ADD, + gw_addr); } else { - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Changing route to gateway %pM (gw_flags: %i, tq: %i)\n", next_gw->orig_node->orig, 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, BATADV_UEV_GW, BATADV_UEV_CHANGE, + gw_addr); } batadv_gw_select(bat_priv, next_gw); @@ -246,11 +252,11 @@ out: batadv_neigh_node_free_ref(router); } -void batadv_gw_check_election(struct bat_priv *bat_priv, - struct orig_node *orig_node) +void batadv_gw_check_election(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node) { - struct orig_node *curr_gw_orig; - struct neigh_node *router_gw = NULL, *router_orig = NULL; + struct batadv_orig_node *curr_gw_orig; + struct batadv_neigh_node *router_gw = NULL, *router_orig = NULL; uint8_t gw_tq_avg, orig_tq_avg; curr_gw_orig = batadv_gw_get_selected_orig(bat_priv); @@ -283,7 +289,7 @@ void batadv_gw_check_election(struct bat_priv *bat_priv, (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw_sel_class))) goto out; - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n", gw_tq_avg, orig_tq_avg); @@ -300,11 +306,11 @@ out: return; } -static void batadv_gw_node_add(struct bat_priv *bat_priv, - struct orig_node *orig_node, +static void batadv_gw_node_add(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, uint8_t new_gwflags) { - struct gw_node *gw_node; + struct batadv_gw_node *gw_node; int down, up; gw_node = kzalloc(sizeof(*gw_node), GFP_ATOMIC); @@ -320,7 +326,7 @@ static void batadv_gw_node_add(struct bat_priv *bat_priv, spin_unlock_bh(&bat_priv->gw_list_lock); batadv_gw_bandwidth_to_kbit(new_gwflags, &down, &up); - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Found new gateway %pM -> gw_class: %i - %i%s/%i%s\n", orig_node->orig, new_gwflags, (down > 2048 ? down / 1024 : down), @@ -329,11 +335,12 @@ static void batadv_gw_node_add(struct bat_priv *bat_priv, (up > 2048 ? "MBit" : "KBit")); } -void batadv_gw_node_update(struct bat_priv *bat_priv, - struct orig_node *orig_node, uint8_t new_gwflags) +void batadv_gw_node_update(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + uint8_t new_gwflags) { struct hlist_node *node; - struct gw_node *gw_node, *curr_gw; + struct batadv_gw_node *gw_node, *curr_gw; /* Note: We don't need a NULL check here, since curr_gw never gets * dereferenced. If curr_gw is NULL we also should not exit as we may @@ -347,7 +354,7 @@ void batadv_gw_node_update(struct bat_priv *bat_priv, if (gw_node->orig_node != orig_node) continue; - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Gateway class of originator %pM changed from %i to %i\n", orig_node->orig, gw_node->orig_node->gw_flags, new_gwflags); @@ -356,7 +363,7 @@ void batadv_gw_node_update(struct bat_priv *bat_priv, if (new_gwflags == BATADV_NO_FLAGS) { gw_node->deleted = jiffies; - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Gateway %pM removed from gateway list\n", orig_node->orig); @@ -382,15 +389,15 @@ unlock: batadv_gw_node_free_ref(curr_gw); } -void batadv_gw_node_delete(struct bat_priv *bat_priv, - struct orig_node *orig_node) +void batadv_gw_node_delete(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node) { batadv_gw_node_update(bat_priv, orig_node, 0); } -void batadv_gw_node_purge(struct bat_priv *bat_priv) +void batadv_gw_node_purge(struct batadv_priv *bat_priv) { - struct gw_node *gw_node, *curr_gw; + struct batadv_gw_node *gw_node, *curr_gw; struct hlist_node *node, *node_tmp; unsigned long timeout = msecs_to_jiffies(2 * BATADV_PURGE_TIMEOUT); int do_deselect = 0; @@ -403,7 +410,7 @@ void batadv_gw_node_purge(struct bat_priv *bat_priv) &bat_priv->gw_list, list) { if (((!gw_node->deleted) || (time_before(jiffies, gw_node->deleted + timeout))) && - atomic_read(&bat_priv->mesh_state) == MESH_ACTIVE) + atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) continue; if (curr_gw == gw_node) @@ -424,12 +431,12 @@ void batadv_gw_node_purge(struct bat_priv *bat_priv) } /* fails if orig_node has no router */ -static int batadv_write_buffer_text(struct bat_priv *bat_priv, - struct seq_file *seq, - const struct gw_node *gw_node) +static int batadv_write_buffer_text(struct batadv_priv *bat_priv, + struct seq_file *seq, + const struct batadv_gw_node *gw_node) { - struct gw_node *curr_gw; - struct neigh_node *router; + struct batadv_gw_node *curr_gw; + struct batadv_neigh_node *router; int down, up, ret = -1; batadv_gw_bandwidth_to_kbit(gw_node->orig_node->gw_flags, &down, &up); @@ -461,9 +468,9 @@ out: int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset) { struct net_device *net_dev = (struct net_device *)seq->private; - struct bat_priv *bat_priv = netdev_priv(net_dev); - struct hard_iface *primary_if; - struct gw_node *gw_node; + struct batadv_priv *bat_priv = netdev_priv(net_dev); + struct batadv_hard_iface *primary_if; + struct batadv_gw_node *gw_node; struct hlist_node *node; int gw_count = 0, ret = 0; @@ -475,7 +482,7 @@ int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset) goto out; } - if (primary_if->if_status != IF_ACTIVE) { + if (primary_if->if_status != BATADV_IF_ACTIVE) { ret = seq_printf(seq, "BATMAN mesh %s disabled - primary interface not active\n", net_dev->name); @@ -636,12 +643,12 @@ bool batadv_gw_is_dhcp_target(struct sk_buff *skb, unsigned int *header_len) return true; } -bool batadv_gw_out_of_range(struct bat_priv *bat_priv, +bool batadv_gw_out_of_range(struct batadv_priv *bat_priv, struct sk_buff *skb, struct ethhdr *ethhdr) { - struct neigh_node *neigh_curr = NULL, *neigh_old = NULL; - struct orig_node *orig_dst_node = NULL; - struct gw_node *curr_gw = NULL; + struct batadv_neigh_node *neigh_curr = NULL, *neigh_old = NULL; + struct batadv_orig_node *orig_dst_node = NULL; + struct batadv_gw_node *curr_gw = NULL; bool ret, out_of_range = false; unsigned int header_len = 0; uint8_t curr_tq_avg; @@ -663,13 +670,13 @@ bool batadv_gw_out_of_range(struct bat_priv *bat_priv, goto out; switch (atomic_read(&bat_priv->gw_mode)) { - case GW_MODE_SERVER: + case BATADV_GW_MODE_SERVER: /* If we are a GW then we are our best GW. We can artificially * set the tq towards ourself as the maximum value */ curr_tq_avg = BATADV_TQ_MAX_VALUE; break; - case GW_MODE_CLIENT: + case BATADV_GW_MODE_CLIENT: curr_gw = batadv_gw_get_selected_gw_node(bat_priv); if (!curr_gw) goto out; @@ -689,7 +696,7 @@ bool batadv_gw_out_of_range(struct bat_priv *bat_priv, curr_tq_avg = neigh_curr->tq_avg; break; - case GW_MODE_OFF: + case BATADV_GW_MODE_OFF: default: goto out; } diff --git a/net/batman-adv/gateway_client.h b/net/batman-adv/gateway_client.h index 4529d42894ef..f0d129e323c8 100644 --- a/net/batman-adv/gateway_client.h +++ b/net/batman-adv/gateway_client.h @@ -20,19 +20,21 @@ #ifndef _NET_BATMAN_ADV_GATEWAY_CLIENT_H_ #define _NET_BATMAN_ADV_GATEWAY_CLIENT_H_ -void batadv_gw_deselect(struct bat_priv *bat_priv); -void batadv_gw_election(struct bat_priv *bat_priv); -struct orig_node *batadv_gw_get_selected_orig(struct bat_priv *bat_priv); -void batadv_gw_check_election(struct bat_priv *bat_priv, - struct orig_node *orig_node); -void batadv_gw_node_update(struct bat_priv *bat_priv, - struct orig_node *orig_node, uint8_t new_gwflags); -void batadv_gw_node_delete(struct bat_priv *bat_priv, - struct orig_node *orig_node); -void batadv_gw_node_purge(struct bat_priv *bat_priv); +void batadv_gw_deselect(struct batadv_priv *bat_priv); +void batadv_gw_election(struct batadv_priv *bat_priv); +struct batadv_orig_node * +batadv_gw_get_selected_orig(struct batadv_priv *bat_priv); +void batadv_gw_check_election(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node); +void batadv_gw_node_update(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + uint8_t new_gwflags); +void batadv_gw_node_delete(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node); +void batadv_gw_node_purge(struct batadv_priv *bat_priv); int batadv_gw_client_seq_print_text(struct seq_file *seq, void *offset); bool batadv_gw_is_dhcp_target(struct sk_buff *skb, unsigned int *header_len); -bool batadv_gw_out_of_range(struct bat_priv *bat_priv, +bool batadv_gw_out_of_range(struct batadv_priv *bat_priv, struct sk_buff *skb, struct ethhdr *ethhdr); #endif /* _NET_BATMAN_ADV_GATEWAY_CLIENT_H_ */ diff --git a/net/batman-adv/gateway_common.c b/net/batman-adv/gateway_common.c index f5c3980aaea6..9001208d1752 100644 --- a/net/batman-adv/gateway_common.c +++ b/net/batman-adv/gateway_common.c @@ -137,7 +137,7 @@ static bool batadv_parse_gw_bandwidth(struct net_device *net_dev, char *buff, ssize_t batadv_gw_bandwidth_set(struct net_device *net_dev, char *buff, size_t count) { - struct bat_priv *bat_priv = netdev_priv(net_dev); + struct batadv_priv *bat_priv = netdev_priv(net_dev); long gw_bandwidth_tmp = 0; int up = 0, down = 0; bool ret; diff --git a/net/batman-adv/gateway_common.h b/net/batman-adv/gateway_common.h index 31bbc3c070a6..13697f6e7113 100644 --- a/net/batman-adv/gateway_common.h +++ b/net/batman-adv/gateway_common.h @@ -20,10 +20,10 @@ #ifndef _NET_BATMAN_ADV_GATEWAY_COMMON_H_ #define _NET_BATMAN_ADV_GATEWAY_COMMON_H_ -enum gw_modes { - GW_MODE_OFF, - GW_MODE_CLIENT, - GW_MODE_SERVER, +enum batadv_gw_modes { + BATADV_GW_MODE_OFF, + BATADV_GW_MODE_CLIENT, + BATADV_GW_MODE_SERVER, }; #define BATADV_GW_MODE_OFF_NAME "off" diff --git a/net/batman-adv/hard-interface.c b/net/batman-adv/hard-interface.c index e7eba9c32e70..282bf6e9353e 100644 --- a/net/batman-adv/hard-interface.c +++ b/net/batman-adv/hard-interface.c @@ -23,7 +23,7 @@ #include "send.h" #include "translation-table.h" #include "routing.h" -#include "bat_sysfs.h" +#include "sysfs.h" #include "originator.h" #include "hash.h" #include "bridge_loop_avoidance.h" @@ -32,16 +32,17 @@ void batadv_hardif_free_rcu(struct rcu_head *rcu) { - struct hard_iface *hard_iface; + struct batadv_hard_iface *hard_iface; - hard_iface = container_of(rcu, struct hard_iface, rcu); + hard_iface = container_of(rcu, struct batadv_hard_iface, rcu); dev_put(hard_iface->net_dev); kfree(hard_iface); } -struct hard_iface *batadv_hardif_get_by_netdev(const struct net_device *net_dev) +struct batadv_hard_iface * +batadv_hardif_get_by_netdev(const struct net_device *net_dev) { - struct hard_iface *hard_iface; + struct batadv_hard_iface *hard_iface; rcu_read_lock(); list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { @@ -75,17 +76,17 @@ static int batadv_is_valid_iface(const struct net_device *net_dev) return 1; } -static struct hard_iface * +static struct batadv_hard_iface * batadv_hardif_get_active(const struct net_device *soft_iface) { - struct hard_iface *hard_iface; + struct batadv_hard_iface *hard_iface; rcu_read_lock(); list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { if (hard_iface->soft_iface != soft_iface) continue; - if (hard_iface->if_status == IF_ACTIVE && + if (hard_iface->if_status == BATADV_IF_ACTIVE && atomic_inc_not_zero(&hard_iface->refcount)) goto out; } @@ -97,17 +98,17 @@ out: return hard_iface; } -static void batadv_primary_if_update_addr(struct bat_priv *bat_priv, - struct hard_iface *oldif) +static void batadv_primary_if_update_addr(struct batadv_priv *bat_priv, + struct batadv_hard_iface *oldif) { - struct vis_packet *vis_packet; - struct hard_iface *primary_if; + struct batadv_vis_packet *vis_packet; + struct batadv_hard_iface *primary_if; primary_if = batadv_primary_if_get_selected(bat_priv); if (!primary_if) goto out; - vis_packet = (struct vis_packet *) + vis_packet = (struct batadv_vis_packet *) bat_priv->my_vis_info->skb_packet->data; memcpy(vis_packet->vis_orig, primary_if->net_dev->dev_addr, ETH_ALEN); memcpy(vis_packet->sender_orig, @@ -119,10 +120,10 @@ out: batadv_hardif_free_ref(primary_if); } -static void batadv_primary_if_select(struct bat_priv *bat_priv, - struct hard_iface *new_hard_iface) +static void batadv_primary_if_select(struct batadv_priv *bat_priv, + struct batadv_hard_iface *new_hard_iface) { - struct hard_iface *curr_hard_iface; + struct batadv_hard_iface *curr_hard_iface; ASSERT_RTNL(); @@ -143,7 +144,8 @@ out: batadv_hardif_free_ref(curr_hard_iface); } -static bool batadv_hardif_is_iface_up(const struct hard_iface *hard_iface) +static bool +batadv_hardif_is_iface_up(const struct batadv_hard_iface *hard_iface) { if (hard_iface->net_dev->flags & IFF_UP) return true; @@ -153,12 +155,12 @@ static bool batadv_hardif_is_iface_up(const struct hard_iface *hard_iface) static void batadv_check_known_mac_addr(const struct net_device *net_dev) { - const struct hard_iface *hard_iface; + const struct batadv_hard_iface *hard_iface; rcu_read_lock(); list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { - if ((hard_iface->if_status != IF_ACTIVE) && - (hard_iface->if_status != IF_TO_BE_ACTIVATED)) + if ((hard_iface->if_status != BATADV_IF_ACTIVE) && + (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) continue; if (hard_iface->net_dev == net_dev) @@ -177,8 +179,8 @@ static void batadv_check_known_mac_addr(const struct net_device *net_dev) int batadv_hardif_min_mtu(struct net_device *soft_iface) { - const struct bat_priv *bat_priv = netdev_priv(soft_iface); - const struct hard_iface *hard_iface; + const struct batadv_priv *bat_priv = netdev_priv(soft_iface); + const struct batadv_hard_iface *hard_iface; /* allow big frames if all devices are capable to do so * (have MTU > 1500 + BAT_HEADER_LEN) */ @@ -189,8 +191,8 @@ int batadv_hardif_min_mtu(struct net_device *soft_iface) rcu_read_lock(); list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { - if ((hard_iface->if_status != IF_ACTIVE) && - (hard_iface->if_status != IF_TO_BE_ACTIVATED)) + if ((hard_iface->if_status != BATADV_IF_ACTIVE) && + (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) continue; if (hard_iface->soft_iface != soft_iface) @@ -215,18 +217,19 @@ void batadv_update_min_mtu(struct net_device *soft_iface) soft_iface->mtu = min_mtu; } -static void batadv_hardif_activate_interface(struct hard_iface *hard_iface) +static void +batadv_hardif_activate_interface(struct batadv_hard_iface *hard_iface) { - struct bat_priv *bat_priv; - struct hard_iface *primary_if = NULL; + struct batadv_priv *bat_priv; + struct batadv_hard_iface *primary_if = NULL; - if (hard_iface->if_status != IF_INACTIVE) + if (hard_iface->if_status != BATADV_IF_INACTIVE) goto out; bat_priv = netdev_priv(hard_iface->soft_iface); bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface); - hard_iface->if_status = IF_TO_BE_ACTIVATED; + hard_iface->if_status = BATADV_IF_TO_BE_ACTIVATED; /* the first active interface becomes our primary interface or * the next active interface after the old primary interface was removed @@ -245,13 +248,14 @@ out: batadv_hardif_free_ref(primary_if); } -static void batadv_hardif_deactivate_interface(struct hard_iface *hard_iface) +static void +batadv_hardif_deactivate_interface(struct batadv_hard_iface *hard_iface) { - if ((hard_iface->if_status != IF_ACTIVE) && - (hard_iface->if_status != IF_TO_BE_ACTIVATED)) + if ((hard_iface->if_status != BATADV_IF_ACTIVE) && + (hard_iface->if_status != BATADV_IF_TO_BE_ACTIVATED)) return; - hard_iface->if_status = IF_INACTIVE; + hard_iface->if_status = BATADV_IF_INACTIVE; batadv_info(hard_iface->soft_iface, "Interface deactivated: %s\n", hard_iface->net_dev->name); @@ -259,15 +263,15 @@ static void batadv_hardif_deactivate_interface(struct hard_iface *hard_iface) batadv_update_min_mtu(hard_iface->soft_iface); } -int batadv_hardif_enable_interface(struct hard_iface *hard_iface, +int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, const char *iface_name) { - struct bat_priv *bat_priv; + struct batadv_priv *bat_priv; struct net_device *soft_iface; __be16 ethertype = __constant_htons(BATADV_ETH_P_BATMAN); int ret; - if (hard_iface->if_status != IF_NOT_IN_USE) + if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) goto out; if (!atomic_inc_not_zero(&hard_iface->refcount)) @@ -308,7 +312,7 @@ int batadv_hardif_enable_interface(struct hard_iface *hard_iface, hard_iface->if_num = bat_priv->num_ifaces; bat_priv->num_ifaces++; - hard_iface->if_status = IF_INACTIVE; + hard_iface->if_status = BATADV_IF_INACTIVE; batadv_orig_hash_add_if(hard_iface, bat_priv->num_ifaces); hard_iface->batman_adv_ptype.type = ethertype; @@ -320,15 +324,15 @@ int batadv_hardif_enable_interface(struct hard_iface *hard_iface, batadv_info(hard_iface->soft_iface, "Adding interface: %s\n", hard_iface->net_dev->name); - if (atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu < - ETH_DATA_LEN + BATADV_HEADER_LEN) + if (atomic_read(&bat_priv->fragmentation) && + hard_iface->net_dev->mtu < ETH_DATA_LEN + BATADV_HEADER_LEN) batadv_info(hard_iface->soft_iface, "The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. Packets going over this interface will be fragmented on layer2 which could impact the performance. Setting the MTU to %zi would solve the problem.\n", hard_iface->net_dev->name, hard_iface->net_dev->mtu, ETH_DATA_LEN + BATADV_HEADER_LEN); - if (!atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu < - ETH_DATA_LEN + BATADV_HEADER_LEN) + if (!atomic_read(&bat_priv->fragmentation) && + hard_iface->net_dev->mtu < ETH_DATA_LEN + BATADV_HEADER_LEN) batadv_info(hard_iface->soft_iface, "The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. If you experience problems getting traffic through try increasing the MTU to %zi.\n", hard_iface->net_dev->name, hard_iface->net_dev->mtu, @@ -354,15 +358,15 @@ err: return ret; } -void batadv_hardif_disable_interface(struct hard_iface *hard_iface) +void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface) { - struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); - struct hard_iface *primary_if = NULL; + struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); + struct batadv_hard_iface *primary_if = NULL; - if (hard_iface->if_status == IF_ACTIVE) + if (hard_iface->if_status == BATADV_IF_ACTIVE) batadv_hardif_deactivate_interface(hard_iface); - if (hard_iface->if_status != IF_INACTIVE) + if (hard_iface->if_status != BATADV_IF_INACTIVE) goto out; batadv_info(hard_iface->soft_iface, "Removing interface: %s\n", @@ -374,7 +378,7 @@ void batadv_hardif_disable_interface(struct hard_iface *hard_iface) primary_if = batadv_primary_if_get_selected(bat_priv); if (hard_iface == primary_if) { - struct hard_iface *new_if; + struct batadv_hard_iface *new_if; new_if = batadv_hardif_get_active(hard_iface->soft_iface); batadv_primary_if_select(bat_priv, new_if); @@ -384,7 +388,7 @@ void batadv_hardif_disable_interface(struct hard_iface *hard_iface) } bat_priv->bat_algo_ops->bat_iface_disable(hard_iface); - hard_iface->if_status = IF_NOT_IN_USE; + hard_iface->if_status = BATADV_IF_NOT_IN_USE; /* delete all references to this hard_iface */ batadv_purge_orig_ref(bat_priv); @@ -403,10 +407,10 @@ out: batadv_hardif_free_ref(primary_if); } -static struct hard_iface * +static struct batadv_hard_iface * batadv_hardif_add_interface(struct net_device *net_dev) { - struct hard_iface *hard_iface; + struct batadv_hard_iface *hard_iface; int ret; ASSERT_RTNL(); @@ -428,7 +432,7 @@ batadv_hardif_add_interface(struct net_device *net_dev) hard_iface->if_num = -1; hard_iface->net_dev = net_dev; hard_iface->soft_iface = NULL; - hard_iface->if_status = IF_NOT_IN_USE; + hard_iface->if_status = BATADV_IF_NOT_IN_USE; INIT_LIST_HEAD(&hard_iface->list); /* extra reference for return */ atomic_set(&hard_iface->refcount, 2); @@ -452,25 +456,25 @@ out: return NULL; } -static void batadv_hardif_remove_interface(struct hard_iface *hard_iface) +static void batadv_hardif_remove_interface(struct batadv_hard_iface *hard_iface) { ASSERT_RTNL(); /* first deactivate interface */ - if (hard_iface->if_status != IF_NOT_IN_USE) + if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) batadv_hardif_disable_interface(hard_iface); - if (hard_iface->if_status != IF_NOT_IN_USE) + if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) return; - hard_iface->if_status = IF_TO_BE_REMOVED; + hard_iface->if_status = BATADV_IF_TO_BE_REMOVED; batadv_sysfs_del_hardif(&hard_iface->hardif_obj); batadv_hardif_free_ref(hard_iface); } void batadv_hardif_remove_interfaces(void) { - struct hard_iface *hard_iface, *hard_iface_tmp; + struct batadv_hard_iface *hard_iface, *hard_iface_tmp; rtnl_lock(); list_for_each_entry_safe(hard_iface, hard_iface_tmp, @@ -485,10 +489,11 @@ static int batadv_hard_if_event(struct notifier_block *this, unsigned long event, void *ptr) { struct net_device *net_dev = ptr; - struct hard_iface *hard_iface = batadv_hardif_get_by_netdev(net_dev); - struct hard_iface *primary_if = NULL; - struct bat_priv *bat_priv; + struct batadv_hard_iface *hard_iface; + struct batadv_hard_iface *primary_if = NULL; + struct batadv_priv *bat_priv; + hard_iface = batadv_hardif_get_by_netdev(net_dev); if (!hard_iface && event == NETDEV_REGISTER) hard_iface = batadv_hardif_add_interface(net_dev); @@ -513,7 +518,7 @@ static int batadv_hard_if_event(struct notifier_block *this, batadv_update_min_mtu(hard_iface->soft_iface); break; case NETDEV_CHANGEADDR: - if (hard_iface->if_status == IF_NOT_IN_USE) + if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) goto hardif_put; batadv_check_known_mac_addr(hard_iface->net_dev); diff --git a/net/batman-adv/hard-interface.h b/net/batman-adv/hard-interface.h index d66dabd620b7..3732366e7445 100644 --- a/net/batman-adv/hard-interface.h +++ b/net/batman-adv/hard-interface.h @@ -20,22 +20,22 @@ #ifndef _NET_BATMAN_ADV_HARD_INTERFACE_H_ #define _NET_BATMAN_ADV_HARD_INTERFACE_H_ -enum hard_if_state { - IF_NOT_IN_USE, - IF_TO_BE_REMOVED, - IF_INACTIVE, - IF_ACTIVE, - IF_TO_BE_ACTIVATED, - IF_I_WANT_YOU +enum batadv_hard_if_state { + BATADV_IF_NOT_IN_USE, + BATADV_IF_TO_BE_REMOVED, + BATADV_IF_INACTIVE, + BATADV_IF_ACTIVE, + BATADV_IF_TO_BE_ACTIVATED, + BATADV_IF_I_WANT_YOU, }; extern struct notifier_block batadv_hard_if_notifier; -struct hard_iface* +struct batadv_hard_iface* batadv_hardif_get_by_netdev(const struct net_device *net_dev); -int batadv_hardif_enable_interface(struct hard_iface *hard_iface, +int batadv_hardif_enable_interface(struct batadv_hard_iface *hard_iface, const char *iface_name); -void batadv_hardif_disable_interface(struct hard_iface *hard_iface); +void batadv_hardif_disable_interface(struct batadv_hard_iface *hard_iface); void batadv_hardif_remove_interfaces(void); int batadv_hardif_min_mtu(struct net_device *soft_iface); void batadv_update_min_mtu(struct net_device *soft_iface); @@ -43,16 +43,16 @@ void batadv_hardif_free_rcu(struct rcu_head *rcu); bool batadv_is_wifi_iface(int ifindex); static inline void -batadv_hardif_free_ref(struct hard_iface *hard_iface) +batadv_hardif_free_ref(struct batadv_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 * -batadv_primary_if_get_selected(struct bat_priv *bat_priv) +static inline struct batadv_hard_iface * +batadv_primary_if_get_selected(struct batadv_priv *bat_priv) { - struct hard_iface *hard_iface; + struct batadv_hard_iface *hard_iface; rcu_read_lock(); hard_iface = rcu_dereference(bat_priv->primary_if); diff --git a/net/batman-adv/hash.c b/net/batman-adv/hash.c index 1fb961c8d9a0..15a849c2d414 100644 --- a/net/batman-adv/hash.c +++ b/net/batman-adv/hash.c @@ -21,18 +21,18 @@ #include "hash.h" /* clears the hash */ -static void batadv_hash_init(struct hashtable_t *hash) +static void batadv_hash_init(struct batadv_hashtable *hash) { uint32_t i; - for (i = 0 ; i < hash->size; i++) { + for (i = 0; i < hash->size; i++) { INIT_HLIST_HEAD(&hash->table[i]); spin_lock_init(&hash->list_locks[i]); } } /* free only the hashtable and the hash itself. */ -void batadv_hash_destroy(struct hashtable_t *hash) +void batadv_hash_destroy(struct batadv_hashtable *hash) { kfree(hash->list_locks); kfree(hash->table); @@ -40,9 +40,9 @@ void batadv_hash_destroy(struct hashtable_t *hash) } /* allocates and clears the hash */ -struct hashtable_t *batadv_hash_new(uint32_t size) +struct batadv_hashtable *batadv_hash_new(uint32_t size) { - struct hashtable_t *hash; + struct batadv_hashtable *hash; hash = kmalloc(sizeof(*hash), GFP_ATOMIC); if (!hash) @@ -68,7 +68,7 @@ free_hash: return NULL; } -void batadv_hash_set_lock_class(struct hashtable_t *hash, +void batadv_hash_set_lock_class(struct batadv_hashtable *hash, struct lock_class_key *key) { uint32_t i; diff --git a/net/batman-adv/hash.h b/net/batman-adv/hash.h index 7ec4e5b0bd41..83990e318e43 100644 --- a/net/batman-adv/hash.h +++ b/net/batman-adv/hash.h @@ -25,37 +25,39 @@ /* callback to a compare function. should compare 2 element datas for their * keys, return 0 if same and not 0 if not same */ -typedef int (*hashdata_compare_cb)(const struct hlist_node *, const void *); +typedef int (*batadv_hashdata_compare_cb)(const struct hlist_node *, + const void *); /* the hashfunction, should return an index * based on the key in the data of the first * argument and the size the second */ -typedef uint32_t (*hashdata_choose_cb)(const void *, uint32_t); -typedef void (*hashdata_free_cb)(struct hlist_node *, void *); +typedef uint32_t (*batadv_hashdata_choose_cb)(const void *, uint32_t); +typedef void (*batadv_hashdata_free_cb)(struct hlist_node *, void *); -struct hashtable_t { +struct batadv_hashtable { struct hlist_head *table; /* the hashtable itself with the buckets */ spinlock_t *list_locks; /* spinlock for each hash list entry */ uint32_t size; /* size of hashtable */ }; /* allocates and clears the hash */ -struct hashtable_t *batadv_hash_new(uint32_t size); +struct batadv_hashtable *batadv_hash_new(uint32_t size); /* set class key for all locks */ -void batadv_hash_set_lock_class(struct hashtable_t *hash, +void batadv_hash_set_lock_class(struct batadv_hashtable *hash, struct lock_class_key *key); /* free only the hashtable and the hash itself. */ -void batadv_hash_destroy(struct hashtable_t *hash); +void batadv_hash_destroy(struct batadv_hashtable *hash); /* remove the hash structure. if hashdata_free_cb != NULL, this function will be * called to remove the elements inside of the hash. if you don't remove the * elements, memory might be leaked. */ -static inline void batadv_hash_delete(struct hashtable_t *hash, - hashdata_free_cb free_cb, void *arg) +static inline void batadv_hash_delete(struct batadv_hashtable *hash, + batadv_hashdata_free_cb free_cb, + void *arg) { struct hlist_head *head; struct hlist_node *node, *node_tmp; @@ -89,9 +91,9 @@ static inline void batadv_hash_delete(struct hashtable_t *hash, * Returns 0 on success, 1 if the element already is in the hash * and -1 on error. */ -static inline int batadv_hash_add(struct hashtable_t *hash, - hashdata_compare_cb compare, - hashdata_choose_cb choose, +static inline int batadv_hash_add(struct batadv_hashtable *hash, + batadv_hashdata_compare_cb compare, + batadv_hashdata_choose_cb choose, const void *data, struct hlist_node *data_node) { @@ -134,9 +136,10 @@ out: * structure you use with just the key filled, we just need the key for * comparing. */ -static inline void *batadv_hash_remove(struct hashtable_t *hash, - hashdata_compare_cb compare, - hashdata_choose_cb choose, void *data) +static inline void *batadv_hash_remove(struct batadv_hashtable *hash, + batadv_hashdata_compare_cb compare, + batadv_hashdata_choose_cb choose, + void *data) { uint32_t index; struct hlist_node *node; diff --git a/net/batman-adv/icmp_socket.c b/net/batman-adv/icmp_socket.c index f2f578b1d9f0..bde3cf747507 100644 --- a/net/batman-adv/icmp_socket.c +++ b/net/batman-adv/icmp_socket.c @@ -26,10 +26,10 @@ #include "originator.h" #include "hard-interface.h" -static struct socket_client *batadv_socket_client_hash[256]; +static struct batadv_socket_client *batadv_socket_client_hash[256]; -static void batadv_socket_add_packet(struct socket_client *socket_client, - struct icmp_packet_rr *icmp_packet, +static void batadv_socket_add_packet(struct batadv_socket_client *socket_client, + struct batadv_icmp_packet_rr *icmp_packet, size_t icmp_len); void batadv_socket_init(void) @@ -40,7 +40,7 @@ void batadv_socket_init(void) static int batadv_socket_open(struct inode *inode, struct file *file) { unsigned int i; - struct socket_client *socket_client; + struct batadv_socket_client *socket_client; nonseekable_open(inode, file); @@ -77,8 +77,8 @@ static int batadv_socket_open(struct inode *inode, struct file *file) static int batadv_socket_release(struct inode *inode, struct file *file) { - struct socket_client *socket_client = file->private_data; - struct socket_packet *socket_packet; + struct batadv_socket_client *socket_client = file->private_data; + struct batadv_socket_packet *socket_packet; struct list_head *list_pos, *list_pos_tmp; spin_lock_bh(&socket_client->lock); @@ -86,7 +86,7 @@ static int batadv_socket_release(struct inode *inode, struct file *file) /* for all packets in the queue ... */ list_for_each_safe(list_pos, list_pos_tmp, &socket_client->queue_list) { socket_packet = list_entry(list_pos, - struct socket_packet, list); + struct batadv_socket_packet, list); list_del(list_pos); kfree(socket_packet); @@ -104,15 +104,15 @@ static int batadv_socket_release(struct inode *inode, struct file *file) static ssize_t batadv_socket_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { - struct socket_client *socket_client = file->private_data; - struct socket_packet *socket_packet; + struct batadv_socket_client *socket_client = file->private_data; + struct batadv_socket_packet *socket_packet; size_t packet_len; int error; if ((file->f_flags & O_NONBLOCK) && (socket_client->queue_len == 0)) return -EAGAIN; - if ((!buf) || (count < sizeof(struct icmp_packet))) + if ((!buf) || (count < sizeof(struct batadv_icmp_packet))) return -EINVAL; if (!access_ok(VERIFY_WRITE, buf, count)) @@ -127,7 +127,7 @@ static ssize_t batadv_socket_read(struct file *file, char __user *buf, spin_lock_bh(&socket_client->lock); socket_packet = list_first_entry(&socket_client->queue_list, - struct socket_packet, list); + struct batadv_socket_packet, list); list_del(&socket_packet->list); socket_client->queue_len--; @@ -147,18 +147,18 @@ static ssize_t batadv_socket_read(struct file *file, char __user *buf, static ssize_t batadv_socket_write(struct file *file, const char __user *buff, size_t len, loff_t *off) { - struct socket_client *socket_client = file->private_data; - struct bat_priv *bat_priv = socket_client->bat_priv; - struct hard_iface *primary_if = NULL; + struct batadv_socket_client *socket_client = file->private_data; + struct batadv_priv *bat_priv = socket_client->bat_priv; + struct batadv_hard_iface *primary_if = NULL; struct sk_buff *skb; - struct icmp_packet_rr *icmp_packet; + struct batadv_icmp_packet_rr *icmp_packet; - struct orig_node *orig_node = NULL; - struct neigh_node *neigh_node = NULL; - size_t packet_len = sizeof(struct icmp_packet); + struct batadv_orig_node *orig_node = NULL; + struct batadv_neigh_node *neigh_node = NULL; + size_t packet_len = sizeof(struct batadv_icmp_packet); - if (len < sizeof(struct icmp_packet)) { - batadv_dbg(DBG_BATMAN, bat_priv, + if (len < sizeof(struct batadv_icmp_packet)) { + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Error - can't send packet from char device: invalid packet size\n"); return -EINVAL; } @@ -170,8 +170,8 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff, goto out; } - if (len >= sizeof(struct icmp_packet_rr)) - packet_len = sizeof(struct icmp_packet_rr); + if (len >= sizeof(struct batadv_icmp_packet_rr)) + packet_len = sizeof(struct batadv_icmp_packet_rr); skb = dev_alloc_skb(packet_len + ETH_HLEN); if (!skb) { @@ -180,22 +180,22 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff, } skb_reserve(skb, ETH_HLEN); - icmp_packet = (struct icmp_packet_rr *)skb_put(skb, packet_len); + icmp_packet = (struct batadv_icmp_packet_rr *)skb_put(skb, packet_len); if (copy_from_user(icmp_packet, buff, packet_len)) { len = -EFAULT; goto free_skb; } - if (icmp_packet->header.packet_type != BAT_ICMP) { - batadv_dbg(DBG_BATMAN, bat_priv, + if (icmp_packet->header.packet_type != BATADV_ICMP) { + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Error - can't send packet from char device: got bogus packet type (expected: BAT_ICMP)\n"); len = -EINVAL; goto free_skb; } - if (icmp_packet->msg_type != ECHO_REQUEST) { - batadv_dbg(DBG_BATMAN, bat_priv, + if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) { + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Error - can't send packet from char device: got bogus message type (expected: ECHO_REQUEST)\n"); len = -EINVAL; goto free_skb; @@ -204,14 +204,14 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff, icmp_packet->uid = socket_client->index; if (icmp_packet->header.version != BATADV_COMPAT_VERSION) { - icmp_packet->msg_type = PARAMETER_PROBLEM; + icmp_packet->msg_type = BATADV_PARAMETER_PROBLEM; icmp_packet->header.version = BATADV_COMPAT_VERSION; batadv_socket_add_packet(socket_client, icmp_packet, packet_len); goto free_skb; } - if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE) + if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE) goto dst_unreach; orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->dst); @@ -225,13 +225,13 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff, if (!neigh_node->if_incoming) goto dst_unreach; - if (neigh_node->if_incoming->if_status != IF_ACTIVE) + if (neigh_node->if_incoming->if_status != BATADV_IF_ACTIVE) goto dst_unreach; memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN); - if (packet_len == sizeof(struct icmp_packet_rr)) + if (packet_len == sizeof(struct batadv_icmp_packet_rr)) memcpy(icmp_packet->rr, neigh_node->if_incoming->net_dev->dev_addr, ETH_ALEN); @@ -239,7 +239,7 @@ static ssize_t batadv_socket_write(struct file *file, const char __user *buff, goto out; dst_unreach: - icmp_packet->msg_type = DESTINATION_UNREACHABLE; + icmp_packet->msg_type = BATADV_DESTINATION_UNREACHABLE; batadv_socket_add_packet(socket_client, icmp_packet, packet_len); free_skb: kfree_skb(skb); @@ -255,7 +255,7 @@ out: static unsigned int batadv_socket_poll(struct file *file, poll_table *wait) { - struct socket_client *socket_client = file->private_data; + struct batadv_socket_client *socket_client = file->private_data; poll_wait(file, &socket_client->queue_wait, wait); @@ -275,7 +275,7 @@ static const struct file_operations batadv_fops = { .llseek = no_llseek, }; -int batadv_socket_setup(struct bat_priv *bat_priv) +int batadv_socket_setup(struct batadv_priv *bat_priv) { struct dentry *d; @@ -293,11 +293,11 @@ err: return -ENOMEM; } -static void batadv_socket_add_packet(struct socket_client *socket_client, - struct icmp_packet_rr *icmp_packet, +static void batadv_socket_add_packet(struct batadv_socket_client *socket_client, + struct batadv_icmp_packet_rr *icmp_packet, size_t icmp_len) { - struct socket_packet *socket_packet; + struct batadv_socket_packet *socket_packet; socket_packet = kmalloc(sizeof(*socket_packet), GFP_ATOMIC); @@ -324,7 +324,8 @@ static void batadv_socket_add_packet(struct socket_client *socket_client, if (socket_client->queue_len > 100) { socket_packet = list_first_entry(&socket_client->queue_list, - struct socket_packet, list); + struct batadv_socket_packet, + list); list_del(&socket_packet->list); kfree(socket_packet); @@ -336,10 +337,10 @@ static void batadv_socket_add_packet(struct socket_client *socket_client, wake_up(&socket_client->queue_wait); } -void batadv_socket_receive_packet(struct icmp_packet_rr *icmp_packet, +void batadv_socket_receive_packet(struct batadv_icmp_packet_rr *icmp_packet, size_t icmp_len) { - struct socket_client *hash; + struct batadv_socket_client *hash; hash = batadv_socket_client_hash[icmp_packet->uid]; if (hash) diff --git a/net/batman-adv/icmp_socket.h b/net/batman-adv/icmp_socket.h index f88f9f0fe7a7..29443a1dbb5c 100644 --- a/net/batman-adv/icmp_socket.h +++ b/net/batman-adv/icmp_socket.h @@ -23,8 +23,8 @@ #define BATADV_ICMP_SOCKET "socket" void batadv_socket_init(void); -int batadv_socket_setup(struct bat_priv *bat_priv); -void batadv_socket_receive_packet(struct icmp_packet_rr *icmp_packet, +int batadv_socket_setup(struct batadv_priv *bat_priv); +void batadv_socket_receive_packet(struct batadv_icmp_packet_rr *icmp_packet, size_t icmp_len); #endif /* _NET_BATMAN_ADV_ICMP_SOCKET_H_ */ diff --git a/net/batman-adv/main.c b/net/batman-adv/main.c index df7335c4217a..13c88b25ab31 100644 --- a/net/batman-adv/main.c +++ b/net/batman-adv/main.c @@ -18,8 +18,8 @@ */ #include "main.h" -#include "bat_sysfs.h" -#include "bat_debugfs.h" +#include "sysfs.h" +#include "debugfs.h" #include "routing.h" #include "send.h" #include "originator.h" @@ -39,7 +39,7 @@ */ struct list_head batadv_hardif_list; static int (*batadv_rx_handler[256])(struct sk_buff *, - struct hard_iface *); + struct batadv_hard_iface *); char batadv_routing_algo[20] = "BATMAN_IV"; static struct hlist_head batadv_algo_list; @@ -92,7 +92,7 @@ static void __exit batadv_exit(void) int batadv_mesh_init(struct net_device *soft_iface) { - struct bat_priv *bat_priv = netdev_priv(soft_iface); + struct batadv_priv *bat_priv = netdev_priv(soft_iface); int ret; spin_lock_init(&bat_priv->forw_bat_list_lock); @@ -132,7 +132,7 @@ int batadv_mesh_init(struct net_device *soft_iface) goto err; atomic_set(&bat_priv->gw_reselect, 0); - atomic_set(&bat_priv->mesh_state, MESH_ACTIVE); + atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE); return 0; @@ -143,9 +143,9 @@ err: void batadv_mesh_free(struct net_device *soft_iface) { - struct bat_priv *bat_priv = netdev_priv(soft_iface); + struct batadv_priv *bat_priv = netdev_priv(soft_iface); - atomic_set(&bat_priv->mesh_state, MESH_DEACTIVATING); + atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING); batadv_purge_outstanding_packets(bat_priv, NULL); @@ -160,7 +160,7 @@ void batadv_mesh_free(struct net_device *soft_iface) free_percpu(bat_priv->bat_counters); - atomic_set(&bat_priv->mesh_state, MESH_INACTIVE); + atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE); } void batadv_inc_module_count(void) @@ -175,11 +175,11 @@ void batadv_dec_module_count(void) int batadv_is_my_mac(const uint8_t *addr) { - const struct hard_iface *hard_iface; + const struct batadv_hard_iface *hard_iface; rcu_read_lock(); list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { - if (hard_iface->if_status != IF_ACTIVE) + if (hard_iface->if_status != BATADV_IF_ACTIVE) continue; if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) { @@ -192,7 +192,7 @@ int batadv_is_my_mac(const uint8_t *addr) } static int batadv_recv_unhandled_packet(struct sk_buff *skb, - struct hard_iface *recv_if) + struct batadv_hard_iface *recv_if) { return NET_RX_DROP; } @@ -204,13 +204,14 @@ int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *ptype, struct net_device *orig_dev) { - struct bat_priv *bat_priv; - struct batman_ogm_packet *batman_ogm_packet; - struct hard_iface *hard_iface; + struct batadv_priv *bat_priv; + struct batadv_ogm_packet *batadv_ogm_packet; + struct batadv_hard_iface *hard_iface; uint8_t idx; int ret; - hard_iface = container_of(ptype, struct hard_iface, batman_adv_ptype); + hard_iface = container_of(ptype, struct batadv_hard_iface, + batman_adv_ptype); skb = skb_share_check(skb, GFP_ATOMIC); /* skb was released by skb_share_check() */ @@ -230,26 +231,26 @@ int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev, bat_priv = netdev_priv(hard_iface->soft_iface); - if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE) + if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE) goto err_free; /* discard frames on not active interfaces */ - if (hard_iface->if_status != IF_ACTIVE) + if (hard_iface->if_status != BATADV_IF_ACTIVE) goto err_free; - batman_ogm_packet = (struct batman_ogm_packet *)skb->data; + batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data; - if (batman_ogm_packet->header.version != BATADV_COMPAT_VERSION) { - batadv_dbg(DBG_BATMAN, bat_priv, + if (batadv_ogm_packet->header.version != BATADV_COMPAT_VERSION) { + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Drop packet: incompatible batman version (%i)\n", - batman_ogm_packet->header.version); + batadv_ogm_packet->header.version); goto err_free; } /* all receive handlers return whether they received or reused * the supplied skb. if not, we have to free the skb. */ - idx = batman_ogm_packet->header.packet_type; + idx = batadv_ogm_packet->header.packet_type; ret = (*batadv_rx_handler[idx])(skb, hard_iface); if (ret == NET_RX_DROP) @@ -275,24 +276,25 @@ static void batadv_recv_handler_init(void) batadv_rx_handler[i] = batadv_recv_unhandled_packet; /* batman icmp packet */ - batadv_rx_handler[BAT_ICMP] = batadv_recv_icmp_packet; + batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet; /* unicast packet */ - batadv_rx_handler[BAT_UNICAST] = batadv_recv_unicast_packet; + batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet; /* fragmented unicast packet */ - batadv_rx_handler[BAT_UNICAST_FRAG] = batadv_recv_ucast_frag_packet; + batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_ucast_frag_packet; /* broadcast packet */ - batadv_rx_handler[BAT_BCAST] = batadv_recv_bcast_packet; + batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet; /* vis packet */ - batadv_rx_handler[BAT_VIS] = batadv_recv_vis_packet; + batadv_rx_handler[BATADV_VIS] = batadv_recv_vis_packet; /* Translation table query (request or response) */ - batadv_rx_handler[BAT_TT_QUERY] = batadv_recv_tt_query; + batadv_rx_handler[BATADV_TT_QUERY] = batadv_recv_tt_query; /* Roaming advertisement */ - batadv_rx_handler[BAT_ROAM_ADV] = batadv_recv_roam_adv; + batadv_rx_handler[BATADV_ROAM_ADV] = batadv_recv_roam_adv; } -int batadv_recv_handler_register(uint8_t packet_type, - int (*recv_handler)(struct sk_buff *, - struct hard_iface *)) +int +batadv_recv_handler_register(uint8_t packet_type, + int (*recv_handler)(struct sk_buff *, + struct batadv_hard_iface *)) { if (batadv_rx_handler[packet_type] != &batadv_recv_unhandled_packet) return -EBUSY; @@ -306,9 +308,9 @@ void batadv_recv_handler_unregister(uint8_t packet_type) batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet; } -static struct bat_algo_ops *batadv_algo_get(char *name) +static struct batadv_algo_ops *batadv_algo_get(char *name) { - struct bat_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp; + struct batadv_algo_ops *bat_algo_ops = NULL, *bat_algo_ops_tmp; struct hlist_node *node; hlist_for_each_entry(bat_algo_ops_tmp, node, &batadv_algo_list, list) { @@ -322,9 +324,9 @@ static struct bat_algo_ops *batadv_algo_get(char *name) return bat_algo_ops; } -int batadv_algo_register(struct bat_algo_ops *bat_algo_ops) +int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops) { - struct bat_algo_ops *bat_algo_ops_tmp; + struct batadv_algo_ops *bat_algo_ops_tmp; int ret; bat_algo_ops_tmp = batadv_algo_get(bat_algo_ops->name); @@ -356,9 +358,9 @@ out: return ret; } -int batadv_algo_select(struct bat_priv *bat_priv, char *name) +int batadv_algo_select(struct batadv_priv *bat_priv, char *name) { - struct bat_algo_ops *bat_algo_ops; + struct batadv_algo_ops *bat_algo_ops; int ret = -EINVAL; bat_algo_ops = batadv_algo_get(name); @@ -374,7 +376,7 @@ out: int batadv_algo_seq_print_text(struct seq_file *seq, void *offset) { - struct bat_algo_ops *bat_algo_ops; + struct batadv_algo_ops *bat_algo_ops; struct hlist_node *node; seq_printf(seq, "Available routing algorithms:\n"); @@ -388,7 +390,7 @@ int batadv_algo_seq_print_text(struct seq_file *seq, void *offset) static int batadv_param_set_ra(const char *val, const struct kernel_param *kp) { - struct bat_algo_ops *bat_algo_ops; + struct batadv_algo_ops *bat_algo_ops; char *algo_name = (char *)val; size_t name_len = strlen(algo_name); diff --git a/net/batman-adv/main.h b/net/batman-adv/main.h index 09660b4041f9..b8d4ac17f001 100644 --- a/net/batman-adv/main.h +++ b/net/batman-adv/main.h @@ -95,23 +95,23 @@ #define BATADV_RESET_PROTECTION_MS 30000 #define BATADV_EXPECTED_SEQNO_RANGE 65536 -enum mesh_state { - MESH_INACTIVE, - MESH_ACTIVE, - MESH_DEACTIVATING +enum batadv_mesh_state { + BATADV_MESH_INACTIVE, + BATADV_MESH_ACTIVE, + BATADV_MESH_DEACTIVATING, }; #define BATADV_BCAST_QUEUE_LEN 256 #define BATADV_BATMAN_QUEUE_LEN 256 -enum uev_action { - UEV_ADD = 0, - UEV_DEL, - UEV_CHANGE +enum batadv_uev_action { + BATADV_UEV_ADD = 0, + BATADV_UEV_DEL, + BATADV_UEV_CHANGE, }; -enum uev_type { - UEV_GW = 0 +enum batadv_uev_type { + BATADV_UEV_GW = 0, }; #define BATADV_GW_THRESHOLD 50 @@ -124,12 +124,12 @@ enum uev_type { #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt /* all messages related to routing / flooding / broadcasting / etc */ -enum dbg_level { - DBG_BATMAN = 1 << 0, - DBG_ROUTES = 1 << 1, /* route added / changed / deleted */ - DBG_TT = 1 << 2, /* translation table operations */ - DBG_BLA = 1 << 3, /* bridge loop avoidance */ - DBG_ALL = 15 +enum batadv_dbg_level { + BATADV_DBG_BATMAN = 1 << 0, + BATADV_DBG_ROUTES = 1 << 1, /* route added / changed / deleted */ + BATADV_DBG_TT = 1 << 2, /* translation table operations */ + BATADV_DBG_BLA = 1 << 3, /* bridge loop avoidance */ + BATADV_DBG_ALL = 15, }; /* Kernel headers */ @@ -164,16 +164,17 @@ int batadv_is_my_mac(const uint8_t *addr); int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev, struct packet_type *ptype, struct net_device *orig_dev); -int batadv_recv_handler_register(uint8_t packet_type, - int (*recv_handler)(struct sk_buff *, - struct hard_iface *)); +int +batadv_recv_handler_register(uint8_t packet_type, + int (*recv_handler)(struct sk_buff *, + struct batadv_hard_iface *)); void batadv_recv_handler_unregister(uint8_t packet_type); -int batadv_algo_register(struct bat_algo_ops *bat_algo_ops); -int batadv_algo_select(struct bat_priv *bat_priv, char *name); +int batadv_algo_register(struct batadv_algo_ops *bat_algo_ops); +int batadv_algo_select(struct batadv_priv *bat_priv, char *name); int batadv_algo_seq_print_text(struct seq_file *seq, void *offset); #ifdef CONFIG_BATMAN_ADV_DEBUG -int batadv_debug_log(struct bat_priv *bat_priv, const char *fmt, ...) +int batadv_debug_log(struct batadv_priv *bat_priv, const char *fmt, ...) __printf(2, 3); #define batadv_dbg(type, bat_priv, fmt, arg...) \ @@ -185,7 +186,7 @@ __printf(2, 3); #else /* !CONFIG_BATMAN_ADV_DEBUG */ __printf(3, 4) static inline void batadv_dbg(int type __always_unused, - struct bat_priv *bat_priv __always_unused, + struct batadv_priv *bat_priv __always_unused, const char *fmt __always_unused, ...) { } @@ -194,15 +195,15 @@ static inline void batadv_dbg(int type __always_unused, #define batadv_info(net_dev, fmt, arg...) \ do { \ struct net_device *_netdev = (net_dev); \ - struct bat_priv *_batpriv = netdev_priv(_netdev); \ - batadv_dbg(DBG_ALL, _batpriv, fmt, ## arg); \ + struct batadv_priv *_batpriv = netdev_priv(_netdev); \ + batadv_dbg(BATADV_DBG_ALL, _batpriv, fmt, ## arg); \ pr_info("%s: " fmt, _netdev->name, ## arg); \ } while (0) #define batadv_err(net_dev, fmt, arg...) \ do { \ struct net_device *_netdev = (net_dev); \ - struct bat_priv *_batpriv = netdev_priv(_netdev); \ - batadv_dbg(DBG_ALL, _batpriv, fmt, ## arg); \ + struct batadv_priv *_batpriv = netdev_priv(_netdev); \ + batadv_dbg(BATADV_DBG_ALL, _batpriv, fmt, ## arg); \ pr_err("%s: " fmt, _netdev->name, ## arg); \ } while (0) @@ -250,7 +251,7 @@ static inline bool batadv_has_timed_out(unsigned long timestamp, #define batadv_seq_after(x, y) batadv_seq_before(y, x) /* Stop preemption on local cpu while incrementing the counter */ -static inline void batadv_add_counter(struct bat_priv *bat_priv, size_t idx, +static inline void batadv_add_counter(struct batadv_priv *bat_priv, size_t idx, size_t count) { int cpu = get_cpu(); @@ -261,11 +262,11 @@ static inline void batadv_add_counter(struct bat_priv *bat_priv, size_t idx, #define batadv_inc_counter(b, i) batadv_add_counter(b, i, 1) /* Sum and return the cpu-local counters for index 'idx' */ -static inline uint64_t batadv_sum_counter(struct bat_priv *bat_priv, size_t idx) +static inline uint64_t batadv_sum_counter(struct batadv_priv *bat_priv, + size_t idx) { - uint64_t *counters; + uint64_t *counters, sum = 0; int cpu; - int sum = 0; for_each_possible_cpu(cpu) { counters = per_cpu_ptr(bat_priv->bat_counters, cpu); diff --git a/net/batman-adv/originator.c b/net/batman-adv/originator.c index f04f591f4668..ac9bdf8f80a6 100644 --- a/net/batman-adv/originator.c +++ b/net/batman-adv/originator.c @@ -30,7 +30,7 @@ static void batadv_purge_orig(struct work_struct *work); -static void batadv_start_purge_timer(struct bat_priv *bat_priv) +static void batadv_start_purge_timer(struct batadv_priv *bat_priv) { INIT_DELAYED_WORK(&bat_priv->orig_work, batadv_purge_orig); queue_delayed_work(batadv_event_workqueue, @@ -40,12 +40,13 @@ static void batadv_start_purge_timer(struct bat_priv *bat_priv) /* returns 1 if they are the same originator */ static int batadv_compare_orig(const struct hlist_node *node, const void *data2) { - const void *data1 = container_of(node, struct orig_node, hash_entry); + const void *data1 = container_of(node, struct batadv_orig_node, + hash_entry); return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0); } -int batadv_originator_init(struct bat_priv *bat_priv) +int batadv_originator_init(struct batadv_priv *bat_priv) { if (bat_priv->orig_hash) return 0; @@ -62,16 +63,17 @@ err: return -ENOMEM; } -void batadv_neigh_node_free_ref(struct neigh_node *neigh_node) +void batadv_neigh_node_free_ref(struct batadv_neigh_node *neigh_node) { if (atomic_dec_and_test(&neigh_node->refcount)) kfree_rcu(neigh_node, rcu); } /* increases the refcounter of a found router */ -struct neigh_node *batadv_orig_node_get_router(struct orig_node *orig_node) +struct batadv_neigh_node * +batadv_orig_node_get_router(struct batadv_orig_node *orig_node) { - struct neigh_node *router; + struct batadv_neigh_node *router; rcu_read_lock(); router = rcu_dereference(orig_node->router); @@ -83,12 +85,12 @@ struct neigh_node *batadv_orig_node_get_router(struct orig_node *orig_node) return router; } -struct neigh_node *batadv_neigh_node_new(struct hard_iface *hard_iface, - const uint8_t *neigh_addr, - uint32_t seqno) +struct batadv_neigh_node * +batadv_neigh_node_new(struct batadv_hard_iface *hard_iface, + const uint8_t *neigh_addr, uint32_t seqno) { - struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); - struct neigh_node *neigh_node; + struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); + struct batadv_neigh_node *neigh_node; neigh_node = kzalloc(sizeof(*neigh_node), GFP_ATOMIC); if (!neigh_node) @@ -102,7 +104,7 @@ struct neigh_node *batadv_neigh_node_new(struct hard_iface *hard_iface, /* extra reference for return */ atomic_set(&neigh_node->refcount, 2); - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Creating new neighbor %pM, initial seqno %d\n", neigh_addr, seqno); @@ -113,10 +115,10 @@ out: static void batadv_orig_node_free_rcu(struct rcu_head *rcu) { struct hlist_node *node, *node_tmp; - struct neigh_node *neigh_node, *tmp_neigh_node; - struct orig_node *orig_node; + struct batadv_neigh_node *neigh_node, *tmp_neigh_node; + struct batadv_orig_node *orig_node; - orig_node = container_of(rcu, struct orig_node, rcu); + orig_node = container_of(rcu, struct batadv_orig_node, rcu); spin_lock_bh(&orig_node->neigh_list_lock); @@ -146,19 +148,19 @@ static void batadv_orig_node_free_rcu(struct rcu_head *rcu) kfree(orig_node); } -void batadv_orig_node_free_ref(struct orig_node *orig_node) +void batadv_orig_node_free_ref(struct batadv_orig_node *orig_node) { if (atomic_dec_and_test(&orig_node->refcount)) call_rcu(&orig_node->rcu, batadv_orig_node_free_rcu); } -void batadv_originator_free(struct bat_priv *bat_priv) +void batadv_originator_free(struct batadv_priv *bat_priv) { - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_node *node, *node_tmp; struct hlist_head *head; spinlock_t *list_lock; /* spinlock to protect write access */ - struct orig_node *orig_node; + struct batadv_orig_node *orig_node; uint32_t i; if (!hash) @@ -188,10 +190,10 @@ void batadv_originator_free(struct bat_priv *bat_priv) /* this function finds or creates an originator entry for the given * address if it does not exits */ -struct orig_node *batadv_get_orig_node(struct bat_priv *bat_priv, - const uint8_t *addr) +struct batadv_orig_node *batadv_get_orig_node(struct batadv_priv *bat_priv, + const uint8_t *addr) { - struct orig_node *orig_node; + struct batadv_orig_node *orig_node; int size; int hash_added; unsigned long reset_time; @@ -200,8 +202,8 @@ struct orig_node *batadv_get_orig_node(struct bat_priv *bat_priv, if (orig_node) return orig_node; - batadv_dbg(DBG_BATMAN, bat_priv, "Creating new originator: %pM\n", - addr); + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, + "Creating new originator: %pM\n", addr); orig_node = kzalloc(sizeof(*orig_node), GFP_ATOMIC); if (!orig_node) @@ -264,15 +266,16 @@ free_orig_node: return NULL; } -static bool batadv_purge_orig_neighbors(struct bat_priv *bat_priv, - struct orig_node *orig_node, - struct neigh_node **best_neigh_node) +static bool +batadv_purge_orig_neighbors(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + struct batadv_neigh_node **best_neigh_node) { struct hlist_node *node, *node_tmp; - struct neigh_node *neigh_node; + struct batadv_neigh_node *neigh_node; bool neigh_purged = false; unsigned long last_seen; - struct hard_iface *if_incoming; + struct batadv_hard_iface *if_incoming; *best_neigh_node = NULL; @@ -286,19 +289,19 @@ static bool batadv_purge_orig_neighbors(struct bat_priv *bat_priv, if_incoming = neigh_node->if_incoming; if ((batadv_has_timed_out(last_seen, BATADV_PURGE_TIMEOUT)) || - (if_incoming->if_status == IF_INACTIVE) || - (if_incoming->if_status == IF_NOT_IN_USE) || - (if_incoming->if_status == IF_TO_BE_REMOVED)) { - - if ((if_incoming->if_status == IF_INACTIVE) || - (if_incoming->if_status == IF_NOT_IN_USE) || - (if_incoming->if_status == IF_TO_BE_REMOVED)) - batadv_dbg(DBG_BATMAN, bat_priv, + (if_incoming->if_status == BATADV_IF_INACTIVE) || + (if_incoming->if_status == BATADV_IF_NOT_IN_USE) || + (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)) { + + if ((if_incoming->if_status == BATADV_IF_INACTIVE) || + (if_incoming->if_status == BATADV_IF_NOT_IN_USE) || + (if_incoming->if_status == BATADV_IF_TO_BE_REMOVED)) + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "neighbor purge: originator %pM, neighbor: %pM, iface: %s\n", orig_node->orig, neigh_node->addr, if_incoming->net_dev->name); else - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "neighbor timeout: originator %pM, neighbor: %pM, last_seen: %u\n", orig_node->orig, neigh_node->addr, jiffies_to_msecs(last_seen)); @@ -319,14 +322,14 @@ static bool batadv_purge_orig_neighbors(struct bat_priv *bat_priv, return neigh_purged; } -static bool batadv_purge_orig_node(struct bat_priv *bat_priv, - struct orig_node *orig_node) +static bool batadv_purge_orig_node(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node) { - struct neigh_node *best_neigh_node; + struct batadv_neigh_node *best_neigh_node; if (batadv_has_timed_out(orig_node->last_seen, 2 * BATADV_PURGE_TIMEOUT)) { - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "Originator timeout: originator %pM, last_seen %u\n", orig_node->orig, jiffies_to_msecs(orig_node->last_seen)); @@ -341,13 +344,13 @@ static bool batadv_purge_orig_node(struct bat_priv *bat_priv, return false; } -static void _batadv_purge_orig(struct bat_priv *bat_priv) +static void _batadv_purge_orig(struct batadv_priv *bat_priv) { - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_node *node, *node_tmp; struct hlist_head *head; spinlock_t *list_lock; /* spinlock to protect write access */ - struct orig_node *orig_node; + struct batadv_orig_node *orig_node; uint32_t i; if (!hash) @@ -383,16 +386,16 @@ static void _batadv_purge_orig(struct bat_priv *bat_priv) static void batadv_purge_orig(struct work_struct *work) { - struct delayed_work *delayed_work = - container_of(work, struct delayed_work, work); - struct bat_priv *bat_priv = - container_of(delayed_work, struct bat_priv, orig_work); + struct delayed_work *delayed_work; + struct batadv_priv *bat_priv; + delayed_work = container_of(work, struct delayed_work, work); + bat_priv = container_of(delayed_work, struct batadv_priv, orig_work); _batadv_purge_orig(bat_priv); batadv_start_purge_timer(bat_priv); } -void batadv_purge_orig_ref(struct bat_priv *bat_priv) +void batadv_purge_orig_ref(struct batadv_priv *bat_priv) { _batadv_purge_orig(bat_priv); } @@ -400,16 +403,17 @@ void batadv_purge_orig_ref(struct bat_priv *bat_priv) int batadv_orig_seq_print_text(struct seq_file *seq, void *offset) { struct net_device *net_dev = (struct net_device *)seq->private; - struct bat_priv *bat_priv = netdev_priv(net_dev); - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_priv *bat_priv = netdev_priv(net_dev); + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_node *node, *node_tmp; struct hlist_head *head; - struct hard_iface *primary_if; - struct orig_node *orig_node; - struct neigh_node *neigh_node, *neigh_node_tmp; + struct batadv_hard_iface *primary_if; + struct batadv_orig_node *orig_node; + struct batadv_neigh_node *neigh_node, *neigh_node_tmp; int batman_count = 0; int last_seen_secs; int last_seen_msecs; + unsigned long last_seen_jiffies; uint32_t i; int ret = 0; @@ -422,7 +426,7 @@ int batadv_orig_seq_print_text(struct seq_file *seq, void *offset) goto out; } - if (primary_if->if_status != IF_ACTIVE) { + if (primary_if->if_status != BATADV_IF_ACTIVE) { ret = seq_printf(seq, "BATMAN mesh %s disabled - primary interface not active\n", net_dev->name); @@ -448,10 +452,10 @@ int batadv_orig_seq_print_text(struct seq_file *seq, void *offset) if (neigh_node->tq_avg == 0) goto next; - last_seen_secs = jiffies_to_msecs(jiffies - - orig_node->last_seen) / 1000; - last_seen_msecs = jiffies_to_msecs(jiffies - - orig_node->last_seen) % 1000; + last_seen_jiffies = jiffies - orig_node->last_seen; + last_seen_msecs = jiffies_to_msecs(last_seen_jiffies); + last_seen_secs = last_seen_msecs / 1000; + last_seen_msecs = last_seen_msecs % 1000; seq_printf(seq, "%pM %4i.%03is (%3i) %pM [%10s]:", orig_node->orig, last_seen_secs, @@ -484,7 +488,8 @@ out: return ret; } -static int batadv_orig_node_add_if(struct orig_node *orig_node, int max_if_num) +static int batadv_orig_node_add_if(struct batadv_orig_node *orig_node, + int max_if_num) { void *data_ptr; size_t data_size, old_size; @@ -511,13 +516,14 @@ static int batadv_orig_node_add_if(struct orig_node *orig_node, int max_if_num) return 0; } -int batadv_orig_hash_add_if(struct hard_iface *hard_iface, int max_if_num) +int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface, + int max_if_num) { - struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_node *node; struct hlist_head *head; - struct orig_node *orig_node; + struct batadv_orig_node *orig_node; uint32_t i; int ret; @@ -546,7 +552,7 @@ err: return -ENOMEM; } -static int batadv_orig_node_del_if(struct orig_node *orig_node, +static int batadv_orig_node_del_if(struct batadv_orig_node *orig_node, int max_if_num, int del_if_num) { void *data_ptr = NULL; @@ -594,14 +600,15 @@ free_own_sum: return 0; } -int batadv_orig_hash_del_if(struct hard_iface *hard_iface, int max_if_num) +int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface, + int max_if_num) { - struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_node *node; struct hlist_head *head; - struct hard_iface *hard_iface_tmp; - struct orig_node *orig_node; + struct batadv_hard_iface *hard_iface_tmp; + struct batadv_orig_node *orig_node; uint32_t i; int ret; @@ -627,7 +634,7 @@ int batadv_orig_hash_del_if(struct hard_iface *hard_iface, int max_if_num) /* renumber remaining batman interfaces _inside_ of orig_hash_lock */ rcu_read_lock(); list_for_each_entry_rcu(hard_iface_tmp, &batadv_hardif_list, list) { - if (hard_iface_tmp->if_status == IF_NOT_IN_USE) + if (hard_iface_tmp->if_status == BATADV_IF_NOT_IN_USE) continue; if (hard_iface == hard_iface_tmp) diff --git a/net/batman-adv/originator.h b/net/batman-adv/originator.h index 35f67eb4073f..9778e656dec7 100644 --- a/net/batman-adv/originator.h +++ b/net/batman-adv/originator.h @@ -22,20 +22,23 @@ #include "hash.h" -int batadv_originator_init(struct bat_priv *bat_priv); -void batadv_originator_free(struct bat_priv *bat_priv); -void batadv_purge_orig_ref(struct bat_priv *bat_priv); -void batadv_orig_node_free_ref(struct orig_node *orig_node); -struct orig_node *batadv_get_orig_node(struct bat_priv *bat_priv, - const uint8_t *addr); -struct neigh_node *batadv_neigh_node_new(struct hard_iface *hard_iface, - const uint8_t *neigh_addr, - uint32_t seqno); -void batadv_neigh_node_free_ref(struct neigh_node *neigh_node); -struct neigh_node *batadv_orig_node_get_router(struct orig_node *orig_node); +int batadv_originator_init(struct batadv_priv *bat_priv); +void batadv_originator_free(struct batadv_priv *bat_priv); +void batadv_purge_orig_ref(struct batadv_priv *bat_priv); +void batadv_orig_node_free_ref(struct batadv_orig_node *orig_node); +struct batadv_orig_node *batadv_get_orig_node(struct batadv_priv *bat_priv, + const uint8_t *addr); +struct batadv_neigh_node * +batadv_neigh_node_new(struct batadv_hard_iface *hard_iface, + const uint8_t *neigh_addr, uint32_t seqno); +void batadv_neigh_node_free_ref(struct batadv_neigh_node *neigh_node); +struct batadv_neigh_node * +batadv_orig_node_get_router(struct batadv_orig_node *orig_node); int batadv_orig_seq_print_text(struct seq_file *seq, void *offset); -int batadv_orig_hash_add_if(struct hard_iface *hard_iface, int max_if_num); -int batadv_orig_hash_del_if(struct hard_iface *hard_iface, int max_if_num); +int batadv_orig_hash_add_if(struct batadv_hard_iface *hard_iface, + int max_if_num); +int batadv_orig_hash_del_if(struct batadv_hard_iface *hard_iface, + int max_if_num); /* hashfunction to choose an entry in a hash table of given size @@ -60,13 +63,13 @@ static inline uint32_t batadv_choose_orig(const void *data, uint32_t size) return hash % size; } -static inline struct orig_node *batadv_orig_hash_find(struct bat_priv *bat_priv, - const void *data) +static inline struct batadv_orig_node * +batadv_orig_hash_find(struct batadv_priv *bat_priv, const void *data) { - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_head *head; struct hlist_node *node; - struct orig_node *orig_node, *orig_node_tmp = NULL; + struct batadv_orig_node *orig_node, *orig_node_tmp = NULL; int index; if (!hash) diff --git a/net/batman-adv/packet.h b/net/batman-adv/packet.h index e562414c2940..8d3e55a96adc 100644 --- a/net/batman-adv/packet.h +++ b/net/batman-adv/packet.h @@ -22,99 +22,99 @@ #define BATADV_ETH_P_BATMAN 0x4305 /* unofficial/not registered Ethertype */ -enum bat_packettype { - BAT_IV_OGM = 0x01, - BAT_ICMP = 0x02, - BAT_UNICAST = 0x03, - BAT_BCAST = 0x04, - BAT_VIS = 0x05, - BAT_UNICAST_FRAG = 0x06, - BAT_TT_QUERY = 0x07, - BAT_ROAM_ADV = 0x08 +enum batadv_packettype { + BATADV_IV_OGM = 0x01, + BATADV_ICMP = 0x02, + BATADV_UNICAST = 0x03, + BATADV_BCAST = 0x04, + BATADV_VIS = 0x05, + BATADV_UNICAST_FRAG = 0x06, + BATADV_TT_QUERY = 0x07, + BATADV_ROAM_ADV = 0x08, }; /* this file is included by batctl which needs these defines */ #define BATADV_COMPAT_VERSION 14 -enum batman_iv_flags { - NOT_BEST_NEXT_HOP = 1 << 3, - PRIMARIES_FIRST_HOP = 1 << 4, - VIS_SERVER = 1 << 5, - DIRECTLINK = 1 << 6 +enum batadv_iv_flags { + BATADV_NOT_BEST_NEXT_HOP = 1 << 3, + BATADV_PRIMARIES_FIRST_HOP = 1 << 4, + BATADV_VIS_SERVER = 1 << 5, + BATADV_DIRECTLINK = 1 << 6, }; /* ICMP message types */ -enum icmp_packettype { - ECHO_REPLY = 0, - DESTINATION_UNREACHABLE = 3, - ECHO_REQUEST = 8, - TTL_EXCEEDED = 11, - PARAMETER_PROBLEM = 12 +enum batadv_icmp_packettype { + BATADV_ECHO_REPLY = 0, + BATADV_DESTINATION_UNREACHABLE = 3, + BATADV_ECHO_REQUEST = 8, + BATADV_TTL_EXCEEDED = 11, + BATADV_PARAMETER_PROBLEM = 12, }; /* vis defines */ -enum vis_packettype { - VIS_TYPE_SERVER_SYNC = 0, - VIS_TYPE_CLIENT_UPDATE = 1 +enum batadv_vis_packettype { + BATADV_VIS_TYPE_SERVER_SYNC = 0, + BATADV_VIS_TYPE_CLIENT_UPDATE = 1, }; /* fragmentation defines */ -enum unicast_frag_flags { - UNI_FRAG_HEAD = 1 << 0, - UNI_FRAG_LARGETAIL = 1 << 1 +enum batadv_unicast_frag_flags { + BATADV_UNI_FRAG_HEAD = 1 << 0, + BATADV_UNI_FRAG_LARGETAIL = 1 << 1, }; /* TT_QUERY subtypes */ #define BATADV_TT_QUERY_TYPE_MASK 0x3 -enum tt_query_packettype { - TT_REQUEST = 0, - TT_RESPONSE = 1 +enum batadv_tt_query_packettype { + BATADV_TT_REQUEST = 0, + BATADV_TT_RESPONSE = 1, }; /* TT_QUERY flags */ -enum tt_query_flags { - TT_FULL_TABLE = 1 << 2 +enum batadv_tt_query_flags { + BATADV_TT_FULL_TABLE = 1 << 2, }; -/* TT_CLIENT flags. +/* BATADV_TT_CLIENT flags. * Flags from 1 to 1 << 7 are sent on the wire, while flags from 1 << 8 to * 1 << 15 are used for local computation only */ -enum tt_client_flags { - TT_CLIENT_DEL = 1 << 0, - TT_CLIENT_ROAM = 1 << 1, - TT_CLIENT_WIFI = 1 << 2, - TT_CLIENT_NOPURGE = 1 << 8, - TT_CLIENT_NEW = 1 << 9, - TT_CLIENT_PENDING = 1 << 10 +enum batadv_tt_client_flags { + BATADV_TT_CLIENT_DEL = 1 << 0, + BATADV_TT_CLIENT_ROAM = 1 << 1, + BATADV_TT_CLIENT_WIFI = 1 << 2, + BATADV_TT_CLIENT_NOPURGE = 1 << 8, + BATADV_TT_CLIENT_NEW = 1 << 9, + BATADV_TT_CLIENT_PENDING = 1 << 10, }; /* claim frame types for the bridge loop avoidance */ -enum bla_claimframe { - CLAIM_TYPE_ADD = 0x00, - CLAIM_TYPE_DEL = 0x01, - CLAIM_TYPE_ANNOUNCE = 0x02, - CLAIM_TYPE_REQUEST = 0x03 +enum batadv_bla_claimframe { + BATADV_CLAIM_TYPE_ADD = 0x00, + BATADV_CLAIM_TYPE_DEL = 0x01, + BATADV_CLAIM_TYPE_ANNOUNCE = 0x02, + BATADV_CLAIM_TYPE_REQUEST = 0x03, }; /* the destination hardware field in the ARP frame is used to * transport the claim type and the group id */ -struct bla_claim_dst { +struct batadv_bla_claim_dst { uint8_t magic[3]; /* FF:43:05 */ uint8_t type; /* bla_claimframe */ __be16 group; /* group id */ } __packed; -struct batman_header { +struct batadv_header { uint8_t packet_type; uint8_t version; /* batman version field */ uint8_t ttl; } __packed; -struct batman_ogm_packet { - struct batman_header header; +struct batadv_ogm_packet { + struct batadv_header header; uint8_t flags; /* 0x40: DIRECTLINK flag, 0x20 VIS_SERVER flag... */ __be32 seqno; uint8_t orig[ETH_ALEN]; @@ -126,10 +126,10 @@ struct batman_ogm_packet { __be16 tt_crc; } __packed; -#define BATADV_OGM_HLEN sizeof(struct batman_ogm_packet) +#define BATADV_OGM_HLEN sizeof(struct batadv_ogm_packet) -struct icmp_packet { - struct batman_header header; +struct batadv_icmp_packet { + struct batadv_header header; uint8_t msg_type; /* see ICMP message types above */ uint8_t dst[ETH_ALEN]; uint8_t orig[ETH_ALEN]; @@ -143,8 +143,8 @@ struct icmp_packet { /* icmp_packet_rr must start with all fields from imcp_packet * as this is assumed by code that handles ICMP packets */ -struct icmp_packet_rr { - struct batman_header header; +struct batadv_icmp_packet_rr { + struct batadv_header header; uint8_t msg_type; /* see ICMP message types above */ uint8_t dst[ETH_ALEN]; uint8_t orig[ETH_ALEN]; @@ -154,14 +154,14 @@ struct icmp_packet_rr { uint8_t rr[BATADV_RR_LEN][ETH_ALEN]; } __packed; -struct unicast_packet { - struct batman_header header; +struct batadv_unicast_packet { + struct batadv_header header; uint8_t ttvn; /* destination translation table version number */ uint8_t dest[ETH_ALEN]; } __packed; -struct unicast_frag_packet { - struct batman_header header; +struct batadv_unicast_frag_packet { + struct batadv_header header; uint8_t ttvn; /* destination translation table version number */ uint8_t dest[ETH_ALEN]; uint8_t flags; @@ -170,15 +170,15 @@ struct unicast_frag_packet { __be16 seqno; } __packed; -struct bcast_packet { - struct batman_header header; +struct batadv_bcast_packet { + struct batadv_header header; uint8_t reserved; __be32 seqno; uint8_t orig[ETH_ALEN]; } __packed; -struct vis_packet { - struct batman_header header; +struct batadv_vis_packet { + struct batadv_header header; uint8_t vis_type; /* which type of vis-participant sent this? */ __be32 seqno; /* sequence number */ uint8_t entries; /* number of entries behind this struct */ @@ -188,8 +188,8 @@ struct vis_packet { uint8_t sender_orig[ETH_ALEN]; /* who sent or forwarded this packet */ } __packed; -struct tt_query_packet { - struct batman_header header; +struct batadv_tt_query_packet { + struct batadv_header header; /* the flag field is a combination of: * - TT_REQUEST or TT_RESPONSE * - TT_FULL_TABLE @@ -212,15 +212,15 @@ struct tt_query_packet { __be16 tt_data; } __packed; -struct roam_adv_packet { - struct batman_header header; +struct batadv_roam_adv_packet { + struct batadv_header header; uint8_t reserved; uint8_t dst[ETH_ALEN]; uint8_t src[ETH_ALEN]; uint8_t client[ETH_ALEN]; } __packed; -struct tt_change { +struct batadv_tt_change { uint8_t flags; uint8_t addr[ETH_ALEN]; } __packed; diff --git a/net/batman-adv/routing.c b/net/batman-adv/routing.c index b3fd61c90f32..bc2b88bbea1f 100644 --- a/net/batman-adv/routing.c +++ b/net/batman-adv/routing.c @@ -30,15 +30,15 @@ #include "bridge_loop_avoidance.h" static int batadv_route_unicast_packet(struct sk_buff *skb, - struct hard_iface *recv_if); + struct batadv_hard_iface *recv_if); -void batadv_slide_own_bcast_window(struct hard_iface *hard_iface) +void batadv_slide_own_bcast_window(struct batadv_hard_iface *hard_iface) { - struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_node *node; struct hlist_head *head; - struct orig_node *orig_node; + struct batadv_orig_node *orig_node; unsigned long *word; uint32_t i; size_t word_index; @@ -62,30 +62,30 @@ void batadv_slide_own_bcast_window(struct hard_iface *hard_iface) } } -static void _batadv_update_route(struct bat_priv *bat_priv, - struct orig_node *orig_node, - struct neigh_node *neigh_node) +static void _batadv_update_route(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + struct batadv_neigh_node *neigh_node) { - struct neigh_node *curr_router; + struct batadv_neigh_node *curr_router; curr_router = batadv_orig_node_get_router(orig_node); /* route deleted */ if ((curr_router) && (!neigh_node)) { - batadv_dbg(DBG_ROUTES, bat_priv, "Deleting route towards: %pM\n", - orig_node->orig); + batadv_dbg(BATADV_DBG_ROUTES, bat_priv, + "Deleting route towards: %pM\n", orig_node->orig); batadv_tt_global_del_orig(bat_priv, orig_node, "Deleted route towards originator"); /* route added */ } else if ((!curr_router) && (neigh_node)) { - batadv_dbg(DBG_ROUTES, bat_priv, + batadv_dbg(BATADV_DBG_ROUTES, bat_priv, "Adding route towards: %pM (via %pM)\n", orig_node->orig, neigh_node->addr); /* route changed */ } else if (neigh_node && curr_router) { - batadv_dbg(DBG_ROUTES, bat_priv, + batadv_dbg(BATADV_DBG_ROUTES, bat_priv, "Changing route towards: %pM (now via %pM - was via %pM)\n", orig_node->orig, neigh_node->addr, curr_router->addr); @@ -107,10 +107,11 @@ static void _batadv_update_route(struct bat_priv *bat_priv, batadv_neigh_node_free_ref(curr_router); } -void batadv_update_route(struct bat_priv *bat_priv, struct orig_node *orig_node, - struct neigh_node *neigh_node) +void batadv_update_route(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + struct batadv_neigh_node *neigh_node) { - struct neigh_node *router = NULL; + struct batadv_neigh_node *router = NULL; if (!orig_node) goto out; @@ -126,8 +127,8 @@ out: } /* caller must hold the neigh_list_lock */ -void batadv_bonding_candidate_del(struct orig_node *orig_node, - struct neigh_node *neigh_node) +void batadv_bonding_candidate_del(struct batadv_orig_node *orig_node, + struct batadv_neigh_node *neigh_node) { /* this neighbor is not part of our candidate list */ if (list_empty(&neigh_node->bonding_list)) @@ -142,11 +143,11 @@ out: return; } -void batadv_bonding_candidate_add(struct orig_node *orig_node, - struct neigh_node *neigh_node) +void batadv_bonding_candidate_add(struct batadv_orig_node *orig_node, + struct batadv_neigh_node *neigh_node) { struct hlist_node *node; - struct neigh_node *tmp_neigh_node, *router = NULL; + struct batadv_neigh_node *tmp_neigh_node, *router = NULL; uint8_t interference_candidate = 0; spin_lock_bh(&orig_node->neigh_list_lock); @@ -215,11 +216,11 @@ out: /* copy primary address for bonding */ void -batadv_bonding_save_primary(const struct orig_node *orig_node, - struct orig_node *orig_neigh_node, - const struct batman_ogm_packet *batman_ogm_packet) +batadv_bonding_save_primary(const struct batadv_orig_node *orig_node, + struct batadv_orig_node *orig_neigh_node, + const struct batadv_ogm_packet *batman_ogm_packet) { - if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP)) + if (!(batman_ogm_packet->flags & BATADV_PRIMARIES_FIRST_HOP)) return; memcpy(orig_neigh_node->primary_addr, orig_node->orig, ETH_ALEN); @@ -230,7 +231,7 @@ batadv_bonding_save_primary(const struct orig_node *orig_node, * 0 if the packet is to be accepted * 1 if the packet is to be ignored. */ -int batadv_window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff, +int batadv_window_protected(struct batadv_priv *bat_priv, int32_t seq_num_diff, unsigned long *last_reset) { if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE || @@ -240,7 +241,7 @@ int batadv_window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff, return 1; *last_reset = jiffies; - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "old packet received, start protection\n"); } @@ -248,7 +249,7 @@ int batadv_window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff, } bool batadv_check_management_packet(struct sk_buff *skb, - struct hard_iface *hard_iface, + struct batadv_hard_iface *hard_iface, int header_len) { struct ethhdr *ethhdr; @@ -278,19 +279,19 @@ bool batadv_check_management_packet(struct sk_buff *skb, return true; } -static int batadv_recv_my_icmp_packet(struct bat_priv *bat_priv, +static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv, struct sk_buff *skb, size_t icmp_len) { - struct hard_iface *primary_if = NULL; - struct orig_node *orig_node = NULL; - struct neigh_node *router = NULL; - struct icmp_packet_rr *icmp_packet; + struct batadv_hard_iface *primary_if = NULL; + struct batadv_orig_node *orig_node = NULL; + struct batadv_neigh_node *router = NULL; + struct batadv_icmp_packet_rr *icmp_packet; int ret = NET_RX_DROP; - icmp_packet = (struct icmp_packet_rr *)skb->data; + icmp_packet = (struct batadv_icmp_packet_rr *)skb->data; /* add data to device queue */ - if (icmp_packet->msg_type != ECHO_REQUEST) { + if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) { batadv_socket_receive_packet(icmp_packet, icmp_len); goto out; } @@ -313,11 +314,11 @@ static int batadv_recv_my_icmp_packet(struct bat_priv *bat_priv, if (skb_cow(skb, ETH_HLEN) < 0) goto out; - icmp_packet = (struct icmp_packet_rr *)skb->data; + icmp_packet = (struct batadv_icmp_packet_rr *)skb->data; memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN); memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN); - icmp_packet->msg_type = ECHO_REPLY; + icmp_packet->msg_type = BATADV_ECHO_REPLY; icmp_packet->header.ttl = BATADV_TTL; batadv_send_skb_packet(skb, router->if_incoming, router->addr); @@ -333,19 +334,19 @@ out: return ret; } -static int batadv_recv_icmp_ttl_exceeded(struct bat_priv *bat_priv, +static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv, struct sk_buff *skb) { - struct hard_iface *primary_if = NULL; - struct orig_node *orig_node = NULL; - struct neigh_node *router = NULL; - struct icmp_packet *icmp_packet; + struct batadv_hard_iface *primary_if = NULL; + struct batadv_orig_node *orig_node = NULL; + struct batadv_neigh_node *router = NULL; + struct batadv_icmp_packet *icmp_packet; int ret = NET_RX_DROP; - icmp_packet = (struct icmp_packet *)skb->data; + icmp_packet = (struct batadv_icmp_packet *)skb->data; /* send TTL exceeded if packet is an echo request (traceroute) */ - if (icmp_packet->msg_type != ECHO_REQUEST) { + if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) { pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n", icmp_packet->orig, icmp_packet->dst); goto out; @@ -368,11 +369,11 @@ static int batadv_recv_icmp_ttl_exceeded(struct bat_priv *bat_priv, if (skb_cow(skb, ETH_HLEN) < 0) goto out; - icmp_packet = (struct icmp_packet *)skb->data; + icmp_packet = (struct batadv_icmp_packet *)skb->data; memcpy(icmp_packet->dst, icmp_packet->orig, ETH_ALEN); memcpy(icmp_packet->orig, primary_if->net_dev->dev_addr, ETH_ALEN); - icmp_packet->msg_type = TTL_EXCEEDED; + icmp_packet->msg_type = BATADV_TTL_EXCEEDED; icmp_packet->header.ttl = BATADV_TTL; batadv_send_skb_packet(skb, router->if_incoming, router->addr); @@ -389,19 +390,20 @@ out: } -int batadv_recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if) +int batadv_recv_icmp_packet(struct sk_buff *skb, + struct batadv_hard_iface *recv_if) { - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); - struct icmp_packet_rr *icmp_packet; + struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct batadv_icmp_packet_rr *icmp_packet; struct ethhdr *ethhdr; - struct orig_node *orig_node = NULL; - struct neigh_node *router = NULL; - int hdr_size = sizeof(struct icmp_packet); + struct batadv_orig_node *orig_node = NULL; + struct batadv_neigh_node *router = NULL; + int hdr_size = sizeof(struct batadv_icmp_packet); int ret = NET_RX_DROP; /* we truncate all incoming icmp packets if they don't match our size */ - if (skb->len >= sizeof(struct icmp_packet_rr)) - hdr_size = sizeof(struct icmp_packet_rr); + if (skb->len >= sizeof(struct batadv_icmp_packet_rr)) + hdr_size = sizeof(struct batadv_icmp_packet_rr); /* drop packet if it has not necessary minimum size */ if (unlikely(!pskb_may_pull(skb, hdr_size))) @@ -421,10 +423,10 @@ int batadv_recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if) if (!batadv_is_my_mac(ethhdr->h_dest)) goto out; - icmp_packet = (struct icmp_packet_rr *)skb->data; + icmp_packet = (struct batadv_icmp_packet_rr *)skb->data; /* add record route information if not full */ - if ((hdr_size == sizeof(struct icmp_packet_rr)) && + if ((hdr_size == sizeof(struct batadv_icmp_packet_rr)) && (icmp_packet->rr_cur < BATADV_RR_LEN)) { memcpy(&(icmp_packet->rr[icmp_packet->rr_cur]), ethhdr->h_dest, ETH_ALEN); @@ -452,7 +454,7 @@ int batadv_recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if) if (skb_cow(skb, ETH_HLEN) < 0) goto out; - icmp_packet = (struct icmp_packet_rr *)skb->data; + icmp_packet = (struct batadv_icmp_packet_rr *)skb->data; /* decrement ttl */ icmp_packet->header.ttl--; @@ -475,12 +477,12 @@ out: * This method rotates the bonding list and increases the * returned router's refcount. */ -static struct neigh_node * -batadv_find_bond_router(struct orig_node *primary_orig, - const struct hard_iface *recv_if) +static struct batadv_neigh_node * +batadv_find_bond_router(struct batadv_orig_node *primary_orig, + const struct batadv_hard_iface *recv_if) { - struct neigh_node *tmp_neigh_node; - struct neigh_node *router = NULL, *first_candidate = NULL; + struct batadv_neigh_node *tmp_neigh_node; + struct batadv_neigh_node *router = NULL, *first_candidate = NULL; rcu_read_lock(); list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list, @@ -530,12 +532,12 @@ out: * * Increases the returned router's refcount */ -static struct neigh_node * -batadv_find_ifalter_router(struct orig_node *primary_orig, - const struct hard_iface *recv_if) +static struct batadv_neigh_node * +batadv_find_ifalter_router(struct batadv_orig_node *primary_orig, + const struct batadv_hard_iface *recv_if) { - struct neigh_node *tmp_neigh_node; - struct neigh_node *router = NULL, *first_candidate = NULL; + struct batadv_neigh_node *tmp_neigh_node; + struct batadv_neigh_node *router = NULL, *first_candidate = NULL; rcu_read_lock(); list_for_each_entry_rcu(tmp_neigh_node, &primary_orig->bond_list, @@ -577,20 +579,22 @@ batadv_find_ifalter_router(struct orig_node *primary_orig, return router; } -int batadv_recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if) +int batadv_recv_tt_query(struct sk_buff *skb, struct batadv_hard_iface *recv_if) { - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); - struct tt_query_packet *tt_query; + struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct batadv_tt_query_packet *tt_query; uint16_t tt_size; struct ethhdr *ethhdr; char tt_flag; + size_t packet_size; /* drop packet if it has not necessary minimum size */ - if (unlikely(!pskb_may_pull(skb, sizeof(struct tt_query_packet)))) + if (unlikely(!pskb_may_pull(skb, + sizeof(struct batadv_tt_query_packet)))) goto out; /* I could need to modify it */ - if (skb_cow(skb, sizeof(struct tt_query_packet)) < 0) + if (skb_cow(skb, sizeof(struct batadv_tt_query_packet)) < 0) goto out; ethhdr = (struct ethhdr *)skb_mac_header(skb); @@ -603,26 +607,30 @@ int batadv_recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if) if (is_broadcast_ether_addr(ethhdr->h_source)) goto out; - tt_query = (struct tt_query_packet *)skb->data; + tt_query = (struct batadv_tt_query_packet *)skb->data; switch (tt_query->flags & BATADV_TT_QUERY_TYPE_MASK) { - case TT_REQUEST: - batadv_inc_counter(bat_priv, BAT_CNT_TT_REQUEST_RX); + case BATADV_TT_REQUEST: + batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX); /* If we cannot provide an answer the tt_request is * forwarded */ if (!batadv_send_tt_response(bat_priv, tt_query)) { - tt_flag = tt_query->flags & TT_FULL_TABLE ? 'F' : '.'; - batadv_dbg(DBG_TT, bat_priv, + if (tt_query->flags & BATADV_TT_FULL_TABLE) + tt_flag = 'F'; + else + tt_flag = '.'; + + batadv_dbg(BATADV_DBG_TT, bat_priv, "Routing TT_REQUEST to %pM [%c]\n", tt_query->dst, tt_flag); return batadv_route_unicast_packet(skb, recv_if); } break; - case TT_RESPONSE: - batadv_inc_counter(bat_priv, BAT_CNT_TT_RESPONSE_RX); + case BATADV_TT_RESPONSE: + batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX); if (batadv_is_my_mac(tt_query->dst)) { /* packet needs to be linearized to access the TT @@ -631,19 +639,23 @@ int batadv_recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if) if (skb_linearize(skb) < 0) goto out; /* skb_linearize() possibly changed skb->data */ - tt_query = (struct tt_query_packet *)skb->data; + tt_query = (struct batadv_tt_query_packet *)skb->data; tt_size = batadv_tt_len(ntohs(tt_query->tt_data)); /* Ensure we have all the claimed data */ - if (unlikely(skb_headlen(skb) < - sizeof(struct tt_query_packet) + tt_size)) + packet_size = sizeof(struct batadv_tt_query_packet); + packet_size += tt_size; + if (unlikely(skb_headlen(skb) < packet_size)) goto out; batadv_handle_tt_response(bat_priv, tt_query); } else { - tt_flag = tt_query->flags & TT_FULL_TABLE ? 'F' : '.'; - batadv_dbg(DBG_TT, bat_priv, + if (tt_query->flags & BATADV_TT_FULL_TABLE) + tt_flag = 'F'; + else + tt_flag = '.'; + batadv_dbg(BATADV_DBG_TT, bat_priv, "Routing TT_RESPONSE to %pM [%c]\n", tt_query->dst, tt_flag); @@ -657,15 +669,16 @@ out: return NET_RX_DROP; } -int batadv_recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if) +int batadv_recv_roam_adv(struct sk_buff *skb, struct batadv_hard_iface *recv_if) { - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); - struct roam_adv_packet *roam_adv_packet; - struct orig_node *orig_node; + struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct batadv_roam_adv_packet *roam_adv_packet; + struct batadv_orig_node *orig_node; struct ethhdr *ethhdr; /* drop packet if it has not necessary minimum size */ - if (unlikely(!pskb_may_pull(skb, sizeof(struct roam_adv_packet)))) + if (unlikely(!pskb_may_pull(skb, + sizeof(struct batadv_roam_adv_packet)))) goto out; ethhdr = (struct ethhdr *)skb_mac_header(skb); @@ -678,9 +691,9 @@ int batadv_recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if) if (is_broadcast_ether_addr(ethhdr->h_source)) goto out; - batadv_inc_counter(bat_priv, BAT_CNT_TT_ROAM_ADV_RX); + batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX); - roam_adv_packet = (struct roam_adv_packet *)skb->data; + roam_adv_packet = (struct batadv_roam_adv_packet *)skb->data; if (!batadv_is_my_mac(roam_adv_packet->dst)) return batadv_route_unicast_packet(skb, recv_if); @@ -696,12 +709,12 @@ int batadv_recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if) if (!orig_node) goto out; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Received ROAMING_ADV from %pM (client %pM)\n", roam_adv_packet->src, roam_adv_packet->client); batadv_tt_global_add(bat_priv, orig_node, roam_adv_packet->client, - TT_CLIENT_ROAM, + BATADV_TT_CLIENT_ROAM, atomic_read(&orig_node->last_ttvn) + 1); /* Roaming phase starts: I have new information but the ttvn has not @@ -720,13 +733,14 @@ out: * bonding if possible. increases the found neighbors * refcount. */ -struct neigh_node *batadv_find_router(struct bat_priv *bat_priv, - struct orig_node *orig_node, - const struct hard_iface *recv_if) +struct batadv_neigh_node * +batadv_find_router(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + const struct batadv_hard_iface *recv_if) { - struct orig_node *primary_orig_node; - struct orig_node *router_orig; - struct neigh_node *router; + struct batadv_orig_node *primary_orig_node; + struct batadv_orig_node *router_orig; + struct batadv_neigh_node *router; static uint8_t zero_mac[ETH_ALEN] = {0, 0, 0, 0, 0, 0}; int bonding_enabled; uint8_t *primary_addr; @@ -792,7 +806,7 @@ struct neigh_node *batadv_find_router(struct bat_priv *bat_priv, router = batadv_find_ifalter_router(primary_orig_node, recv_if); return_router: - if (router && router->if_incoming->if_status != IF_ACTIVE) + if (router && router->if_incoming->if_status != BATADV_IF_ACTIVE) goto err_unlock; rcu_read_unlock(); @@ -831,17 +845,17 @@ static int batadv_check_unicast_packet(struct sk_buff *skb, int hdr_size) } static int batadv_route_unicast_packet(struct sk_buff *skb, - struct hard_iface *recv_if) + struct batadv_hard_iface *recv_if) { - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); - struct orig_node *orig_node = NULL; - struct neigh_node *neigh_node = NULL; - struct unicast_packet *unicast_packet; + struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct batadv_orig_node *orig_node = NULL; + struct batadv_neigh_node *neigh_node = NULL; + struct batadv_unicast_packet *unicast_packet; struct ethhdr *ethhdr = (struct ethhdr *)skb_mac_header(skb); int ret = NET_RX_DROP; struct sk_buff *new_skb; - unicast_packet = (struct unicast_packet *)skb->data; + unicast_packet = (struct batadv_unicast_packet *)skb->data; /* TTL exceeded */ if (unicast_packet->header.ttl < 2) { @@ -866,9 +880,9 @@ static int batadv_route_unicast_packet(struct sk_buff *skb, if (skb_cow(skb, ETH_HLEN) < 0) goto out; - unicast_packet = (struct unicast_packet *)skb->data; + unicast_packet = (struct batadv_unicast_packet *)skb->data; - if (unicast_packet->header.packet_type == BAT_UNICAST && + if (unicast_packet->header.packet_type == BATADV_UNICAST && atomic_read(&bat_priv->fragmentation) && skb->len > neigh_node->if_incoming->net_dev->mtu) { ret = batadv_frag_send_skb(skb, bat_priv, @@ -877,7 +891,7 @@ static int batadv_route_unicast_packet(struct sk_buff *skb, goto out; } - if (unicast_packet->header.packet_type == BAT_UNICAST_FRAG && + if (unicast_packet->header.packet_type == BATADV_UNICAST_FRAG && batadv_frag_can_reassemble(skb, neigh_node->if_incoming->net_dev->mtu)) { @@ -893,15 +907,15 @@ static int batadv_route_unicast_packet(struct sk_buff *skb, } skb = new_skb; - unicast_packet = (struct unicast_packet *)skb->data; + unicast_packet = (struct batadv_unicast_packet *)skb->data; } /* decrement ttl */ unicast_packet->header.ttl--; /* Update stats counter */ - batadv_inc_counter(bat_priv, BAT_CNT_FORWARD); - batadv_add_counter(bat_priv, BAT_CNT_FORWARD_BYTES, + batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD); + batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES, skb->len + ETH_HLEN); /* route it */ @@ -916,21 +930,21 @@ out: return ret; } -static int batadv_check_unicast_ttvn(struct bat_priv *bat_priv, +static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv, struct sk_buff *skb) { uint8_t curr_ttvn; - struct orig_node *orig_node; + struct batadv_orig_node *orig_node; struct ethhdr *ethhdr; - struct hard_iface *primary_if; - struct unicast_packet *unicast_packet; + struct batadv_hard_iface *primary_if; + struct batadv_unicast_packet *unicast_packet; bool tt_poss_change; int is_old_ttvn; /* I could need to modify it */ - if (skb_cow(skb, sizeof(struct unicast_packet)) < 0) + if (skb_cow(skb, sizeof(struct batadv_unicast_packet)) < 0) return 0; - unicast_packet = (struct unicast_packet *)skb->data; + unicast_packet = (struct batadv_unicast_packet *)skb->data; if (batadv_is_my_mac(unicast_packet->dest)) { tt_poss_change = bat_priv->tt_poss_change; @@ -951,12 +965,11 @@ static int batadv_check_unicast_ttvn(struct bat_priv *bat_priv, is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn); if (is_old_ttvn || tt_poss_change) { /* check if there is enough data before accessing it */ - if (pskb_may_pull(skb, sizeof(struct unicast_packet) + + if (pskb_may_pull(skb, sizeof(struct batadv_unicast_packet) + ETH_HLEN) < 0) return 0; - ethhdr = (struct ethhdr *)(skb->data + - sizeof(struct unicast_packet)); + ethhdr = (struct ethhdr *)(skb->data + sizeof(*unicast_packet)); /* we don't have an updated route for this client, so we should * not try to reroute the packet!! @@ -985,7 +998,7 @@ static int batadv_check_unicast_ttvn(struct bat_priv *bat_priv, batadv_orig_node_free_ref(orig_node); } - batadv_dbg(DBG_ROUTES, bat_priv, + batadv_dbg(BATADV_DBG_ROUTES, bat_priv, "TTVN mismatch (old_ttvn %u new_ttvn %u)! Rerouting unicast packet (for %pM) to %pM\n", unicast_packet->ttvn, curr_ttvn, ethhdr->h_dest, unicast_packet->dest); @@ -995,10 +1008,11 @@ static int batadv_check_unicast_ttvn(struct bat_priv *bat_priv, return 1; } -int batadv_recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) +int batadv_recv_unicast_packet(struct sk_buff *skb, + struct batadv_hard_iface *recv_if) { - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); - struct unicast_packet *unicast_packet; + struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct batadv_unicast_packet *unicast_packet; int hdr_size = sizeof(*unicast_packet); if (batadv_check_unicast_packet(skb, hdr_size) < 0) @@ -1007,7 +1021,7 @@ int batadv_recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) if (!batadv_check_unicast_ttvn(bat_priv, skb)) return NET_RX_DROP; - unicast_packet = (struct unicast_packet *)skb->data; + unicast_packet = (struct batadv_unicast_packet *)skb->data; /* packet for me */ if (batadv_is_my_mac(unicast_packet->dest)) { @@ -1020,10 +1034,10 @@ int batadv_recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if) } int batadv_recv_ucast_frag_packet(struct sk_buff *skb, - struct hard_iface *recv_if) + struct batadv_hard_iface *recv_if) { - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); - struct unicast_frag_packet *unicast_packet; + struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct batadv_unicast_frag_packet *unicast_packet; int hdr_size = sizeof(*unicast_packet); struct sk_buff *new_skb = NULL; int ret; @@ -1034,7 +1048,7 @@ int batadv_recv_ucast_frag_packet(struct sk_buff *skb, if (!batadv_check_unicast_ttvn(bat_priv, skb)) return NET_RX_DROP; - unicast_packet = (struct unicast_frag_packet *)skb->data; + unicast_packet = (struct batadv_unicast_frag_packet *)skb->data; /* packet for me */ if (batadv_is_my_mac(unicast_packet->dest)) { @@ -1049,7 +1063,7 @@ int batadv_recv_ucast_frag_packet(struct sk_buff *skb, return NET_RX_SUCCESS; batadv_interface_rx(recv_if->soft_iface, new_skb, recv_if, - sizeof(struct unicast_packet)); + sizeof(struct batadv_unicast_packet)); return NET_RX_SUCCESS; } @@ -1057,11 +1071,12 @@ int batadv_recv_ucast_frag_packet(struct sk_buff *skb, } -int batadv_recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if) +int batadv_recv_bcast_packet(struct sk_buff *skb, + struct batadv_hard_iface *recv_if) { - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); - struct orig_node *orig_node = NULL; - struct bcast_packet *bcast_packet; + struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct batadv_orig_node *orig_node = NULL; + struct batadv_bcast_packet *bcast_packet; struct ethhdr *ethhdr; int hdr_size = sizeof(*bcast_packet); int ret = NET_RX_DROP; @@ -1085,7 +1100,7 @@ int batadv_recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if) if (batadv_is_my_mac(ethhdr->h_source)) goto out; - bcast_packet = (struct bcast_packet *)skb->data; + bcast_packet = (struct batadv_bcast_packet *)skb->data; /* ignore broadcasts originated by myself */ if (batadv_is_my_mac(bcast_packet->orig)) @@ -1147,11 +1162,12 @@ out: return ret; } -int batadv_recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if) +int batadv_recv_vis_packet(struct sk_buff *skb, + struct batadv_hard_iface *recv_if) { - struct vis_packet *vis_packet; + struct batadv_vis_packet *vis_packet; struct ethhdr *ethhdr; - struct bat_priv *bat_priv = netdev_priv(recv_if->soft_iface); + struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface); int hdr_size = sizeof(*vis_packet); /* keep skb linear */ @@ -1161,7 +1177,7 @@ int batadv_recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if) if (unlikely(!pskb_may_pull(skb, hdr_size))) return NET_RX_DROP; - vis_packet = (struct vis_packet *)skb->data; + vis_packet = (struct batadv_vis_packet *)skb->data; ethhdr = (struct ethhdr *)skb_mac_header(skb); /* not for me */ @@ -1176,12 +1192,12 @@ int batadv_recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if) return NET_RX_DROP; switch (vis_packet->vis_type) { - case VIS_TYPE_SERVER_SYNC: + case BATADV_VIS_TYPE_SERVER_SYNC: batadv_receive_server_sync_packet(bat_priv, vis_packet, skb_headlen(skb)); break; - case VIS_TYPE_CLIENT_UPDATE: + case BATADV_VIS_TYPE_CLIENT_UPDATE: batadv_receive_client_update_packet(bat_priv, vis_packet, skb_headlen(skb)); break; diff --git a/net/batman-adv/routing.h b/net/batman-adv/routing.h index c3fd219e8e53..9262279ea667 100644 --- a/net/batman-adv/routing.h +++ b/net/batman-adv/routing.h @@ -20,32 +20,40 @@ #ifndef _NET_BATMAN_ADV_ROUTING_H_ #define _NET_BATMAN_ADV_ROUTING_H_ -void batadv_slide_own_bcast_window(struct hard_iface *hard_iface); +void batadv_slide_own_bcast_window(struct batadv_hard_iface *hard_iface); bool batadv_check_management_packet(struct sk_buff *skb, - struct hard_iface *hard_iface, + struct batadv_hard_iface *hard_iface, int header_len); -void batadv_update_route(struct bat_priv *bat_priv, struct orig_node *orig_node, - struct neigh_node *neigh_node); -int batadv_recv_icmp_packet(struct sk_buff *skb, struct hard_iface *recv_if); -int batadv_recv_unicast_packet(struct sk_buff *skb, struct hard_iface *recv_if); +void batadv_update_route(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + struct batadv_neigh_node *neigh_node); +int batadv_recv_icmp_packet(struct sk_buff *skb, + struct batadv_hard_iface *recv_if); +int batadv_recv_unicast_packet(struct sk_buff *skb, + struct batadv_hard_iface *recv_if); int batadv_recv_ucast_frag_packet(struct sk_buff *skb, - struct hard_iface *recv_if); -int batadv_recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if); -int batadv_recv_vis_packet(struct sk_buff *skb, struct hard_iface *recv_if); -int batadv_recv_tt_query(struct sk_buff *skb, struct hard_iface *recv_if); -int batadv_recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if); -struct neigh_node *batadv_find_router(struct bat_priv *bat_priv, - struct orig_node *orig_node, - const struct hard_iface *recv_if); -void batadv_bonding_candidate_del(struct orig_node *orig_node, - struct neigh_node *neigh_node); -void batadv_bonding_candidate_add(struct orig_node *orig_node, - struct neigh_node *neigh_node); -void batadv_bonding_save_primary(const struct orig_node *orig_node, - struct orig_node *orig_neigh_node, - const struct batman_ogm_packet + struct batadv_hard_iface *recv_if); +int batadv_recv_bcast_packet(struct sk_buff *skb, + struct batadv_hard_iface *recv_if); +int batadv_recv_vis_packet(struct sk_buff *skb, + struct batadv_hard_iface *recv_if); +int batadv_recv_tt_query(struct sk_buff *skb, + struct batadv_hard_iface *recv_if); +int batadv_recv_roam_adv(struct sk_buff *skb, + struct batadv_hard_iface *recv_if); +struct batadv_neigh_node * +batadv_find_router(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + const struct batadv_hard_iface *recv_if); +void batadv_bonding_candidate_del(struct batadv_orig_node *orig_node, + struct batadv_neigh_node *neigh_node); +void batadv_bonding_candidate_add(struct batadv_orig_node *orig_node, + struct batadv_neigh_node *neigh_node); +void batadv_bonding_save_primary(const struct batadv_orig_node *orig_node, + struct batadv_orig_node *orig_neigh_node, + const struct batadv_ogm_packet *batman_ogm_packet); -int batadv_window_protected(struct bat_priv *bat_priv, int32_t seq_num_diff, +int batadv_window_protected(struct batadv_priv *bat_priv, int32_t seq_num_diff, unsigned long *last_reset); #endif /* _NET_BATMAN_ADV_ROUTING_H_ */ diff --git a/net/batman-adv/send.c b/net/batman-adv/send.c index 72542cb01662..3b4b2daa3b3e 100644 --- a/net/batman-adv/send.c +++ b/net/batman-adv/send.c @@ -32,12 +32,13 @@ static void batadv_send_outstanding_bcast_packet(struct work_struct *work); /* send out an already prepared packet to the given address via the * specified batman interface */ -int batadv_send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface, +int batadv_send_skb_packet(struct sk_buff *skb, + struct batadv_hard_iface *hard_iface, const uint8_t *dst_addr) { struct ethhdr *ethhdr; - if (hard_iface->if_status != IF_ACTIVE) + if (hard_iface->if_status != BATADV_IF_ACTIVE) goto send_skb_err; if (unlikely(!hard_iface->net_dev)) @@ -76,12 +77,12 @@ send_skb_err: return NET_XMIT_DROP; } -void batadv_schedule_bat_ogm(struct hard_iface *hard_iface) +void batadv_schedule_bat_ogm(struct batadv_hard_iface *hard_iface) { - struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); + struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); - if ((hard_iface->if_status == IF_NOT_IN_USE) || - (hard_iface->if_status == IF_TO_BE_REMOVED)) + if ((hard_iface->if_status == BATADV_IF_NOT_IN_USE) || + (hard_iface->if_status == BATADV_IF_TO_BE_REMOVED)) return; /* the interface gets activated here to avoid race conditions between @@ -90,13 +91,13 @@ void batadv_schedule_bat_ogm(struct hard_iface *hard_iface) * outdated packets (especially uninitialized mac addresses) in the * packet queue */ - if (hard_iface->if_status == IF_TO_BE_ACTIVATED) - hard_iface->if_status = IF_ACTIVE; + if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED) + hard_iface->if_status = BATADV_IF_ACTIVE; bat_priv->bat_algo_ops->bat_ogm_schedule(hard_iface); } -static void batadv_forw_packet_free(struct forw_packet *forw_packet) +static void batadv_forw_packet_free(struct batadv_forw_packet *forw_packet) { if (forw_packet->skb) kfree_skb(forw_packet->skb); @@ -105,9 +106,10 @@ static void batadv_forw_packet_free(struct forw_packet *forw_packet) kfree(forw_packet); } -static void _batadv_add_bcast_packet_to_list(struct bat_priv *bat_priv, - struct forw_packet *forw_packet, - unsigned long send_time) +static void +_batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv, + struct batadv_forw_packet *forw_packet, + unsigned long send_time) { INIT_HLIST_NODE(&forw_packet->list); @@ -132,17 +134,18 @@ static void _batadv_add_bcast_packet_to_list(struct bat_priv *bat_priv, * The skb is not consumed, so the caller should make sure that the * skb is freed. */ -int batadv_add_bcast_packet_to_list(struct bat_priv *bat_priv, +int batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv, const struct sk_buff *skb, unsigned long delay) { - struct hard_iface *primary_if = NULL; - struct forw_packet *forw_packet; - struct bcast_packet *bcast_packet; + struct batadv_hard_iface *primary_if = NULL; + struct batadv_forw_packet *forw_packet; + struct batadv_bcast_packet *bcast_packet; struct sk_buff *newskb; if (!batadv_atomic_dec_not_zero(&bat_priv->bcast_queue_left)) { - batadv_dbg(DBG_BATMAN, bat_priv, "bcast packet queue full\n"); + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, + "bcast packet queue full\n"); goto out; } @@ -160,7 +163,7 @@ int batadv_add_bcast_packet_to_list(struct bat_priv *bat_priv, goto packet_free; /* as we have a copy now, it is safe to decrease the TTL */ - bcast_packet = (struct bcast_packet *)newskb->data; + bcast_packet = (struct batadv_bcast_packet *)newskb->data; bcast_packet->header.ttl--; skb_reset_mac_header(newskb); @@ -186,20 +189,24 @@ out: static void batadv_send_outstanding_bcast_packet(struct work_struct *work) { - struct hard_iface *hard_iface; + struct batadv_hard_iface *hard_iface; struct delayed_work *delayed_work = container_of(work, struct delayed_work, work); - struct forw_packet *forw_packet = - container_of(delayed_work, struct forw_packet, delayed_work); + struct batadv_forw_packet *forw_packet; struct sk_buff *skb1; - struct net_device *soft_iface = forw_packet->if_incoming->soft_iface; - struct bat_priv *bat_priv = netdev_priv(soft_iface); + struct net_device *soft_iface; + struct batadv_priv *bat_priv; + + forw_packet = container_of(delayed_work, struct batadv_forw_packet, + delayed_work); + soft_iface = forw_packet->if_incoming->soft_iface; + bat_priv = netdev_priv(soft_iface); spin_lock_bh(&bat_priv->forw_bcast_list_lock); hlist_del(&forw_packet->list); spin_unlock_bh(&bat_priv->forw_bcast_list_lock); - if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING) + if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) goto out; /* rebroadcast packet */ @@ -234,16 +241,17 @@ void batadv_send_outstanding_bat_ogm_packet(struct work_struct *work) { struct delayed_work *delayed_work = container_of(work, struct delayed_work, work); - struct forw_packet *forw_packet = - container_of(delayed_work, struct forw_packet, delayed_work); - struct bat_priv *bat_priv; + struct batadv_forw_packet *forw_packet; + struct batadv_priv *bat_priv; + forw_packet = container_of(delayed_work, struct batadv_forw_packet, + delayed_work); bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface); spin_lock_bh(&bat_priv->forw_bat_list_lock); hlist_del(&forw_packet->list); spin_unlock_bh(&bat_priv->forw_bat_list_lock); - if (atomic_read(&bat_priv->mesh_state) == MESH_DEACTIVATING) + if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) goto out; bat_priv->bat_algo_ops->bat_ogm_emit(forw_packet); @@ -263,19 +271,20 @@ out: batadv_forw_packet_free(forw_packet); } -void batadv_purge_outstanding_packets(struct bat_priv *bat_priv, - const struct hard_iface *hard_iface) +void +batadv_purge_outstanding_packets(struct batadv_priv *bat_priv, + const struct batadv_hard_iface *hard_iface) { - struct forw_packet *forw_packet; + struct batadv_forw_packet *forw_packet; struct hlist_node *tmp_node, *safe_tmp_node; bool pending; if (hard_iface) - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "purge_outstanding_packets(): %s\n", hard_iface->net_dev->name); else - batadv_dbg(DBG_BATMAN, bat_priv, + batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "purge_outstanding_packets()\n"); /* free bcast list */ diff --git a/net/batman-adv/send.h b/net/batman-adv/send.h index e3ac75ba432b..643329b787ed 100644 --- a/net/batman-adv/send.h +++ b/net/batman-adv/send.h @@ -20,14 +20,16 @@ #ifndef _NET_BATMAN_ADV_SEND_H_ #define _NET_BATMAN_ADV_SEND_H_ -int batadv_send_skb_packet(struct sk_buff *skb, struct hard_iface *hard_iface, +int batadv_send_skb_packet(struct sk_buff *skb, + struct batadv_hard_iface *hard_iface, const uint8_t *dst_addr); -void batadv_schedule_bat_ogm(struct hard_iface *hard_iface); -int batadv_add_bcast_packet_to_list(struct bat_priv *bat_priv, +void batadv_schedule_bat_ogm(struct batadv_hard_iface *hard_iface); +int batadv_add_bcast_packet_to_list(struct batadv_priv *bat_priv, const struct sk_buff *skb, unsigned long delay); void batadv_send_outstanding_bat_ogm_packet(struct work_struct *work); -void batadv_purge_outstanding_packets(struct bat_priv *bat_priv, - const struct hard_iface *hard_iface); +void +batadv_purge_outstanding_packets(struct batadv_priv *bat_priv, + const struct batadv_hard_iface *hard_iface); #endif /* _NET_BATMAN_ADV_SEND_H_ */ diff --git a/net/batman-adv/soft-interface.c b/net/batman-adv/soft-interface.c index c1b2ab2f37bb..9e4bb61301ec 100644 --- a/net/batman-adv/soft-interface.c +++ b/net/batman-adv/soft-interface.c @@ -22,12 +22,12 @@ #include "hard-interface.h" #include "routing.h" #include "send.h" -#include "bat_debugfs.h" +#include "debugfs.h" #include "translation-table.h" #include "hash.h" #include "gateway_common.h" #include "gateway_client.h" -#include "bat_sysfs.h" +#include "sysfs.h" #include "originator.h" #include <linux/slab.h> #include <linux/ethtool.h> @@ -92,20 +92,20 @@ static int batadv_interface_release(struct net_device *dev) static struct net_device_stats *batadv_interface_stats(struct net_device *dev) { - struct bat_priv *bat_priv = netdev_priv(dev); + struct batadv_priv *bat_priv = netdev_priv(dev); return &bat_priv->stats; } static int batadv_interface_set_mac_addr(struct net_device *dev, void *p) { - struct bat_priv *bat_priv = netdev_priv(dev); + struct batadv_priv *bat_priv = netdev_priv(dev); struct sockaddr *addr = p; if (!is_valid_ether_addr(addr->sa_data)) return -EADDRNOTAVAIL; /* only modify transtable if it has been initialized before */ - if (atomic_read(&bat_priv->mesh_state) == MESH_ACTIVE) { + if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) { batadv_tt_local_remove(bat_priv, dev->dev_addr, "mac address changed", false); batadv_tt_local_add(dev, addr->sa_data, BATADV_NULL_IFINDEX); @@ -131,9 +131,9 @@ static int batadv_interface_tx(struct sk_buff *skb, struct net_device *soft_iface) { struct ethhdr *ethhdr = (struct ethhdr *)skb->data; - struct bat_priv *bat_priv = netdev_priv(soft_iface); - struct hard_iface *primary_if = NULL; - struct bcast_packet *bcast_packet; + struct batadv_priv *bat_priv = netdev_priv(soft_iface); + struct batadv_hard_iface *primary_if = NULL; + struct batadv_bcast_packet *bcast_packet; struct vlan_ethhdr *vhdr; __be16 ethertype = __constant_htons(BATADV_ETH_P_BATMAN); static const uint8_t stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00, 0x00, @@ -143,7 +143,7 @@ static int batadv_interface_tx(struct sk_buff *skb, short vid __maybe_unused = -1; bool do_bcast = false; - if (atomic_read(&bat_priv->mesh_state) != MESH_ACTIVE) + if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE) goto dropped; soft_iface->trans_start = jiffies; @@ -177,7 +177,7 @@ static int batadv_interface_tx(struct sk_buff *skb, do_bcast = true; switch (atomic_read(&bat_priv->gw_mode)) { - case GW_MODE_SERVER: + case BATADV_GW_MODE_SERVER: /* gateway servers should not send dhcp * requests into the mesh */ @@ -185,7 +185,7 @@ static int batadv_interface_tx(struct sk_buff *skb, if (ret) goto dropped; break; - case GW_MODE_CLIENT: + case BATADV_GW_MODE_CLIENT: /* gateway clients should send dhcp requests * via unicast to their gateway */ @@ -193,7 +193,7 @@ static int batadv_interface_tx(struct sk_buff *skb, if (ret) do_bcast = false; break; - case GW_MODE_OFF: + case BATADV_GW_MODE_OFF: default: break; } @@ -208,12 +208,13 @@ static int batadv_interface_tx(struct sk_buff *skb, if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0) goto dropped; - bcast_packet = (struct bcast_packet *)skb->data; + bcast_packet = (struct batadv_bcast_packet *)skb->data; bcast_packet->header.version = BATADV_COMPAT_VERSION; bcast_packet->header.ttl = BATADV_TTL; /* batman packet type: broadcast */ - bcast_packet->header.packet_type = BAT_BCAST; + bcast_packet->header.packet_type = BATADV_BCAST; + bcast_packet->reserved = 0; /* hw address of first interface is the orig mac because only * this mac is known throughout the mesh @@ -234,7 +235,7 @@ static int batadv_interface_tx(struct sk_buff *skb, /* unicast packet */ } else { - if (atomic_read(&bat_priv->gw_mode) != GW_MODE_OFF) { + if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_OFF) { ret = batadv_gw_out_of_range(bat_priv, skb, ethhdr); if (ret) goto dropped; @@ -260,10 +261,10 @@ end: } void batadv_interface_rx(struct net_device *soft_iface, - struct sk_buff *skb, struct hard_iface *recv_if, + struct sk_buff *skb, struct batadv_hard_iface *recv_if, int hdr_size) { - struct bat_priv *bat_priv = netdev_priv(soft_iface); + struct batadv_priv *bat_priv = netdev_priv(soft_iface); struct ethhdr *ethhdr; struct vlan_ethhdr *vhdr; short vid __maybe_unused = -1; @@ -338,7 +339,7 @@ static const struct net_device_ops batadv_netdev_ops = { static void batadv_interface_setup(struct net_device *dev) { - struct bat_priv *priv = netdev_priv(dev); + struct batadv_priv *priv = netdev_priv(dev); ether_setup(dev); @@ -364,8 +365,9 @@ static void batadv_interface_setup(struct net_device *dev) struct net_device *batadv_softif_create(const char *name) { struct net_device *soft_iface; - struct bat_priv *bat_priv; + struct batadv_priv *bat_priv; int ret; + size_t cnt_len = sizeof(uint64_t) * BATADV_CNT_NUM; soft_iface = alloc_netdev(sizeof(*bat_priv), name, batadv_interface_setup); @@ -386,8 +388,8 @@ struct net_device *batadv_softif_create(const char *name) atomic_set(&bat_priv->bonding, 0); atomic_set(&bat_priv->bridge_loop_avoidance, 0); atomic_set(&bat_priv->ap_isolation, 0); - atomic_set(&bat_priv->vis_mode, VIS_TYPE_CLIENT_UPDATE); - atomic_set(&bat_priv->gw_mode, GW_MODE_OFF); + atomic_set(&bat_priv->vis_mode, BATADV_VIS_TYPE_CLIENT_UPDATE); + atomic_set(&bat_priv->gw_mode, BATADV_GW_MODE_OFF); atomic_set(&bat_priv->gw_sel_class, 20); atomic_set(&bat_priv->gw_bandwidth, 41); atomic_set(&bat_priv->orig_interval, 1000); @@ -397,7 +399,7 @@ struct net_device *batadv_softif_create(const char *name) atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN); atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN); - atomic_set(&bat_priv->mesh_state, MESH_INACTIVE); + atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE); atomic_set(&bat_priv->bcast_seqno, 1); atomic_set(&bat_priv->ttvn, 0); atomic_set(&bat_priv->tt_local_changes, 0); @@ -411,8 +413,7 @@ struct net_device *batadv_softif_create(const char *name) bat_priv->primary_if = NULL; bat_priv->num_ifaces = 0; - bat_priv->bat_counters = __alloc_percpu(sizeof(uint64_t) * BAT_CNT_NUM, - __alignof__(uint64_t)); + bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(uint64_t)); if (!bat_priv->bat_counters) goto unreg_soft_iface; @@ -539,17 +540,17 @@ static void batadv_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats, uint64_t *data) { - struct bat_priv *bat_priv = netdev_priv(dev); + struct batadv_priv *bat_priv = netdev_priv(dev); int i; - for (i = 0; i < BAT_CNT_NUM; i++) + for (i = 0; i < BATADV_CNT_NUM; i++) data[i] = batadv_sum_counter(bat_priv, i); } static int batadv_get_sset_count(struct net_device *dev, int stringset) { if (stringset == ETH_SS_STATS) - return BAT_CNT_NUM; + return BATADV_CNT_NUM; return -EOPNOTSUPP; } diff --git a/net/batman-adv/soft-interface.h b/net/batman-adv/soft-interface.h index 2711ba5b1233..852c683b06a1 100644 --- a/net/batman-adv/soft-interface.h +++ b/net/batman-adv/soft-interface.h @@ -22,7 +22,7 @@ int batadv_skb_head_push(struct sk_buff *skb, unsigned int len); void batadv_interface_rx(struct net_device *soft_iface, struct sk_buff *skb, - struct hard_iface *recv_if, int hdr_size); + struct batadv_hard_iface *recv_if, int hdr_size); struct net_device *batadv_softif_create(const char *name); void batadv_softif_destroy(struct net_device *soft_iface); int batadv_softif_is_valid(const struct net_device *net_dev); diff --git a/net/batman-adv/bat_sysfs.c b/net/batman-adv/sysfs.c index 95d80d1808f2..66518c75c217 100644 --- a/net/batman-adv/bat_sysfs.c +++ b/net/batman-adv/sysfs.c @@ -18,7 +18,7 @@ */ #include "main.h" -#include "bat_sysfs.h" +#include "sysfs.h" #include "translation-table.h" #include "originator.h" #include "hard-interface.h" @@ -32,7 +32,7 @@ static struct net_device *batadv_kobj_to_netdev(struct kobject *obj) return to_net_dev(dev); } -static struct bat_priv *batadv_kobj_to_batpriv(struct kobject *obj) +static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj) { struct net_device *net_dev = batadv_kobj_to_netdev(obj); return netdev_priv(net_dev); @@ -54,7 +54,7 @@ static char *batadv_uev_type_str[] = { /* Use this, if you have customized show and store functions */ #define BATADV_ATTR(_name, _mode, _show, _store) \ -struct bat_attribute batadv_attr_##_name = { \ +struct batadv_attribute batadv_attr_##_name = { \ .attr = {.name = __stringify(_name), \ .mode = _mode }, \ .show = _show, \ @@ -67,7 +67,7 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ size_t count) \ { \ struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \ - struct bat_priv *bat_priv = netdev_priv(net_dev); \ + struct batadv_priv *bat_priv = netdev_priv(net_dev); \ return __batadv_store_bool_attr(buff, count, _post_func, attr, \ &bat_priv->_name, net_dev); \ } @@ -76,7 +76,7 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ ssize_t batadv_show_##_name(struct kobject *kobj, \ struct attribute *attr, char *buff) \ { \ - struct bat_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \ + struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \ return sprintf(buff, "%s\n", \ atomic_read(&bat_priv->_name) == 0 ? \ "disabled" : "enabled"); \ @@ -98,7 +98,7 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ size_t count) \ { \ struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \ - struct bat_priv *bat_priv = netdev_priv(net_dev); \ + struct batadv_priv *bat_priv = netdev_priv(net_dev); \ return __batadv_store_uint_attr(buff, count, _min, _max, \ _post_func, attr, \ &bat_priv->_name, net_dev); \ @@ -108,7 +108,7 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ ssize_t batadv_show_##_name(struct kobject *kobj, \ struct attribute *attr, char *buff) \ { \ - struct bat_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \ + struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); \ return sprintf(buff, "%i\n", atomic_read(&bat_priv->_name)); \ } \ @@ -128,7 +128,7 @@ ssize_t batadv_store_##_name(struct kobject *kobj, \ size_t count) \ { \ struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \ - struct hard_iface *hard_iface; \ + struct batadv_hard_iface *hard_iface; \ ssize_t length; \ \ hard_iface = batadv_hardif_get_by_netdev(net_dev); \ @@ -148,7 +148,7 @@ ssize_t batadv_show_##_name(struct kobject *kobj, \ struct attribute *attr, char *buff) \ { \ struct net_device *net_dev = batadv_kobj_to_netdev(kobj); \ - struct hard_iface *hard_iface; \ + struct batadv_hard_iface *hard_iface; \ ssize_t length; \ \ hard_iface = batadv_hardif_get_by_netdev(net_dev); \ @@ -281,12 +281,16 @@ __batadv_store_uint_attr(const char *buff, size_t count, static ssize_t batadv_show_vis_mode(struct kobject *kobj, struct attribute *attr, char *buff) { - struct bat_priv *bat_priv = batadv_kobj_to_batpriv(kobj); + struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); int vis_mode = atomic_read(&bat_priv->vis_mode); + const char *mode; - return sprintf(buff, "%s\n", - vis_mode == VIS_TYPE_CLIENT_UPDATE ? - "client" : "server"); + if (vis_mode == BATADV_VIS_TYPE_CLIENT_UPDATE) + mode = "client"; + else + mode = "server"; + + return sprintf(buff, "%s\n", mode); } static ssize_t batadv_store_vis_mode(struct kobject *kobj, @@ -294,21 +298,23 @@ static ssize_t batadv_store_vis_mode(struct kobject *kobj, size_t count) { struct net_device *net_dev = batadv_kobj_to_netdev(kobj); - struct bat_priv *bat_priv = netdev_priv(net_dev); + struct batadv_priv *bat_priv = netdev_priv(net_dev); unsigned long val; int ret, vis_mode_tmp = -1; const char *old_mode, *new_mode; ret = kstrtoul(buff, 10, &val); - if (((count == 2) && (!ret) && (val == VIS_TYPE_CLIENT_UPDATE)) || + if (((count == 2) && (!ret) && + (val == BATADV_VIS_TYPE_CLIENT_UPDATE)) || (strncmp(buff, "client", 6) == 0) || (strncmp(buff, "off", 3) == 0)) - vis_mode_tmp = VIS_TYPE_CLIENT_UPDATE; + vis_mode_tmp = BATADV_VIS_TYPE_CLIENT_UPDATE; - if (((count == 2) && (!ret) && (val == VIS_TYPE_SERVER_SYNC)) || + if (((count == 2) && (!ret) && + (val == BATADV_VIS_TYPE_SERVER_SYNC)) || (strncmp(buff, "server", 6) == 0)) - vis_mode_tmp = VIS_TYPE_SERVER_SYNC; + vis_mode_tmp = BATADV_VIS_TYPE_SERVER_SYNC; if (vis_mode_tmp < 0) { if (buff[count - 1] == '\n') @@ -323,12 +329,12 @@ static ssize_t batadv_store_vis_mode(struct kobject *kobj, if (atomic_read(&bat_priv->vis_mode) == vis_mode_tmp) return count; - if (atomic_read(&bat_priv->vis_mode) == VIS_TYPE_CLIENT_UPDATE) + if (atomic_read(&bat_priv->vis_mode) == BATADV_VIS_TYPE_CLIENT_UPDATE) old_mode = "client"; else old_mode = "server"; - if (vis_mode_tmp == VIS_TYPE_CLIENT_UPDATE) + if (vis_mode_tmp == BATADV_VIS_TYPE_CLIENT_UPDATE) new_mode = "client"; else new_mode = "server"; @@ -343,28 +349,28 @@ static ssize_t batadv_store_vis_mode(struct kobject *kobj, static ssize_t batadv_show_bat_algo(struct kobject *kobj, struct attribute *attr, char *buff) { - struct bat_priv *bat_priv = batadv_kobj_to_batpriv(kobj); + struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); return sprintf(buff, "%s\n", bat_priv->bat_algo_ops->name); } static void batadv_post_gw_deselect(struct net_device *net_dev) { - struct bat_priv *bat_priv = netdev_priv(net_dev); + struct batadv_priv *bat_priv = netdev_priv(net_dev); batadv_gw_deselect(bat_priv); } static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr, char *buff) { - struct bat_priv *bat_priv = batadv_kobj_to_batpriv(kobj); + struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); int bytes_written; switch (atomic_read(&bat_priv->gw_mode)) { - case GW_MODE_CLIENT: + case BATADV_GW_MODE_CLIENT: bytes_written = sprintf(buff, "%s\n", BATADV_GW_MODE_CLIENT_NAME); break; - case GW_MODE_SERVER: + case BATADV_GW_MODE_SERVER: bytes_written = sprintf(buff, "%s\n", BATADV_GW_MODE_SERVER_NAME); break; @@ -382,7 +388,7 @@ static ssize_t batadv_store_gw_mode(struct kobject *kobj, size_t count) { struct net_device *net_dev = batadv_kobj_to_netdev(kobj); - struct bat_priv *bat_priv = netdev_priv(net_dev); + struct batadv_priv *bat_priv = netdev_priv(net_dev); char *curr_gw_mode_str; int gw_mode_tmp = -1; @@ -391,15 +397,15 @@ static ssize_t batadv_store_gw_mode(struct kobject *kobj, if (strncmp(buff, BATADV_GW_MODE_OFF_NAME, strlen(BATADV_GW_MODE_OFF_NAME)) == 0) - gw_mode_tmp = GW_MODE_OFF; + gw_mode_tmp = BATADV_GW_MODE_OFF; if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME, strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0) - gw_mode_tmp = GW_MODE_CLIENT; + gw_mode_tmp = BATADV_GW_MODE_CLIENT; if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME, strlen(BATADV_GW_MODE_SERVER_NAME)) == 0) - gw_mode_tmp = GW_MODE_SERVER; + gw_mode_tmp = BATADV_GW_MODE_SERVER; if (gw_mode_tmp < 0) { batadv_info(net_dev, @@ -412,10 +418,10 @@ static ssize_t batadv_store_gw_mode(struct kobject *kobj, return count; switch (atomic_read(&bat_priv->gw_mode)) { - case GW_MODE_CLIENT: + case BATADV_GW_MODE_CLIENT: curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME; break; - case GW_MODE_SERVER: + case BATADV_GW_MODE_SERVER: curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME; break; default: @@ -434,7 +440,7 @@ static ssize_t batadv_store_gw_mode(struct kobject *kobj, static ssize_t batadv_show_gw_bwidth(struct kobject *kobj, struct attribute *attr, char *buff) { - struct bat_priv *bat_priv = batadv_kobj_to_batpriv(kobj); + struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj); int down, up; int gw_bandwidth = atomic_read(&bat_priv->gw_bandwidth); @@ -479,10 +485,10 @@ 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[] = { +static struct batadv_attribute *batadv_mesh_attrs[] = { &batadv_attr_aggregated_ogms, &batadv_attr_bonding, #ifdef CONFIG_BATMAN_ADV_BLA @@ -506,8 +512,8 @@ static struct bat_attribute *batadv_mesh_attrs[] = { int batadv_sysfs_add_meshif(struct net_device *dev) { struct kobject *batif_kobject = &dev->dev.kobj; - struct bat_priv *bat_priv = netdev_priv(dev); - struct bat_attribute **bat_attr; + struct batadv_priv *bat_priv = netdev_priv(dev); + struct batadv_attribute **bat_attr; int err; bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR, @@ -543,8 +549,8 @@ out: void batadv_sysfs_del_meshif(struct net_device *dev) { - struct bat_priv *bat_priv = netdev_priv(dev); - struct bat_attribute **bat_attr; + struct batadv_priv *bat_priv = netdev_priv(dev); + struct batadv_attribute **bat_attr; for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr)); @@ -557,14 +563,20 @@ static ssize_t batadv_show_mesh_iface(struct kobject *kobj, struct attribute *attr, char *buff) { struct net_device *net_dev = batadv_kobj_to_netdev(kobj); - struct hard_iface *hard_iface = batadv_hardif_get_by_netdev(net_dev); + struct batadv_hard_iface *hard_iface; ssize_t length; + const char *ifname; + hard_iface = batadv_hardif_get_by_netdev(net_dev); if (!hard_iface) return 0; - length = sprintf(buff, "%s\n", hard_iface->if_status == IF_NOT_IN_USE ? - "none" : hard_iface->soft_iface->name); + if (hard_iface->if_status == BATADV_IF_NOT_IN_USE) + ifname = "none"; + else + ifname = hard_iface->soft_iface->name; + + length = sprintf(buff, "%s\n", ifname); batadv_hardif_free_ref(hard_iface); @@ -576,10 +588,11 @@ static ssize_t batadv_store_mesh_iface(struct kobject *kobj, size_t count) { struct net_device *net_dev = batadv_kobj_to_netdev(kobj); - struct hard_iface *hard_iface = batadv_hardif_get_by_netdev(net_dev); + struct batadv_hard_iface *hard_iface; int status_tmp = -1; int ret = count; + hard_iface = batadv_hardif_get_by_netdev(net_dev); if (!hard_iface) return count; @@ -594,9 +607,9 @@ static ssize_t batadv_store_mesh_iface(struct kobject *kobj, } if (strncmp(buff, "none", 4) == 0) - status_tmp = IF_NOT_IN_USE; + status_tmp = BATADV_IF_NOT_IN_USE; else - status_tmp = IF_I_WANT_YOU; + status_tmp = BATADV_IF_I_WANT_YOU; if (hard_iface->if_status == status_tmp) goto out; @@ -610,13 +623,13 @@ static ssize_t batadv_store_mesh_iface(struct kobject *kobj, goto out; } - if (status_tmp == IF_NOT_IN_USE) { + if (status_tmp == BATADV_IF_NOT_IN_USE) { batadv_hardif_disable_interface(hard_iface); goto unlock; } /* if the interface already is in use */ - if (hard_iface->if_status != IF_NOT_IN_USE) + if (hard_iface->if_status != BATADV_IF_NOT_IN_USE) batadv_hardif_disable_interface(hard_iface); ret = batadv_hardif_enable_interface(hard_iface, buff); @@ -632,26 +645,27 @@ static ssize_t batadv_show_iface_status(struct kobject *kobj, struct attribute *attr, char *buff) { struct net_device *net_dev = batadv_kobj_to_netdev(kobj); - struct hard_iface *hard_iface = batadv_hardif_get_by_netdev(net_dev); + struct batadv_hard_iface *hard_iface; ssize_t length; + hard_iface = batadv_hardif_get_by_netdev(net_dev); if (!hard_iface) return 0; switch (hard_iface->if_status) { - case IF_TO_BE_REMOVED: + case BATADV_IF_TO_BE_REMOVED: length = sprintf(buff, "disabling\n"); break; - case IF_INACTIVE: + case BATADV_IF_INACTIVE: length = sprintf(buff, "inactive\n"); break; - case IF_ACTIVE: + case BATADV_IF_ACTIVE: length = sprintf(buff, "active\n"); break; - case IF_TO_BE_ACTIVATED: + case BATADV_IF_TO_BE_ACTIVATED: length = sprintf(buff, "enabling\n"); break; - case IF_NOT_IN_USE: + case BATADV_IF_NOT_IN_USE: default: length = sprintf(buff, "not in use\n"); break; @@ -666,7 +680,7 @@ static BATADV_ATTR(mesh_iface, S_IRUGO | S_IWUSR, batadv_show_mesh_iface, batadv_store_mesh_iface); static BATADV_ATTR(iface_status, S_IRUGO, batadv_show_iface_status, NULL); -static struct bat_attribute *batadv_batman_attrs[] = { +static struct batadv_attribute *batadv_batman_attrs[] = { &batadv_attr_mesh_iface, &batadv_attr_iface_status, NULL, @@ -675,7 +689,7 @@ static struct bat_attribute *batadv_batman_attrs[] = { int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev) { struct kobject *hardif_kobject = &dev->dev.kobj; - struct bat_attribute **bat_attr; + struct batadv_attribute **bat_attr; int err; *hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR, @@ -712,11 +726,11 @@ 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 batadv_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; + struct batadv_hard_iface *primary_if = NULL; struct kobject *bat_kobj; char *uevent_env[4] = { NULL, NULL, NULL, NULL }; @@ -745,7 +759,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]) @@ -764,10 +778,10 @@ out: 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; } diff --git a/net/batman-adv/bat_sysfs.h b/net/batman-adv/sysfs.h index 23a8390851a6..3fd1412b0620 100644 --- a/net/batman-adv/bat_sysfs.h +++ b/net/batman-adv/sysfs.h @@ -23,7 +23,7 @@ #define BATADV_SYSFS_IF_MESH_SUBDIR "mesh" #define BATADV_SYSFS_IF_BAT_SUBDIR "batman_adv" -struct bat_attribute { +struct batadv_attribute { struct attribute attr; ssize_t (*show)(struct kobject *kobj, struct attribute *attr, char *buf); @@ -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 batadv_priv *bat_priv, enum batadv_uev_type type, + enum batadv_uev_action action, const char *data); #endif /* _NET_BATMAN_ADV_SYSFS_H_ */ diff --git a/net/batman-adv/translation-table.c b/net/batman-adv/translation-table.c index a0487e9f18c7..a438f4b582fc 100644 --- a/net/batman-adv/translation-table.c +++ b/net/batman-adv/translation-table.c @@ -29,34 +29,35 @@ #include <linux/crc16.h> -static void batadv_send_roam_adv(struct bat_priv *bat_priv, uint8_t *client, - struct orig_node *orig_node); +static void batadv_send_roam_adv(struct batadv_priv *bat_priv, uint8_t *client, + struct batadv_orig_node *orig_node); static void batadv_tt_purge(struct work_struct *work); static void -batadv_tt_global_del_orig_list(struct tt_global_entry *tt_global_entry); +batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry); /* returns 1 if they are the same mac addr */ static int batadv_compare_tt(const struct hlist_node *node, const void *data2) { - const void *data1 = container_of(node, struct tt_common_entry, + const void *data1 = container_of(node, struct batadv_tt_common_entry, hash_entry); return (memcmp(data1, data2, ETH_ALEN) == 0 ? 1 : 0); } -static void batadv_tt_start_timer(struct bat_priv *bat_priv) +static void batadv_tt_start_timer(struct batadv_priv *bat_priv) { INIT_DELAYED_WORK(&bat_priv->tt_work, batadv_tt_purge); queue_delayed_work(batadv_event_workqueue, &bat_priv->tt_work, msecs_to_jiffies(5000)); } -static struct tt_common_entry *batadv_tt_hash_find(struct hashtable_t *hash, - const void *data) +static struct batadv_tt_common_entry * +batadv_tt_hash_find(struct batadv_hashtable *hash, const void *data) { struct hlist_head *head; struct hlist_node *node; - struct tt_common_entry *tt_common_entry, *tt_common_entry_tmp = NULL; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_common_entry *tt_common_entry_tmp = NULL; uint32_t index; if (!hash) @@ -81,35 +82,37 @@ static struct tt_common_entry *batadv_tt_hash_find(struct hashtable_t *hash, return tt_common_entry_tmp; } -static struct tt_local_entry * -batadv_tt_local_hash_find(struct bat_priv *bat_priv, const void *data) +static struct batadv_tt_local_entry * +batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const void *data) { - struct tt_common_entry *tt_common_entry; - struct tt_local_entry *tt_local_entry = NULL; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_local_entry *tt_local_entry = NULL; tt_common_entry = batadv_tt_hash_find(bat_priv->tt_local_hash, data); if (tt_common_entry) tt_local_entry = container_of(tt_common_entry, - struct tt_local_entry, common); + struct batadv_tt_local_entry, + common); return tt_local_entry; } -static struct tt_global_entry * -batadv_tt_global_hash_find(struct bat_priv *bat_priv, const void *data) +static struct batadv_tt_global_entry * +batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const void *data) { - struct tt_common_entry *tt_common_entry; - struct tt_global_entry *tt_global_entry = NULL; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_global_entry *tt_global_entry = NULL; tt_common_entry = batadv_tt_hash_find(bat_priv->tt_global_hash, data); if (tt_common_entry) tt_global_entry = container_of(tt_common_entry, - struct tt_global_entry, common); + struct batadv_tt_global_entry, + common); return tt_global_entry; } static void -batadv_tt_local_entry_free_ref(struct tt_local_entry *tt_local_entry) +batadv_tt_local_entry_free_ref(struct batadv_tt_local_entry *tt_local_entry) { if (atomic_dec_and_test(&tt_local_entry->common.refcount)) kfree_rcu(tt_local_entry, common.rcu); @@ -117,18 +120,18 @@ batadv_tt_local_entry_free_ref(struct tt_local_entry *tt_local_entry) static void batadv_tt_global_entry_free_rcu(struct rcu_head *rcu) { - struct tt_common_entry *tt_common_entry; - struct tt_global_entry *tt_global_entry; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_global_entry *tt_global_entry; - tt_common_entry = container_of(rcu, struct tt_common_entry, rcu); - tt_global_entry = container_of(tt_common_entry, struct tt_global_entry, - common); + tt_common_entry = container_of(rcu, struct batadv_tt_common_entry, rcu); + tt_global_entry = container_of(tt_common_entry, + struct batadv_tt_global_entry, common); kfree(tt_global_entry); } static void -batadv_tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry) +batadv_tt_global_entry_free_ref(struct batadv_tt_global_entry *tt_global_entry) { if (atomic_dec_and_test(&tt_global_entry->common.refcount)) { batadv_tt_global_del_orig_list(tt_global_entry); @@ -139,25 +142,25 @@ batadv_tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry) static void batadv_tt_orig_list_entry_free_rcu(struct rcu_head *rcu) { - struct tt_orig_list_entry *orig_entry; + struct batadv_tt_orig_list_entry *orig_entry; - orig_entry = container_of(rcu, struct tt_orig_list_entry, rcu); + orig_entry = container_of(rcu, struct batadv_tt_orig_list_entry, rcu); batadv_orig_node_free_ref(orig_entry->orig_node); kfree(orig_entry); } static void -batadv_tt_orig_list_entry_free_ref(struct tt_orig_list_entry *orig_entry) +batadv_tt_orig_list_entry_free_ref(struct batadv_tt_orig_list_entry *orig_entry) { /* to avoid race conditions, immediately decrease the tt counter */ atomic_dec(&orig_entry->orig_node->tt_size); call_rcu(&orig_entry->rcu, batadv_tt_orig_list_entry_free_rcu); } -static void batadv_tt_local_event(struct bat_priv *bat_priv, +static void batadv_tt_local_event(struct batadv_priv *bat_priv, const uint8_t *addr, uint8_t flags) { - struct tt_change_node *tt_change_node, *entry, *safe; + struct batadv_tt_change_node *tt_change_node, *entry, *safe; bool event_removed = false; bool del_op_requested, del_op_entry; @@ -169,7 +172,7 @@ static void batadv_tt_local_event(struct bat_priv *bat_priv, tt_change_node->change.flags = flags; memcpy(tt_change_node->change.addr, addr, ETH_ALEN); - del_op_requested = flags & TT_CLIENT_DEL; + del_op_requested = flags & BATADV_TT_CLIENT_DEL; /* check for ADD+DEL or DEL+ADD events */ spin_lock_bh(&bat_priv->tt_changes_list_lock); @@ -185,7 +188,7 @@ static void batadv_tt_local_event(struct bat_priv *bat_priv, * now possible due to automatically recognition of "temporary" * clients */ - del_op_entry = entry->change.flags & TT_CLIENT_DEL; + del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL; if (!del_op_requested && del_op_entry) goto del; if (del_op_requested && !del_op_entry) @@ -212,10 +215,10 @@ unlock: int batadv_tt_len(int changes_num) { - return changes_num * sizeof(struct tt_change); + return changes_num * sizeof(struct batadv_tt_change); } -static int batadv_tt_local_init(struct bat_priv *bat_priv) +static int batadv_tt_local_init(struct batadv_priv *bat_priv) { if (bat_priv->tt_local_hash) return 0; @@ -231,20 +234,20 @@ static int batadv_tt_local_init(struct bat_priv *bat_priv) void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr, int ifindex) { - struct bat_priv *bat_priv = netdev_priv(soft_iface); - struct tt_local_entry *tt_local_entry = NULL; - struct tt_global_entry *tt_global_entry = NULL; + struct batadv_priv *bat_priv = netdev_priv(soft_iface); + struct batadv_tt_local_entry *tt_local_entry = NULL; + struct batadv_tt_global_entry *tt_global_entry = NULL; struct hlist_head *head; struct hlist_node *node; - struct tt_orig_list_entry *orig_entry; + struct batadv_tt_orig_list_entry *orig_entry; int hash_added; tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr); if (tt_local_entry) { tt_local_entry->last_seen = jiffies; - /* possibly unset the TT_CLIENT_PENDING flag */ - tt_local_entry->common.flags &= ~TT_CLIENT_PENDING; + /* possibly unset the BATADV_TT_CLIENT_PENDING flag */ + tt_local_entry->common.flags &= ~BATADV_TT_CLIENT_PENDING; goto out; } @@ -252,26 +255,26 @@ void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr, if (!tt_local_entry) goto out; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Creating new local tt entry: %pM (ttvn: %d)\n", addr, (uint8_t)atomic_read(&bat_priv->ttvn)); memcpy(tt_local_entry->common.addr, addr, ETH_ALEN); tt_local_entry->common.flags = BATADV_NO_FLAGS; if (batadv_is_wifi_iface(ifindex)) - tt_local_entry->common.flags |= TT_CLIENT_WIFI; + tt_local_entry->common.flags |= BATADV_TT_CLIENT_WIFI; atomic_set(&tt_local_entry->common.refcount, 2); tt_local_entry->last_seen = jiffies; /* the batman interface mac address should never be purged */ if (batadv_compare_eth(addr, soft_iface->dev_addr)) - tt_local_entry->common.flags |= TT_CLIENT_NOPURGE; + tt_local_entry->common.flags |= BATADV_TT_CLIENT_NOPURGE; /* The local entry has to be marked as NEW to avoid to send it in * a full table response going out before the next ttvn increment * (consistency check) */ - tt_local_entry->common.flags |= TT_CLIENT_NEW; + tt_local_entry->common.flags |= BATADV_TT_CLIENT_NEW; hash_added = batadv_hash_add(bat_priv->tt_local_hash, batadv_compare_tt, batadv_choose_orig, @@ -305,7 +308,7 @@ void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr, /* The global entry has to be marked as ROAMING and * has to be kept for consistency purpose */ - tt_global_entry->common.flags |= TT_CLIENT_ROAM; + tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM; tt_global_entry->roam_at = jiffies; } out: @@ -333,12 +336,12 @@ static void batadv_tt_realloc_packet_buff(unsigned char **packet_buff, } } -static void batadv_tt_prepare_packet_buff(struct bat_priv *bat_priv, +static void batadv_tt_prepare_packet_buff(struct batadv_priv *bat_priv, unsigned char **packet_buff, int *packet_buff_len, int min_packet_len) { - struct hard_iface *primary_if; + struct batadv_hard_iface *primary_if; int req_len; primary_if = batadv_primary_if_get_selected(bat_priv); @@ -359,12 +362,12 @@ static void batadv_tt_prepare_packet_buff(struct bat_priv *bat_priv, batadv_hardif_free_ref(primary_if); } -static int batadv_tt_changes_fill_buff(struct bat_priv *bat_priv, +static int batadv_tt_changes_fill_buff(struct batadv_priv *bat_priv, unsigned char **packet_buff, int *packet_buff_len, int min_packet_len) { - struct tt_change_node *entry, *safe; + struct batadv_tt_change_node *entry, *safe; int count = 0, tot_changes = 0, new_len; unsigned char *tt_buff; @@ -384,7 +387,7 @@ static int batadv_tt_changes_fill_buff(struct bat_priv *bat_priv, list) { if (count < tot_changes) { memcpy(tt_buff + batadv_tt_len(count), - &entry->change, sizeof(struct tt_change)); + &entry->change, sizeof(struct batadv_tt_change)); count++; } list_del(&entry->list); @@ -416,10 +419,10 @@ static int batadv_tt_changes_fill_buff(struct bat_priv *bat_priv, int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset) { struct net_device *net_dev = (struct net_device *)seq->private; - struct bat_priv *bat_priv = netdev_priv(net_dev); - struct hashtable_t *hash = bat_priv->tt_local_hash; - struct tt_common_entry *tt_common_entry; - struct hard_iface *primary_if; + struct batadv_priv *bat_priv = netdev_priv(net_dev); + struct batadv_hashtable *hash = bat_priv->tt_local_hash; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_hard_iface *primary_if; struct hlist_node *node; struct hlist_head *head; uint32_t i; @@ -433,7 +436,7 @@ int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset) goto out; } - if (primary_if->if_status != IF_ACTIVE) { + if (primary_if->if_status != BATADV_IF_ACTIVE) { ret = seq_printf(seq, "BATMAN mesh %s disabled - primary interface not active\n", net_dev->name); @@ -453,15 +456,15 @@ int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset) seq_printf(seq, " * %pM [%c%c%c%c%c]\n", tt_common_entry->addr, (tt_common_entry->flags & - TT_CLIENT_ROAM ? 'R' : '.'), + BATADV_TT_CLIENT_ROAM ? 'R' : '.'), (tt_common_entry->flags & - TT_CLIENT_NOPURGE ? 'P' : '.'), + BATADV_TT_CLIENT_NOPURGE ? 'P' : '.'), (tt_common_entry->flags & - TT_CLIENT_NEW ? 'N' : '.'), + BATADV_TT_CLIENT_NEW ? 'N' : '.'), (tt_common_entry->flags & - TT_CLIENT_PENDING ? 'X' : '.'), + BATADV_TT_CLIENT_PENDING ? 'X' : '.'), (tt_common_entry->flags & - TT_CLIENT_WIFI ? 'W' : '.')); + BATADV_TT_CLIENT_WIFI ? 'W' : '.')); } rcu_read_unlock(); } @@ -471,9 +474,10 @@ out: return ret; } -static void batadv_tt_local_set_pending(struct bat_priv *bat_priv, - struct tt_local_entry *tt_local_entry, - uint16_t flags, const char *message) +static void +batadv_tt_local_set_pending(struct batadv_priv *bat_priv, + struct batadv_tt_local_entry *tt_local_entry, + uint16_t flags, const char *message) { batadv_tt_local_event(bat_priv, tt_local_entry->common.addr, tt_local_entry->common.flags | flags); @@ -482,26 +486,26 @@ static void batadv_tt_local_set_pending(struct bat_priv *bat_priv, * to be kept in the table in order to send it in a full table * response issued before the net ttvn increment (consistency check) */ - tt_local_entry->common.flags |= TT_CLIENT_PENDING; + tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Local tt entry (%pM) pending to be removed: %s\n", tt_local_entry->common.addr, message); } -void batadv_tt_local_remove(struct bat_priv *bat_priv, const uint8_t *addr, +void batadv_tt_local_remove(struct batadv_priv *bat_priv, const uint8_t *addr, const char *message, bool roaming) { - struct tt_local_entry *tt_local_entry = NULL; + struct batadv_tt_local_entry *tt_local_entry = NULL; uint16_t flags; tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr); if (!tt_local_entry) goto out; - flags = TT_CLIENT_DEL; + flags = BATADV_TT_CLIENT_DEL; if (roaming) - flags |= TT_CLIENT_ROAM; + flags |= BATADV_TT_CLIENT_ROAM; batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags, message); out: @@ -509,12 +513,37 @@ out: batadv_tt_local_entry_free_ref(tt_local_entry); } -static void batadv_tt_local_purge(struct bat_priv *bat_priv) +static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv, + struct hlist_head *head) { - struct hashtable_t *hash = bat_priv->tt_local_hash; - struct tt_local_entry *tt_local_entry; - struct tt_common_entry *tt_common_entry; + struct batadv_tt_local_entry *tt_local_entry; + struct batadv_tt_common_entry *tt_common_entry; struct hlist_node *node, *node_tmp; + + hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, head, + hash_entry) { + tt_local_entry = container_of(tt_common_entry, + struct batadv_tt_local_entry, + common); + if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE) + continue; + + /* entry already marked for deletion */ + if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) + continue; + + if (!batadv_has_timed_out(tt_local_entry->last_seen, + BATADV_TT_LOCAL_TIMEOUT)) + continue; + + batadv_tt_local_set_pending(bat_priv, tt_local_entry, + BATADV_TT_CLIENT_DEL, "timed out"); + } +} + +static void batadv_tt_local_purge(struct batadv_priv *bat_priv) +{ + struct batadv_hashtable *hash = bat_priv->tt_local_hash; struct hlist_head *head; spinlock_t *list_lock; /* protects write access to the hash lists */ uint32_t i; @@ -524,36 +553,18 @@ static void batadv_tt_local_purge(struct bat_priv *bat_priv) list_lock = &hash->list_locks[i]; spin_lock_bh(list_lock); - hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, - head, hash_entry) { - tt_local_entry = container_of(tt_common_entry, - struct tt_local_entry, - common); - if (tt_local_entry->common.flags & TT_CLIENT_NOPURGE) - continue; - - /* entry already marked for deletion */ - if (tt_local_entry->common.flags & TT_CLIENT_PENDING) - continue; - - if (!batadv_has_timed_out(tt_local_entry->last_seen, - BATADV_TT_LOCAL_TIMEOUT)) - continue; - - batadv_tt_local_set_pending(bat_priv, tt_local_entry, - TT_CLIENT_DEL, "timed out"); - } + batadv_tt_local_purge_list(bat_priv, head); spin_unlock_bh(list_lock); } } -static void batadv_tt_local_table_free(struct bat_priv *bat_priv) +static void batadv_tt_local_table_free(struct batadv_priv *bat_priv) { - struct hashtable_t *hash; + struct batadv_hashtable *hash; spinlock_t *list_lock; /* protects write access to the hash lists */ - struct tt_common_entry *tt_common_entry; - struct tt_local_entry *tt_local_entry; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_local_entry *tt_local; struct hlist_node *node, *node_tmp; struct hlist_head *head; uint32_t i; @@ -571,10 +582,10 @@ static void batadv_tt_local_table_free(struct bat_priv *bat_priv) hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, head, hash_entry) { hlist_del_rcu(node); - tt_local_entry = container_of(tt_common_entry, - struct tt_local_entry, - common); - batadv_tt_local_entry_free_ref(tt_local_entry); + tt_local = container_of(tt_common_entry, + struct batadv_tt_local_entry, + common); + batadv_tt_local_entry_free_ref(tt_local); } spin_unlock_bh(list_lock); } @@ -584,7 +595,7 @@ static void batadv_tt_local_table_free(struct bat_priv *bat_priv) bat_priv->tt_local_hash = NULL; } -static int batadv_tt_global_init(struct bat_priv *bat_priv) +static int batadv_tt_global_init(struct batadv_priv *bat_priv) { if (bat_priv->tt_global_hash) return 0; @@ -597,9 +608,9 @@ static int batadv_tt_global_init(struct bat_priv *bat_priv) return 0; } -static void batadv_tt_changes_list_free(struct bat_priv *bat_priv) +static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv) { - struct tt_change_node *entry, *safe; + struct batadv_tt_change_node *entry, *safe; spin_lock_bh(&bat_priv->tt_changes_list_lock); @@ -616,10 +627,11 @@ static void batadv_tt_changes_list_free(struct bat_priv *bat_priv) /* find out if an orig_node is already in the list of a tt_global_entry. * returns 1 if found, 0 otherwise */ -static bool batadv_tt_global_entry_has_orig(const struct tt_global_entry *entry, - const struct orig_node *orig_node) +static bool +batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry, + const struct batadv_orig_node *orig_node) { - struct tt_orig_list_entry *tmp_orig_entry; + struct batadv_tt_orig_list_entry *tmp_orig_entry; const struct hlist_head *head; struct hlist_node *node; bool found = false; @@ -637,10 +649,10 @@ static bool batadv_tt_global_entry_has_orig(const struct tt_global_entry *entry, } static void -batadv_tt_global_add_orig_entry(struct tt_global_entry *tt_global_entry, - struct orig_node *orig_node, int ttvn) +batadv_tt_global_add_orig_entry(struct batadv_tt_global_entry *tt_global_entry, + struct batadv_orig_node *orig_node, int ttvn) { - struct tt_orig_list_entry *orig_entry; + struct batadv_tt_orig_list_entry *orig_entry; orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC); if (!orig_entry) @@ -659,14 +671,15 @@ batadv_tt_global_add_orig_entry(struct tt_global_entry *tt_global_entry, } /* caller must hold orig_node refcount */ -int batadv_tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node, +int batadv_tt_global_add(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const unsigned char *tt_addr, uint8_t flags, uint8_t ttvn) { - struct tt_global_entry *tt_global_entry = NULL; + struct batadv_tt_global_entry *tt_global_entry = NULL; int ret = 0; int hash_added; - struct tt_common_entry *common; + struct batadv_tt_common_entry *common; tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr); @@ -701,16 +714,16 @@ int batadv_tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node, } else { /* there is already a global entry, use this one. */ - /* If there is the TT_CLIENT_ROAM flag set, there is only one - * originator left in the list and we previously received a + /* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only + * one originator left in the list and we previously received a * delete + roaming change for this originator. * * We should first delete the old originator before adding the * new one. */ - if (tt_global_entry->common.flags & TT_CLIENT_ROAM) { + if (tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM) { batadv_tt_global_del_orig_list(tt_global_entry); - tt_global_entry->common.flags &= ~TT_CLIENT_ROAM; + tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM; tt_global_entry->roam_at = 0; } @@ -720,14 +733,15 @@ int batadv_tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node, orig_node, ttvn); } - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Creating new global tt entry: %pM (via %pM)\n", tt_global_entry->common.addr, orig_node->orig); out_remove: /* remove address from local hash if present */ batadv_tt_local_remove(bat_priv, tt_global_entry->common.addr, - "global tt received", flags & TT_CLIENT_ROAM); + "global tt received", + flags & BATADV_TT_CLIENT_ROAM); ret = 1; out: if (tt_global_entry) @@ -739,13 +753,13 @@ out: * it is assumed that the caller holds rcu_read_lock(); */ static void -batadv_tt_global_print_entry(struct tt_global_entry *tt_global_entry, +batadv_tt_global_print_entry(struct batadv_tt_global_entry *tt_global_entry, struct seq_file *seq) { struct hlist_head *head; struct hlist_node *node; - struct tt_orig_list_entry *orig_entry; - struct tt_common_entry *tt_common_entry; + struct batadv_tt_orig_list_entry *orig_entry; + struct batadv_tt_common_entry *tt_common_entry; uint16_t flags; uint8_t last_ttvn; @@ -759,19 +773,19 @@ batadv_tt_global_print_entry(struct tt_global_entry *tt_global_entry, seq_printf(seq, " * %pM (%3u) via %pM (%3u) [%c%c]\n", tt_global_entry->common.addr, orig_entry->ttvn, orig_entry->orig_node->orig, last_ttvn, - (flags & TT_CLIENT_ROAM ? 'R' : '.'), - (flags & TT_CLIENT_WIFI ? 'W' : '.')); + (flags & BATADV_TT_CLIENT_ROAM ? 'R' : '.'), + (flags & BATADV_TT_CLIENT_WIFI ? 'W' : '.')); } } int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset) { struct net_device *net_dev = (struct net_device *)seq->private; - struct bat_priv *bat_priv = netdev_priv(net_dev); - struct hashtable_t *hash = bat_priv->tt_global_hash; - struct tt_common_entry *tt_common_entry; - struct tt_global_entry *tt_global_entry; - struct hard_iface *primary_if; + struct batadv_priv *bat_priv = netdev_priv(net_dev); + struct batadv_hashtable *hash = bat_priv->tt_global_hash; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_global_entry *tt_global; + struct batadv_hard_iface *primary_if; struct hlist_node *node; struct hlist_head *head; uint32_t i; @@ -785,7 +799,7 @@ int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset) goto out; } - if (primary_if->if_status != IF_ACTIVE) { + if (primary_if->if_status != BATADV_IF_ACTIVE) { ret = seq_printf(seq, "BATMAN mesh %s disabled - primary interface not active\n", net_dev->name); @@ -804,10 +818,10 @@ int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset) rcu_read_lock(); hlist_for_each_entry_rcu(tt_common_entry, node, head, hash_entry) { - tt_global_entry = container_of(tt_common_entry, - struct tt_global_entry, - common); - batadv_tt_global_print_entry(tt_global_entry, seq); + tt_global = container_of(tt_common_entry, + struct batadv_tt_global_entry, + common); + batadv_tt_global_print_entry(tt_global, seq); } rcu_read_unlock(); } @@ -819,11 +833,11 @@ out: /* deletes the orig list of a tt_global_entry */ static void -batadv_tt_global_del_orig_list(struct tt_global_entry *tt_global_entry) +batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry) { struct hlist_head *head; struct hlist_node *node, *safe; - struct tt_orig_list_entry *orig_entry; + struct batadv_tt_orig_list_entry *orig_entry; spin_lock_bh(&tt_global_entry->list_lock); head = &tt_global_entry->orig_list; @@ -836,20 +850,20 @@ batadv_tt_global_del_orig_list(struct tt_global_entry *tt_global_entry) } static void -batadv_tt_global_del_orig_entry(struct bat_priv *bat_priv, - struct tt_global_entry *tt_global_entry, - struct orig_node *orig_node, +batadv_tt_global_del_orig_entry(struct batadv_priv *bat_priv, + struct batadv_tt_global_entry *tt_global_entry, + struct batadv_orig_node *orig_node, const char *message) { struct hlist_head *head; struct hlist_node *node, *safe; - struct tt_orig_list_entry *orig_entry; + struct batadv_tt_orig_list_entry *orig_entry; spin_lock_bh(&tt_global_entry->list_lock); head = &tt_global_entry->orig_list; hlist_for_each_entry_safe(orig_entry, node, safe, head, list) { if (orig_entry->orig_node == orig_node) { - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Deleting %pM from global tt entry %pM: %s\n", orig_node->orig, tt_global_entry->common.addr, message); @@ -860,11 +874,13 @@ batadv_tt_global_del_orig_entry(struct bat_priv *bat_priv, spin_unlock_bh(&tt_global_entry->list_lock); } -static void batadv_tt_global_del_struct(struct bat_priv *bat_priv, - struct tt_global_entry *tt_global_entry, - const char *message) +static void +batadv_tt_global_del_struct(struct batadv_priv *bat_priv, + struct batadv_tt_global_entry *tt_global_entry, + const char *message) { - batadv_dbg(DBG_TT, bat_priv, "Deleting global tt entry %pM: %s\n", + batadv_dbg(BATADV_DBG_TT, bat_priv, + "Deleting global tt entry %pM: %s\n", tt_global_entry->common.addr, message); batadv_hash_remove(bat_priv->tt_global_hash, batadv_compare_tt, @@ -874,18 +890,19 @@ static void batadv_tt_global_del_struct(struct bat_priv *bat_priv, } /* If the client is to be deleted, we check if it is the last origantor entry - * within tt_global entry. If yes, we set the TT_CLIENT_ROAM flag and the timer, - * otherwise we simply remove the originator scheduled for deletion. + * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the + * timer, otherwise we simply remove the originator scheduled for deletion. */ static void -batadv_tt_global_del_roaming(struct bat_priv *bat_priv, - struct tt_global_entry *tt_global_entry, - struct orig_node *orig_node, const char *message) +batadv_tt_global_del_roaming(struct batadv_priv *bat_priv, + struct batadv_tt_global_entry *tt_global_entry, + struct batadv_orig_node *orig_node, + const char *message) { bool last_entry = true; struct hlist_head *head; struct hlist_node *node; - struct tt_orig_list_entry *orig_entry; + struct batadv_tt_orig_list_entry *orig_entry; /* no local entry exists, case 1: * Check if this is the last one or if other entries exist. @@ -903,7 +920,7 @@ batadv_tt_global_del_roaming(struct bat_priv *bat_priv, if (last_entry) { /* its the last one, mark for roaming. */ - tt_global_entry->common.flags |= TT_CLIENT_ROAM; + tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM; tt_global_entry->roam_at = jiffies; } else /* there is another entry, we can simply delete this @@ -915,13 +932,13 @@ batadv_tt_global_del_roaming(struct bat_priv *bat_priv, -static void batadv_tt_global_del(struct bat_priv *bat_priv, - struct orig_node *orig_node, +static void batadv_tt_global_del(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const unsigned char *addr, const char *message, bool roaming) { - struct tt_global_entry *tt_global_entry = NULL; - struct tt_local_entry *local_entry = NULL; + struct batadv_tt_global_entry *tt_global_entry = NULL; + struct batadv_tt_local_entry *local_entry = NULL; tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr); if (!tt_global_entry) @@ -942,7 +959,7 @@ static void batadv_tt_global_del(struct bat_priv *bat_priv, * event, there are two possibilities: * 1) the client roamed from node A to node B => if there * is only one originator left for this client, we mark - * it with TT_CLIENT_ROAM, we start a timer and we + * it with BATADV_TT_CLIENT_ROAM, we start a timer and we * wait for node B to claim it. In case of timeout * the entry is purged. * @@ -970,13 +987,14 @@ out: batadv_tt_local_entry_free_ref(local_entry); } -void batadv_tt_global_del_orig(struct bat_priv *bat_priv, - struct orig_node *orig_node, const char *message) +void batadv_tt_global_del_orig(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + const char *message) { - struct tt_global_entry *global_entry; - struct tt_common_entry *tt_common_entry; + struct batadv_tt_global_entry *tt_global; + struct batadv_tt_common_entry *tt_common_entry; uint32_t i; - struct hashtable_t *hash = bat_priv->tt_global_hash; + struct batadv_hashtable *hash = bat_priv->tt_global_hash; struct hlist_node *node, *safe; struct hlist_head *head; spinlock_t *list_lock; /* protects write access to the hash lists */ @@ -991,19 +1009,19 @@ void batadv_tt_global_del_orig(struct bat_priv *bat_priv, spin_lock_bh(list_lock); hlist_for_each_entry_safe(tt_common_entry, node, safe, head, hash_entry) { - global_entry = container_of(tt_common_entry, - struct tt_global_entry, - common); + tt_global = container_of(tt_common_entry, + struct batadv_tt_global_entry, + common); - batadv_tt_global_del_orig_entry(bat_priv, global_entry, + batadv_tt_global_del_orig_entry(bat_priv, tt_global, orig_node, message); - if (hlist_empty(&global_entry->orig_list)) { - batadv_dbg(DBG_TT, bat_priv, + if (hlist_empty(&tt_global->orig_list)) { + batadv_dbg(BATADV_DBG_TT, bat_priv, "Deleting global tt entry %pM: %s\n", - global_entry->common.addr, message); + tt_global->common.addr, message); hlist_del_rcu(node); - batadv_tt_global_entry_free_ref(global_entry); + batadv_tt_global_entry_free_ref(tt_global); } } spin_unlock_bh(list_lock); @@ -1011,24 +1029,25 @@ void batadv_tt_global_del_orig(struct bat_priv *bat_priv, orig_node->tt_initialised = false; } -static void batadv_tt_global_roam_purge_list(struct bat_priv *bat_priv, +static void batadv_tt_global_roam_purge_list(struct batadv_priv *bat_priv, struct hlist_head *head) { - struct tt_common_entry *tt_common_entry; - struct tt_global_entry *tt_global_entry; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_global_entry *tt_global_entry; struct hlist_node *node, *node_tmp; hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, head, hash_entry) { tt_global_entry = container_of(tt_common_entry, - struct tt_global_entry, common); - if (!(tt_global_entry->common.flags & TT_CLIENT_ROAM)) + struct batadv_tt_global_entry, + common); + if (!(tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM)) continue; if (!batadv_has_timed_out(tt_global_entry->roam_at, BATADV_TT_CLIENT_ROAM_TIMEOUT)) continue; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Deleting global tt entry (%pM): Roaming timeout\n", tt_global_entry->common.addr); @@ -1037,9 +1056,9 @@ static void batadv_tt_global_roam_purge_list(struct bat_priv *bat_priv, } } -static void batadv_tt_global_roam_purge(struct bat_priv *bat_priv) +static void batadv_tt_global_roam_purge(struct batadv_priv *bat_priv) { - struct hashtable_t *hash = bat_priv->tt_global_hash; + struct batadv_hashtable *hash = bat_priv->tt_global_hash; struct hlist_head *head; spinlock_t *list_lock; /* protects write access to the hash lists */ uint32_t i; @@ -1055,12 +1074,12 @@ static void batadv_tt_global_roam_purge(struct bat_priv *bat_priv) } -static void batadv_tt_global_table_free(struct bat_priv *bat_priv) +static void batadv_tt_global_table_free(struct batadv_priv *bat_priv) { - struct hashtable_t *hash; + struct batadv_hashtable *hash; spinlock_t *list_lock; /* protects write access to the hash lists */ - struct tt_common_entry *tt_common_entry; - struct tt_global_entry *tt_global_entry; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_global_entry *tt_global; struct hlist_node *node, *node_tmp; struct hlist_head *head; uint32_t i; @@ -1078,10 +1097,10 @@ static void batadv_tt_global_table_free(struct bat_priv *bat_priv) hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, head, hash_entry) { hlist_del_rcu(node); - tt_global_entry = container_of(tt_common_entry, - struct tt_global_entry, - common); - batadv_tt_global_entry_free_ref(tt_global_entry); + tt_global = container_of(tt_common_entry, + struct batadv_tt_global_entry, + common); + batadv_tt_global_entry_free_ref(tt_global); } spin_unlock_bh(list_lock); } @@ -1091,29 +1110,30 @@ static void batadv_tt_global_table_free(struct bat_priv *bat_priv) bat_priv->tt_global_hash = NULL; } -static bool _batadv_is_ap_isolated(struct tt_local_entry *tt_local_entry, - struct tt_global_entry *tt_global_entry) +static bool +_batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry, + struct batadv_tt_global_entry *tt_global_entry) { bool ret = false; - if (tt_local_entry->common.flags & TT_CLIENT_WIFI && - tt_global_entry->common.flags & TT_CLIENT_WIFI) + if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI && + tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI) ret = true; return ret; } -struct orig_node *batadv_transtable_search(struct bat_priv *bat_priv, - const uint8_t *src, - const uint8_t *addr) +struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv, + const uint8_t *src, + const uint8_t *addr) { - struct tt_local_entry *tt_local_entry = NULL; - struct tt_global_entry *tt_global_entry = NULL; - struct orig_node *orig_node = NULL; - struct neigh_node *router = NULL; + struct batadv_tt_local_entry *tt_local_entry = NULL; + struct batadv_tt_global_entry *tt_global_entry = NULL; + struct batadv_orig_node *orig_node = NULL; + struct batadv_neigh_node *router = NULL; struct hlist_head *head; struct hlist_node *node; - struct tt_orig_list_entry *orig_entry; + struct batadv_tt_orig_list_entry *orig_entry; int best_tq; if (src && atomic_read(&bat_priv->ap_isolation)) { @@ -1162,13 +1182,13 @@ out: } /* Calculates the checksum of the local table of a given orig_node */ -static uint16_t batadv_tt_global_crc(struct bat_priv *bat_priv, - struct orig_node *orig_node) +static uint16_t batadv_tt_global_crc(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node) { uint16_t total = 0, total_one; - struct hashtable_t *hash = bat_priv->tt_global_hash; - struct tt_common_entry *tt_common_entry; - struct tt_global_entry *tt_global_entry; + struct batadv_hashtable *hash = bat_priv->tt_global_hash; + struct batadv_tt_common_entry *tt_common; + struct batadv_tt_global_entry *tt_global; struct hlist_node *node; struct hlist_head *head; uint32_t i; @@ -1178,30 +1198,29 @@ static uint16_t batadv_tt_global_crc(struct bat_priv *bat_priv, head = &hash->table[i]; rcu_read_lock(); - hlist_for_each_entry_rcu(tt_common_entry, node, - head, hash_entry) { - tt_global_entry = container_of(tt_common_entry, - struct tt_global_entry, - common); + hlist_for_each_entry_rcu(tt_common, node, head, hash_entry) { + tt_global = container_of(tt_common, + struct batadv_tt_global_entry, + common); /* Roaming clients are in the global table for * consistency only. They don't have to be * taken into account while computing the * global crc */ - if (tt_global_entry->common.flags & TT_CLIENT_ROAM) + if (tt_common->flags & BATADV_TT_CLIENT_ROAM) continue; /* find out if this global entry is announced by this * originator */ - if (!batadv_tt_global_entry_has_orig(tt_global_entry, + if (!batadv_tt_global_entry_has_orig(tt_global, orig_node)) continue; total_one = 0; for (j = 0; j < ETH_ALEN; j++) total_one = crc16_byte(total_one, - tt_global_entry->common.addr[j]); + tt_common->addr[j]); total ^= total_one; } rcu_read_unlock(); @@ -1211,11 +1230,11 @@ static uint16_t batadv_tt_global_crc(struct bat_priv *bat_priv, } /* Calculates the checksum of the local table */ -static uint16_t batadv_tt_local_crc(struct bat_priv *bat_priv) +static uint16_t batadv_tt_local_crc(struct batadv_priv *bat_priv) { uint16_t total = 0, total_one; - struct hashtable_t *hash = bat_priv->tt_local_hash; - struct tt_common_entry *tt_common_entry; + struct batadv_hashtable *hash = bat_priv->tt_local_hash; + struct batadv_tt_common_entry *tt_common; struct hlist_node *node; struct hlist_head *head; uint32_t i; @@ -1225,17 +1244,16 @@ static uint16_t batadv_tt_local_crc(struct bat_priv *bat_priv) head = &hash->table[i]; rcu_read_lock(); - hlist_for_each_entry_rcu(tt_common_entry, node, - head, hash_entry) { + hlist_for_each_entry_rcu(tt_common, node, head, hash_entry) { /* not yet committed clients have not to be taken into * account while computing the CRC */ - if (tt_common_entry->flags & TT_CLIENT_NEW) + if (tt_common->flags & BATADV_TT_CLIENT_NEW) continue; total_one = 0; for (j = 0; j < ETH_ALEN; j++) total_one = crc16_byte(total_one, - tt_common_entry->addr[j]); + tt_common->addr[j]); total ^= total_one; } rcu_read_unlock(); @@ -1244,9 +1262,9 @@ static uint16_t batadv_tt_local_crc(struct bat_priv *bat_priv) return total; } -static void batadv_tt_req_list_free(struct bat_priv *bat_priv) +static void batadv_tt_req_list_free(struct batadv_priv *bat_priv) { - struct tt_req_node *node, *safe; + struct batadv_tt_req_node *node, *safe; spin_lock_bh(&bat_priv->tt_req_list_lock); @@ -1258,8 +1276,8 @@ static void batadv_tt_req_list_free(struct bat_priv *bat_priv) spin_unlock_bh(&bat_priv->tt_req_list_lock); } -static void batadv_tt_save_orig_buffer(struct bat_priv *bat_priv, - struct orig_node *orig_node, +static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const unsigned char *tt_buff, uint8_t tt_num_changes) { @@ -1281,9 +1299,9 @@ static void batadv_tt_save_orig_buffer(struct bat_priv *bat_priv, spin_unlock_bh(&orig_node->tt_buff_lock); } -static void batadv_tt_req_purge(struct bat_priv *bat_priv) +static void batadv_tt_req_purge(struct batadv_priv *bat_priv) { - struct tt_req_node *node, *safe; + struct batadv_tt_req_node *node, *safe; spin_lock_bh(&bat_priv->tt_req_list_lock); list_for_each_entry_safe(node, safe, &bat_priv->tt_req_list, list) { @@ -1299,10 +1317,11 @@ static void batadv_tt_req_purge(struct bat_priv *bat_priv) /* returns the pointer to the new tt_req_node struct if no request * has already been issued for this orig_node, NULL otherwise */ -static struct tt_req_node *batadv_new_tt_req_node(struct bat_priv *bat_priv, - struct orig_node *orig_node) +static struct batadv_tt_req_node * +batadv_new_tt_req_node(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node) { - struct tt_req_node *tt_req_node_tmp, *tt_req_node = NULL; + struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL; spin_lock_bh(&bat_priv->tt_req_list_lock); list_for_each_entry(tt_req_node_tmp, &bat_priv->tt_req_list, list) { @@ -1329,9 +1348,9 @@ unlock: static int batadv_tt_local_valid_entry(const void *entry_ptr, const void *data_ptr) { - const struct tt_common_entry *tt_common_entry = entry_ptr; + const struct batadv_tt_common_entry *tt_common_entry = entry_ptr; - if (tt_common_entry->flags & TT_CLIENT_NEW) + if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW) return 0; return 1; } @@ -1339,14 +1358,15 @@ static int batadv_tt_local_valid_entry(const void *entry_ptr, static int batadv_tt_global_valid(const void *entry_ptr, const void *data_ptr) { - const struct tt_common_entry *tt_common_entry = entry_ptr; - const struct tt_global_entry *tt_global_entry; - const struct orig_node *orig_node = data_ptr; + const struct batadv_tt_common_entry *tt_common_entry = entry_ptr; + const struct batadv_tt_global_entry *tt_global_entry; + const struct batadv_orig_node *orig_node = data_ptr; - if (tt_common_entry->flags & TT_CLIENT_ROAM) + if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM) return 0; - tt_global_entry = container_of(tt_common_entry, struct tt_global_entry, + tt_global_entry = container_of(tt_common_entry, + struct batadv_tt_global_entry, common); return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node); @@ -1354,37 +1374,38 @@ static int batadv_tt_global_valid(const void *entry_ptr, static struct sk_buff * batadv_tt_response_fill_table(uint16_t tt_len, uint8_t ttvn, - struct hashtable_t *hash, - struct hard_iface *primary_if, + struct batadv_hashtable *hash, + struct batadv_hard_iface *primary_if, int (*valid_cb)(const void *, const void *), void *cb_data) { - struct tt_common_entry *tt_common_entry; - struct tt_query_packet *tt_response; - struct tt_change *tt_change; + struct batadv_tt_common_entry *tt_common_entry; + struct batadv_tt_query_packet *tt_response; + struct batadv_tt_change *tt_change; struct hlist_node *node; struct hlist_head *head; struct sk_buff *skb = NULL; uint16_t tt_tot, tt_count; - ssize_t tt_query_size = sizeof(struct tt_query_packet); + ssize_t tt_query_size = sizeof(struct batadv_tt_query_packet); uint32_t i; + size_t len; if (tt_query_size + tt_len > primary_if->soft_iface->mtu) { tt_len = primary_if->soft_iface->mtu - tt_query_size; - tt_len -= tt_len % sizeof(struct tt_change); + tt_len -= tt_len % sizeof(struct batadv_tt_change); } - tt_tot = tt_len / sizeof(struct tt_change); + tt_tot = tt_len / sizeof(struct batadv_tt_change); - skb = dev_alloc_skb(tt_query_size + tt_len + ETH_HLEN); + len = tt_query_size + tt_len; + skb = dev_alloc_skb(len + ETH_HLEN); if (!skb) goto out; skb_reserve(skb, ETH_HLEN); - tt_response = (struct tt_query_packet *)skb_put(skb, - tt_query_size + tt_len); + tt_response = (struct batadv_tt_query_packet *)skb_put(skb, len); tt_response->ttvn = ttvn; - tt_change = (struct tt_change *)(skb->data + tt_query_size); + tt_change = (struct batadv_tt_change *)(skb->data + tt_query_size); tt_count = 0; rcu_read_lock(); @@ -1418,17 +1439,18 @@ out: return skb; } -static int batadv_send_tt_request(struct bat_priv *bat_priv, - struct orig_node *dst_orig_node, +static int batadv_send_tt_request(struct batadv_priv *bat_priv, + struct batadv_orig_node *dst_orig_node, uint8_t ttvn, uint16_t tt_crc, bool full_table) { struct sk_buff *skb = NULL; - struct tt_query_packet *tt_request; - struct neigh_node *neigh_node = NULL; - struct hard_iface *primary_if; - struct tt_req_node *tt_req_node = NULL; + struct batadv_tt_query_packet *tt_request; + struct batadv_neigh_node *neigh_node = NULL; + struct batadv_hard_iface *primary_if; + struct batadv_tt_req_node *tt_req_node = NULL; int ret = 1; + size_t tt_req_len; primary_if = batadv_primary_if_get_selected(bat_priv); if (!primary_if) @@ -1441,37 +1463,37 @@ static int batadv_send_tt_request(struct bat_priv *bat_priv, if (!tt_req_node) goto out; - skb = dev_alloc_skb(sizeof(struct tt_query_packet) + ETH_HLEN); + skb = dev_alloc_skb(sizeof(*tt_request) + ETH_HLEN); if (!skb) goto out; skb_reserve(skb, ETH_HLEN); - tt_request = (struct tt_query_packet *)skb_put(skb, - sizeof(struct tt_query_packet)); + tt_req_len = sizeof(*tt_request); + tt_request = (struct batadv_tt_query_packet *)skb_put(skb, tt_req_len); - tt_request->header.packet_type = BAT_TT_QUERY; + tt_request->header.packet_type = BATADV_TT_QUERY; tt_request->header.version = BATADV_COMPAT_VERSION; memcpy(tt_request->src, primary_if->net_dev->dev_addr, ETH_ALEN); memcpy(tt_request->dst, dst_orig_node->orig, ETH_ALEN); tt_request->header.ttl = BATADV_TTL; tt_request->ttvn = ttvn; tt_request->tt_data = htons(tt_crc); - tt_request->flags = TT_REQUEST; + tt_request->flags = BATADV_TT_REQUEST; if (full_table) - tt_request->flags |= TT_FULL_TABLE; + tt_request->flags |= BATADV_TT_FULL_TABLE; neigh_node = batadv_orig_node_get_router(dst_orig_node); if (!neigh_node) goto out; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM via %pM [%c]\n", dst_orig_node->orig, neigh_node->addr, (full_table ? 'F' : '.')); - batadv_inc_counter(bat_priv, BAT_CNT_TT_REQUEST_TX); + batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX); batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); ret = 0; @@ -1492,24 +1514,27 @@ out: return ret; } -static bool batadv_send_other_tt_response(struct bat_priv *bat_priv, - struct tt_query_packet *tt_request) +static bool +batadv_send_other_tt_response(struct batadv_priv *bat_priv, + struct batadv_tt_query_packet *tt_request) { - struct orig_node *req_dst_orig_node = NULL, *res_dst_orig_node = NULL; - struct neigh_node *neigh_node = NULL; - struct hard_iface *primary_if = NULL; + struct batadv_orig_node *req_dst_orig_node = NULL; + struct batadv_orig_node *res_dst_orig_node = NULL; + struct batadv_neigh_node *neigh_node = NULL; + struct batadv_hard_iface *primary_if = NULL; uint8_t orig_ttvn, req_ttvn, ttvn; int ret = false; unsigned char *tt_buff; bool full_table; uint16_t tt_len, tt_tot; struct sk_buff *skb = NULL; - struct tt_query_packet *tt_response; + struct batadv_tt_query_packet *tt_response; + size_t len; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n", tt_request->src, tt_request->ttvn, tt_request->dst, - (tt_request->flags & TT_FULL_TABLE ? 'F' : '.')); + (tt_request->flags & BATADV_TT_FULL_TABLE ? 'F' : '.')); /* Let's get the orig node of the REAL destination */ req_dst_orig_node = batadv_orig_hash_find(bat_priv, tt_request->dst); @@ -1537,7 +1562,7 @@ static bool batadv_send_other_tt_response(struct bat_priv *bat_priv, goto out; /* If the full table has been explicitly requested */ - if (tt_request->flags & TT_FULL_TABLE || + if (tt_request->flags & BATADV_TT_FULL_TABLE || !req_dst_orig_node->tt_buff) full_table = true; else @@ -1549,28 +1574,28 @@ static bool batadv_send_other_tt_response(struct bat_priv *bat_priv, if (!full_table) { spin_lock_bh(&req_dst_orig_node->tt_buff_lock); tt_len = req_dst_orig_node->tt_buff_len; - tt_tot = tt_len / sizeof(struct tt_change); + tt_tot = tt_len / sizeof(struct batadv_tt_change); - skb = dev_alloc_skb(sizeof(struct tt_query_packet) + - tt_len + ETH_HLEN); + len = sizeof(*tt_response) + tt_len; + skb = dev_alloc_skb(len + ETH_HLEN); if (!skb) goto unlock; skb_reserve(skb, ETH_HLEN); - tt_response = (struct tt_query_packet *)skb_put(skb, - sizeof(struct tt_query_packet) + tt_len); + tt_response = (struct batadv_tt_query_packet *)skb_put(skb, + len); tt_response->ttvn = req_ttvn; tt_response->tt_data = htons(tt_tot); - tt_buff = skb->data + sizeof(struct tt_query_packet); + tt_buff = skb->data + sizeof(*tt_response); /* Copy the last orig_node's OGM buffer */ memcpy(tt_buff, req_dst_orig_node->tt_buff, req_dst_orig_node->tt_buff_len); spin_unlock_bh(&req_dst_orig_node->tt_buff_lock); } else { - tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size) * - sizeof(struct tt_change); + tt_len = (uint16_t)atomic_read(&req_dst_orig_node->tt_size); + tt_len *= sizeof(struct batadv_tt_change); ttvn = (uint8_t)atomic_read(&req_dst_orig_node->last_ttvn); skb = batadv_tt_response_fill_table(tt_len, ttvn, @@ -1581,25 +1606,25 @@ static bool batadv_send_other_tt_response(struct bat_priv *bat_priv, if (!skb) goto out; - tt_response = (struct tt_query_packet *)skb->data; + tt_response = (struct batadv_tt_query_packet *)skb->data; } - tt_response->header.packet_type = BAT_TT_QUERY; + tt_response->header.packet_type = BATADV_TT_QUERY; tt_response->header.version = BATADV_COMPAT_VERSION; tt_response->header.ttl = BATADV_TTL; memcpy(tt_response->src, req_dst_orig_node->orig, ETH_ALEN); memcpy(tt_response->dst, tt_request->src, ETH_ALEN); - tt_response->flags = TT_RESPONSE; + tt_response->flags = BATADV_TT_RESPONSE; if (full_table) - tt_response->flags |= TT_FULL_TABLE; + tt_response->flags |= BATADV_TT_FULL_TABLE; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_RESPONSE %pM via %pM for %pM (ttvn: %u)\n", res_dst_orig_node->orig, neigh_node->addr, req_dst_orig_node->orig, req_ttvn); - batadv_inc_counter(bat_priv, BAT_CNT_TT_RESPONSE_TX); + batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX); batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); ret = true; @@ -1622,24 +1647,27 @@ out: return ret; } -static bool batadv_send_my_tt_response(struct bat_priv *bat_priv, - struct tt_query_packet *tt_request) + +static bool +batadv_send_my_tt_response(struct batadv_priv *bat_priv, + struct batadv_tt_query_packet *tt_request) { - struct orig_node *orig_node = NULL; - struct neigh_node *neigh_node = NULL; - struct hard_iface *primary_if = NULL; + struct batadv_orig_node *orig_node = NULL; + struct batadv_neigh_node *neigh_node = NULL; + struct batadv_hard_iface *primary_if = NULL; uint8_t my_ttvn, req_ttvn, ttvn; int ret = false; unsigned char *tt_buff; bool full_table; uint16_t tt_len, tt_tot; struct sk_buff *skb = NULL; - struct tt_query_packet *tt_response; + struct batadv_tt_query_packet *tt_response; + size_t len; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n", tt_request->src, tt_request->ttvn, - (tt_request->flags & TT_FULL_TABLE ? 'F' : '.')); + (tt_request->flags & BATADV_TT_FULL_TABLE ? 'F' : '.')); my_ttvn = (uint8_t)atomic_read(&bat_priv->ttvn); @@ -1660,7 +1688,7 @@ static bool batadv_send_my_tt_response(struct bat_priv *bat_priv, /* If the full table has been explicitly requested or the gap * is too big send the whole local translation table */ - if (tt_request->flags & TT_FULL_TABLE || my_ttvn != req_ttvn || + if (tt_request->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn || !bat_priv->tt_buff) full_table = true; else @@ -1672,26 +1700,26 @@ static bool batadv_send_my_tt_response(struct bat_priv *bat_priv, if (!full_table) { spin_lock_bh(&bat_priv->tt_buff_lock); tt_len = bat_priv->tt_buff_len; - tt_tot = tt_len / sizeof(struct tt_change); + tt_tot = tt_len / sizeof(struct batadv_tt_change); - skb = dev_alloc_skb(sizeof(struct tt_query_packet) + - tt_len + ETH_HLEN); + len = sizeof(*tt_response) + tt_len; + skb = dev_alloc_skb(len + ETH_HLEN); if (!skb) goto unlock; skb_reserve(skb, ETH_HLEN); - tt_response = (struct tt_query_packet *)skb_put(skb, - sizeof(struct tt_query_packet) + tt_len); + tt_response = (struct batadv_tt_query_packet *)skb_put(skb, + len); tt_response->ttvn = req_ttvn; tt_response->tt_data = htons(tt_tot); - tt_buff = skb->data + sizeof(struct tt_query_packet); + tt_buff = skb->data + sizeof(*tt_response); memcpy(tt_buff, bat_priv->tt_buff, bat_priv->tt_buff_len); spin_unlock_bh(&bat_priv->tt_buff_lock); } else { - tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt) * - sizeof(struct tt_change); + tt_len = (uint16_t)atomic_read(&bat_priv->num_local_tt); + tt_len *= sizeof(struct batadv_tt_change); ttvn = (uint8_t)atomic_read(&bat_priv->ttvn); skb = batadv_tt_response_fill_table(tt_len, ttvn, @@ -1702,25 +1730,25 @@ static bool batadv_send_my_tt_response(struct bat_priv *bat_priv, if (!skb) goto out; - tt_response = (struct tt_query_packet *)skb->data; + tt_response = (struct batadv_tt_query_packet *)skb->data; } - tt_response->header.packet_type = BAT_TT_QUERY; + tt_response->header.packet_type = BATADV_TT_QUERY; tt_response->header.version = BATADV_COMPAT_VERSION; tt_response->header.ttl = BATADV_TTL; memcpy(tt_response->src, primary_if->net_dev->dev_addr, ETH_ALEN); memcpy(tt_response->dst, tt_request->src, ETH_ALEN); - tt_response->flags = TT_RESPONSE; + tt_response->flags = BATADV_TT_RESPONSE; if (full_table) - tt_response->flags |= TT_FULL_TABLE; + tt_response->flags |= BATADV_TT_FULL_TABLE; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_RESPONSE to %pM via %pM [%c]\n", orig_node->orig, neigh_node->addr, - (tt_response->flags & TT_FULL_TABLE ? 'F' : '.')); + (tt_response->flags & BATADV_TT_FULL_TABLE ? 'F' : '.')); - batadv_inc_counter(bat_priv, BAT_CNT_TT_RESPONSE_TX); + batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX); batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); ret = true; @@ -1741,8 +1769,8 @@ out: return true; } -bool batadv_send_tt_response(struct bat_priv *bat_priv, - struct tt_query_packet *tt_request) +bool batadv_send_tt_response(struct batadv_priv *bat_priv, + struct batadv_tt_query_packet *tt_request) { if (batadv_is_my_mac(tt_request->dst)) { /* don't answer backbone gws! */ @@ -1755,17 +1783,17 @@ bool batadv_send_tt_response(struct bat_priv *bat_priv, } } -static void _batadv_tt_update_changes(struct bat_priv *bat_priv, - struct orig_node *orig_node, - struct tt_change *tt_change, +static void _batadv_tt_update_changes(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, + struct batadv_tt_change *tt_change, uint16_t tt_num_changes, uint8_t ttvn) { int i; int roams; for (i = 0; i < tt_num_changes; i++) { - if ((tt_change + i)->flags & TT_CLIENT_DEL) { - roams = (tt_change + i)->flags & TT_CLIENT_ROAM; + if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) { + roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM; batadv_tt_global_del(bat_priv, orig_node, (tt_change + i)->addr, "tt removed by changes", @@ -1786,10 +1814,10 @@ static void _batadv_tt_update_changes(struct bat_priv *bat_priv, orig_node->tt_initialised = true; } -static void batadv_tt_fill_gtable(struct bat_priv *bat_priv, - struct tt_query_packet *tt_response) +static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv, + struct batadv_tt_query_packet *tt_response) { - struct orig_node *orig_node = NULL; + struct batadv_orig_node *orig_node = NULL; orig_node = batadv_orig_hash_find(bat_priv, tt_response->src); if (!orig_node) @@ -1799,7 +1827,7 @@ static void batadv_tt_fill_gtable(struct bat_priv *bat_priv, batadv_tt_global_del_orig(bat_priv, orig_node, "Received full table"); _batadv_tt_update_changes(bat_priv, orig_node, - (struct tt_change *)(tt_response + 1), + (struct batadv_tt_change *)(tt_response + 1), ntohs(tt_response->tt_data), tt_response->ttvn); @@ -1816,10 +1844,10 @@ out: batadv_orig_node_free_ref(orig_node); } -static void batadv_tt_update_changes(struct bat_priv *bat_priv, - struct orig_node *orig_node, +static void batadv_tt_update_changes(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, uint16_t tt_num_changes, uint8_t ttvn, - struct tt_change *tt_change) + struct batadv_tt_change *tt_change) { _batadv_tt_update_changes(bat_priv, orig_node, tt_change, tt_num_changes, ttvn); @@ -1829,9 +1857,9 @@ static void batadv_tt_update_changes(struct bat_priv *bat_priv, atomic_set(&orig_node->last_ttvn, ttvn); } -bool batadv_is_my_client(struct bat_priv *bat_priv, const uint8_t *addr) +bool batadv_is_my_client(struct batadv_priv *bat_priv, const uint8_t *addr) { - struct tt_local_entry *tt_local_entry = NULL; + struct batadv_tt_local_entry *tt_local_entry = NULL; bool ret = false; tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr); @@ -1840,7 +1868,7 @@ bool batadv_is_my_client(struct bat_priv *bat_priv, const uint8_t *addr) /* Check if the client has been logically deleted (but is kept for * consistency purpose) */ - if (tt_local_entry->common.flags & TT_CLIENT_PENDING) + if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) goto out; ret = true; out: @@ -1849,17 +1877,18 @@ out: return ret; } -void batadv_handle_tt_response(struct bat_priv *bat_priv, - struct tt_query_packet *tt_response) +void batadv_handle_tt_response(struct batadv_priv *bat_priv, + struct batadv_tt_query_packet *tt_response) { - struct tt_req_node *node, *safe; - struct orig_node *orig_node = NULL; + struct batadv_tt_req_node *node, *safe; + struct batadv_orig_node *orig_node = NULL; + struct batadv_tt_change *tt_change; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n", tt_response->src, tt_response->ttvn, ntohs(tt_response->tt_data), - (tt_response->flags & TT_FULL_TABLE ? 'F' : '.')); + (tt_response->flags & BATADV_TT_FULL_TABLE ? 'F' : '.')); /* we should have never asked a backbone gw */ if (batadv_bla_is_backbone_gw_orig(bat_priv, tt_response->src)) @@ -1869,13 +1898,14 @@ void batadv_handle_tt_response(struct bat_priv *bat_priv, if (!orig_node) goto out; - if (tt_response->flags & TT_FULL_TABLE) + if (tt_response->flags & BATADV_TT_FULL_TABLE) { batadv_tt_fill_gtable(bat_priv, tt_response); - else + } else { + tt_change = (struct batadv_tt_change *)(tt_response + 1); batadv_tt_update_changes(bat_priv, orig_node, ntohs(tt_response->tt_data), - tt_response->ttvn, - (struct tt_change *)(tt_response + 1)); + tt_response->ttvn, tt_change); + } /* Delete the tt_req_node from pending tt_requests list */ spin_lock_bh(&bat_priv->tt_req_list_lock); @@ -1898,7 +1928,7 @@ out: batadv_orig_node_free_ref(orig_node); } -int batadv_tt_init(struct bat_priv *bat_priv) +int batadv_tt_init(struct batadv_priv *bat_priv) { int ret; @@ -1915,9 +1945,9 @@ int batadv_tt_init(struct bat_priv *bat_priv) return 1; } -static void batadv_tt_roam_list_free(struct bat_priv *bat_priv) +static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv) { - struct tt_roam_node *node, *safe; + struct batadv_tt_roam_node *node, *safe; spin_lock_bh(&bat_priv->tt_roam_list_lock); @@ -1929,9 +1959,9 @@ static void batadv_tt_roam_list_free(struct bat_priv *bat_priv) spin_unlock_bh(&bat_priv->tt_roam_list_lock); } -static void batadv_tt_roam_purge(struct bat_priv *bat_priv) +static void batadv_tt_roam_purge(struct batadv_priv *bat_priv) { - struct tt_roam_node *node, *safe; + struct batadv_tt_roam_node *node, *safe; spin_lock_bh(&bat_priv->tt_roam_list_lock); list_for_each_entry_safe(node, safe, &bat_priv->tt_roam_list, list) { @@ -1951,10 +1981,10 @@ static void batadv_tt_roam_purge(struct bat_priv *bat_priv) * * returns true if the ROAMING_ADV can be sent, false otherwise */ -static bool batadv_tt_check_roam_count(struct bat_priv *bat_priv, +static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, uint8_t *client) { - struct tt_roam_node *tt_roam_node; + struct batadv_tt_roam_node *tt_roam_node; bool ret = false; spin_lock_bh(&bat_priv->tt_roam_list_lock); @@ -1995,14 +2025,15 @@ unlock: return ret; } -static void batadv_send_roam_adv(struct bat_priv *bat_priv, uint8_t *client, - struct orig_node *orig_node) +static void batadv_send_roam_adv(struct batadv_priv *bat_priv, uint8_t *client, + struct batadv_orig_node *orig_node) { - struct neigh_node *neigh_node = NULL; + struct batadv_neigh_node *neigh_node = NULL; struct sk_buff *skb = NULL; - struct roam_adv_packet *roam_adv_packet; + struct batadv_roam_adv_packet *roam_adv_packet; int ret = 1; - struct hard_iface *primary_if; + struct batadv_hard_iface *primary_if; + size_t len = sizeof(*roam_adv_packet); /* before going on we have to check whether the client has * already roamed to us too many times @@ -2010,18 +2041,18 @@ static void batadv_send_roam_adv(struct bat_priv *bat_priv, uint8_t *client, if (!batadv_tt_check_roam_count(bat_priv, client)) goto out; - skb = dev_alloc_skb(sizeof(struct roam_adv_packet) + ETH_HLEN); + skb = dev_alloc_skb(sizeof(*roam_adv_packet) + ETH_HLEN); if (!skb) goto out; skb_reserve(skb, ETH_HLEN); - roam_adv_packet = (struct roam_adv_packet *)skb_put(skb, - sizeof(struct roam_adv_packet)); + roam_adv_packet = (struct batadv_roam_adv_packet *)skb_put(skb, len); - roam_adv_packet->header.packet_type = BAT_ROAM_ADV; + roam_adv_packet->header.packet_type = BATADV_ROAM_ADV; roam_adv_packet->header.version = BATADV_COMPAT_VERSION; roam_adv_packet->header.ttl = BATADV_TTL; + roam_adv_packet->reserved = 0; primary_if = batadv_primary_if_get_selected(bat_priv); if (!primary_if) goto out; @@ -2034,11 +2065,11 @@ static void batadv_send_roam_adv(struct bat_priv *bat_priv, uint8_t *client, if (!neigh_node) goto out; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending ROAMING_ADV to %pM (client %pM) via %pM\n", orig_node->orig, client, neigh_node->addr); - batadv_inc_counter(bat_priv, BAT_CNT_TT_ROAM_ADV_TX); + batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX); batadv_send_skb_packet(skb, neigh_node->if_incoming, neigh_node->addr); ret = 0; @@ -2053,10 +2084,11 @@ out: static void batadv_tt_purge(struct work_struct *work) { - struct delayed_work *delayed_work = - container_of(work, struct delayed_work, work); - struct bat_priv *bat_priv = - container_of(delayed_work, struct bat_priv, tt_work); + struct delayed_work *delayed_work; + struct batadv_priv *bat_priv; + + delayed_work = container_of(work, struct delayed_work, work); + bat_priv = container_of(delayed_work, struct batadv_priv, tt_work); batadv_tt_local_purge(bat_priv); batadv_tt_global_roam_purge(bat_priv); @@ -2066,7 +2098,7 @@ static void batadv_tt_purge(struct work_struct *work) batadv_tt_start_timer(bat_priv); } -void batadv_tt_free(struct bat_priv *bat_priv) +void batadv_tt_free(struct batadv_priv *bat_priv) { cancel_delayed_work_sync(&bat_priv->tt_work); @@ -2082,14 +2114,14 @@ void batadv_tt_free(struct bat_priv *bat_priv) /* This function will enable or disable the specified flags for all the entries * in the given hash table and returns the number of modified entries */ -static uint16_t batadv_tt_set_flags(struct hashtable_t *hash, uint16_t flags, - bool enable) +static uint16_t batadv_tt_set_flags(struct batadv_hashtable *hash, + uint16_t flags, bool enable) { uint32_t i; uint16_t changed_num = 0; struct hlist_head *head; struct hlist_node *node; - struct tt_common_entry *tt_common_entry; + struct batadv_tt_common_entry *tt_common_entry; if (!hash) goto out; @@ -2117,12 +2149,12 @@ out: return changed_num; } -/* Purge out all the tt local entries marked with TT_CLIENT_PENDING */ -static void batadv_tt_local_purge_pending_clients(struct bat_priv *bat_priv) +/* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */ +static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv) { - struct hashtable_t *hash = bat_priv->tt_local_hash; - struct tt_common_entry *tt_common_entry; - struct tt_local_entry *tt_local_entry; + struct batadv_hashtable *hash = bat_priv->tt_local_hash; + struct batadv_tt_common_entry *tt_common; + struct batadv_tt_local_entry *tt_local; struct hlist_node *node, *node_tmp; struct hlist_head *head; spinlock_t *list_lock; /* protects write access to the hash lists */ @@ -2136,28 +2168,28 @@ static void batadv_tt_local_purge_pending_clients(struct bat_priv *bat_priv) list_lock = &hash->list_locks[i]; spin_lock_bh(list_lock); - hlist_for_each_entry_safe(tt_common_entry, node, node_tmp, - head, hash_entry) { - if (!(tt_common_entry->flags & TT_CLIENT_PENDING)) + hlist_for_each_entry_safe(tt_common, node, node_tmp, head, + hash_entry) { + if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING)) continue; - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Deleting local tt entry (%pM): pending\n", - tt_common_entry->addr); + tt_common->addr); atomic_dec(&bat_priv->num_local_tt); hlist_del_rcu(node); - tt_local_entry = container_of(tt_common_entry, - struct tt_local_entry, - common); - batadv_tt_local_entry_free_ref(tt_local_entry); + tt_local = container_of(tt_common, + struct batadv_tt_local_entry, + common); + batadv_tt_local_entry_free_ref(tt_local); } spin_unlock_bh(list_lock); } } -static int batadv_tt_commit_changes(struct bat_priv *bat_priv, +static int batadv_tt_commit_changes(struct batadv_priv *bat_priv, unsigned char **packet_buff, int *packet_buff_len, int packet_min_len) { @@ -2167,7 +2199,7 @@ static int batadv_tt_commit_changes(struct bat_priv *bat_priv, return -ENOENT; changed_num = batadv_tt_set_flags(bat_priv->tt_local_hash, - TT_CLIENT_NEW, false); + BATADV_TT_CLIENT_NEW, false); /* all reset entries have to be counted as local entries */ atomic_add(changed_num, &bat_priv->num_local_tt); @@ -2176,7 +2208,7 @@ static int batadv_tt_commit_changes(struct bat_priv *bat_priv, /* Increment the TTVN only once per OGM interval */ atomic_inc(&bat_priv->ttvn); - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "Local changes committed, updating to ttvn %u\n", (uint8_t)atomic_read(&bat_priv->ttvn)); bat_priv->tt_poss_change = false; @@ -2189,7 +2221,7 @@ static int batadv_tt_commit_changes(struct bat_priv *bat_priv, } /* when calling this function (hard_iface == primary_if) has to be true */ -int batadv_tt_append_diff(struct bat_priv *bat_priv, +int batadv_tt_append_diff(struct batadv_priv *bat_priv, unsigned char **packet_buff, int *packet_buff_len, int packet_min_len) { @@ -2211,11 +2243,11 @@ int batadv_tt_append_diff(struct bat_priv *bat_priv, return tt_num_changes; } -bool batadv_is_ap_isolated(struct bat_priv *bat_priv, uint8_t *src, +bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, uint8_t *src, uint8_t *dst) { - struct tt_local_entry *tt_local_entry = NULL; - struct tt_global_entry *tt_global_entry = NULL; + struct batadv_tt_local_entry *tt_local_entry = NULL; + struct batadv_tt_global_entry *tt_global_entry = NULL; bool ret = false; if (!atomic_read(&bat_priv->ap_isolation)) @@ -2242,13 +2274,14 @@ out: return ret; } -void batadv_tt_update_orig(struct bat_priv *bat_priv, - struct orig_node *orig_node, +void batadv_tt_update_orig(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const unsigned char *tt_buff, uint8_t tt_num_changes, uint8_t ttvn, uint16_t tt_crc) { uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn); bool full_table = true; + struct batadv_tt_change *tt_change; /* don't care about a backbone gateways updates. */ if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig)) @@ -2269,8 +2302,9 @@ void batadv_tt_update_orig(struct bat_priv *bat_priv, goto request_table; } + tt_change = (struct batadv_tt_change *)tt_buff; batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes, - ttvn, (struct tt_change *)tt_buff); + ttvn, tt_change); /* Even if we received the precomputed crc with the OGM, we * prefer to recompute it to spot any possible inconsistency @@ -2301,7 +2335,7 @@ void batadv_tt_update_orig(struct bat_priv *bat_priv, if (!orig_node->tt_initialised || ttvn != orig_ttvn || orig_node->tt_crc != tt_crc) { request_table: - batadv_dbg(DBG_TT, bat_priv, + batadv_dbg(BATADV_DBG_TT, bat_priv, "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u crc: %u last_crc: %u num_changes: %u)\n", orig_node->orig, ttvn, orig_ttvn, tt_crc, orig_node->tt_crc, tt_num_changes); @@ -2316,17 +2350,17 @@ request_table: * originator to another one. This entry is kept is still kept for consistency * purposes */ -bool batadv_tt_global_client_is_roaming(struct bat_priv *bat_priv, +bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv, uint8_t *addr) { - struct tt_global_entry *tt_global_entry; + struct batadv_tt_global_entry *tt_global_entry; bool ret = false; tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr); if (!tt_global_entry) goto out; - ret = tt_global_entry->common.flags & TT_CLIENT_ROAM; + ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM; batadv_tt_global_entry_free_ref(tt_global_entry); out: return ret; diff --git a/net/batman-adv/translation-table.h b/net/batman-adv/translation-table.h index 46b60bd822fe..ffa87355096b 100644 --- a/net/batman-adv/translation-table.h +++ b/net/batman-adv/translation-table.h @@ -21,42 +21,43 @@ #define _NET_BATMAN_ADV_TRANSLATION_TABLE_H_ int batadv_tt_len(int changes_num); -int batadv_tt_init(struct bat_priv *bat_priv); +int batadv_tt_init(struct batadv_priv *bat_priv); void batadv_tt_local_add(struct net_device *soft_iface, const uint8_t *addr, int ifindex); -void batadv_tt_local_remove(struct bat_priv *bat_priv, +void batadv_tt_local_remove(struct batadv_priv *bat_priv, const uint8_t *addr, const char *message, bool roaming); int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset); -void batadv_tt_global_add_orig(struct bat_priv *bat_priv, - struct orig_node *orig_node, +void batadv_tt_global_add_orig(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const unsigned char *tt_buff, int tt_buff_len); -int batadv_tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node, +int batadv_tt_global_add(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const unsigned char *addr, uint8_t flags, uint8_t ttvn); int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset); -void batadv_tt_global_del_orig(struct bat_priv *bat_priv, - struct orig_node *orig_node, +void batadv_tt_global_del_orig(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const char *message); -struct orig_node *batadv_transtable_search(struct bat_priv *bat_priv, - const uint8_t *src, - const uint8_t *addr); -void batadv_tt_free(struct bat_priv *bat_priv); -bool batadv_send_tt_response(struct bat_priv *bat_priv, - struct tt_query_packet *tt_request); -bool batadv_is_my_client(struct bat_priv *bat_priv, const uint8_t *addr); -void batadv_handle_tt_response(struct bat_priv *bat_priv, - struct tt_query_packet *tt_response); -bool batadv_is_ap_isolated(struct bat_priv *bat_priv, uint8_t *src, +struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv, + const uint8_t *src, + const uint8_t *addr); +void batadv_tt_free(struct batadv_priv *bat_priv); +bool batadv_send_tt_response(struct batadv_priv *bat_priv, + struct batadv_tt_query_packet *tt_request); +bool batadv_is_my_client(struct batadv_priv *bat_priv, const uint8_t *addr); +void batadv_handle_tt_response(struct batadv_priv *bat_priv, + struct batadv_tt_query_packet *tt_response); +bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, uint8_t *src, uint8_t *dst); -void batadv_tt_update_orig(struct bat_priv *bat_priv, - struct orig_node *orig_node, +void batadv_tt_update_orig(struct batadv_priv *bat_priv, + struct batadv_orig_node *orig_node, const unsigned char *tt_buff, uint8_t tt_num_changes, uint8_t ttvn, uint16_t tt_crc); -int batadv_tt_append_diff(struct bat_priv *bat_priv, +int batadv_tt_append_diff(struct batadv_priv *bat_priv, unsigned char **packet_buff, int *packet_buff_len, int packet_min_len); -bool batadv_tt_global_client_is_roaming(struct bat_priv *bat_priv, +bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv, uint8_t *addr); diff --git a/net/batman-adv/types.h b/net/batman-adv/types.h index fd538ea68117..2141c1304898 100644 --- a/net/batman-adv/types.h +++ b/net/batman-adv/types.h @@ -25,10 +25,10 @@ #include <linux/kernel.h> #define BATADV_HEADER_LEN \ - (ETH_HLEN + max(sizeof(struct unicast_packet), \ - sizeof(struct bcast_packet))) + (ETH_HLEN + max(sizeof(struct batadv_unicast_packet), \ + sizeof(struct batadv_bcast_packet))) -struct hard_iface { +struct batadv_hard_iface { struct list_head list; int16_t if_num; char if_status; @@ -44,7 +44,7 @@ struct hard_iface { struct rcu_head rcu; }; -/* orig_node - structure for orig_list maintaining nodes of mesh +/* batadv_orig_node - structure for orig_list maintaining nodes of mesh * @primary_addr: hosts primary interface address * @last_seen: when last packet from this node was received * @bcast_seqno_reset: time when the broadcast seqno window was reset @@ -58,10 +58,10 @@ struct hard_iface { * @candidates: how many candidates are available * @selected: next bonding candidate */ -struct orig_node { +struct batadv_orig_node { uint8_t orig[ETH_ALEN]; uint8_t primary_addr[ETH_ALEN]; - struct neigh_node __rcu *router; /* rcu protected pointer */ + struct batadv_neigh_node __rcu *router; /* rcu protected pointer */ unsigned long *bcast_own; uint8_t *bcast_own_sum; unsigned long last_seen; @@ -93,7 +93,7 @@ struct orig_node { atomic_t refcount; struct rcu_head rcu; struct hlist_node hash_entry; - struct bat_priv *bat_priv; + struct batadv_priv *bat_priv; unsigned long last_frag_packet; /* ogm_cnt_lock protects: bcast_own, bcast_own_sum, * neigh_node->real_bits, neigh_node->real_packet_count @@ -106,18 +106,18 @@ struct orig_node { struct list_head bond_list; }; -struct gw_node { +struct batadv_gw_node { struct hlist_node list; - struct orig_node *orig_node; + struct batadv_orig_node *orig_node; unsigned long deleted; atomic_t refcount; struct rcu_head rcu; }; -/* neigh_node +/* batadv_neigh_node * @last_seen: when last packet via this neighbor was received */ -struct neigh_node { +struct batadv_neigh_node { struct hlist_node list; uint8_t addr[ETH_ALEN]; uint8_t real_packet_count; @@ -130,36 +130,36 @@ struct neigh_node { DECLARE_BITMAP(real_bits, BATADV_TQ_LOCAL_WINDOW_SIZE); atomic_t refcount; struct rcu_head rcu; - struct orig_node *orig_node; - struct hard_iface *if_incoming; + struct batadv_orig_node *orig_node; + struct batadv_hard_iface *if_incoming; spinlock_t lq_update_lock; /* protects: tq_recv, tq_index */ }; #ifdef CONFIG_BATMAN_ADV_BLA -struct bcast_duplist_entry { +struct batadv_bcast_duplist_entry { uint8_t orig[ETH_ALEN]; uint16_t crc; unsigned long entrytime; }; #endif -enum bat_counters { - BAT_CNT_FORWARD, - BAT_CNT_FORWARD_BYTES, - BAT_CNT_MGMT_TX, - BAT_CNT_MGMT_TX_BYTES, - BAT_CNT_MGMT_RX, - BAT_CNT_MGMT_RX_BYTES, - BAT_CNT_TT_REQUEST_TX, - BAT_CNT_TT_REQUEST_RX, - BAT_CNT_TT_RESPONSE_TX, - BAT_CNT_TT_RESPONSE_RX, - BAT_CNT_TT_ROAM_ADV_TX, - BAT_CNT_TT_ROAM_ADV_RX, - BAT_CNT_NUM, +enum batadv_counters { + BATADV_CNT_FORWARD, + BATADV_CNT_FORWARD_BYTES, + BATADV_CNT_MGMT_TX, + BATADV_CNT_MGMT_TX_BYTES, + BATADV_CNT_MGMT_RX, + BATADV_CNT_MGMT_RX_BYTES, + BATADV_CNT_TT_REQUEST_TX, + BATADV_CNT_TT_REQUEST_RX, + BATADV_CNT_TT_RESPONSE_TX, + BATADV_CNT_TT_RESPONSE_RX, + BATADV_CNT_TT_ROAM_ADV_TX, + BATADV_CNT_TT_ROAM_ADV_RX, + BATADV_CNT_NUM, }; -struct bat_priv { +struct batadv_priv { atomic_t mesh_state; struct net_device_stats stats; uint64_t __percpu *bat_counters; /* Per cpu counters */ @@ -190,7 +190,7 @@ struct bat_priv { */ bool tt_poss_change; char num_ifaces; - struct debug_log *debug_log; + struct batadv_debug_log *debug_log; struct kobject *mesh_obj; struct dentry *debug_dir; struct hlist_head forw_bat_list; @@ -198,20 +198,20 @@ struct bat_priv { struct hlist_head gw_list; struct list_head tt_changes_list; /* tracks changes in a OGM int */ struct list_head vis_send_list; - struct hashtable_t *orig_hash; - struct hashtable_t *tt_local_hash; - struct hashtable_t *tt_global_hash; + struct batadv_hashtable *orig_hash; + struct batadv_hashtable *tt_local_hash; + struct batadv_hashtable *tt_global_hash; #ifdef CONFIG_BATMAN_ADV_BLA - struct hashtable_t *claim_hash; - struct hashtable_t *backbone_hash; + struct batadv_hashtable *claim_hash; + struct batadv_hashtable *backbone_hash; #endif struct list_head tt_req_list; /* list of pending tt_requests */ struct list_head tt_roam_list; - struct hashtable_t *vis_hash; + struct batadv_hashtable *vis_hash; #ifdef CONFIG_BATMAN_ADV_BLA - struct bcast_duplist_entry bcast_duplist[BATADV_DUPLIST_SIZE]; + struct batadv_bcast_duplist_entry bcast_duplist[BATADV_DUPLIST_SIZE]; int bcast_duplist_curr; - struct bla_claim_dst claim_dest; + struct batadv_bla_claim_dst claim_dest; #endif spinlock_t forw_bat_list_lock; /* protects forw_bat_list */ spinlock_t forw_bcast_list_lock; /* protects */ @@ -231,29 +231,29 @@ struct bat_priv { struct delayed_work orig_work; struct delayed_work vis_work; struct delayed_work bla_work; - struct gw_node __rcu *curr_gw; /* rcu protected pointer */ + struct batadv_gw_node __rcu *curr_gw; /* rcu protected pointer */ atomic_t gw_reselect; - struct hard_iface __rcu *primary_if; /* rcu protected pointer */ - struct vis_info *my_vis_info; - struct bat_algo_ops *bat_algo_ops; + struct batadv_hard_iface __rcu *primary_if; /* rcu protected pointer */ + struct batadv_vis_info *my_vis_info; + struct batadv_algo_ops *bat_algo_ops; }; -struct socket_client { +struct batadv_socket_client { struct list_head queue_list; unsigned int queue_len; unsigned char index; spinlock_t lock; /* protects queue_list, queue_len, index */ wait_queue_head_t queue_wait; - struct bat_priv *bat_priv; + struct batadv_priv *bat_priv; }; -struct socket_packet { +struct batadv_socket_packet { struct list_head list; size_t icmp_len; - struct icmp_packet_rr icmp_packet; + struct batadv_icmp_packet_rr icmp_packet; }; -struct tt_common_entry { +struct batadv_tt_common_entry { uint8_t addr[ETH_ALEN]; struct hlist_node hash_entry; uint16_t flags; @@ -261,31 +261,31 @@ struct tt_common_entry { struct rcu_head rcu; }; -struct tt_local_entry { - struct tt_common_entry common; +struct batadv_tt_local_entry { + struct batadv_tt_common_entry common; unsigned long last_seen; }; -struct tt_global_entry { - struct tt_common_entry common; +struct batadv_tt_global_entry { + struct batadv_tt_common_entry common; struct hlist_head orig_list; spinlock_t list_lock; /* protects the list */ unsigned long roam_at; /* time at which TT_GLOBAL_ROAM was set */ }; -struct tt_orig_list_entry { - struct orig_node *orig_node; +struct batadv_tt_orig_list_entry { + struct batadv_orig_node *orig_node; uint8_t ttvn; struct rcu_head rcu; struct hlist_node list; }; #ifdef CONFIG_BATMAN_ADV_BLA -struct backbone_gw { +struct batadv_backbone_gw { uint8_t orig[ETH_ALEN]; short vid; /* used VLAN ID */ struct hlist_node hash_entry; - struct bat_priv *bat_priv; + struct batadv_priv *bat_priv; unsigned long lasttime; /* last time we heard of this backbone gw */ atomic_t request_sent; atomic_t refcount; @@ -293,10 +293,10 @@ struct backbone_gw { uint16_t crc; /* crc checksum over all claims */ }; -struct claim { +struct batadv_claim { uint8_t addr[ETH_ALEN]; short vid; - struct backbone_gw *backbone_gw; + struct batadv_backbone_gw *backbone_gw; unsigned long lasttime; /* last time we heard of claim (locals only) */ struct rcu_head rcu; atomic_t refcount; @@ -304,18 +304,18 @@ struct claim { }; #endif -struct tt_change_node { +struct batadv_tt_change_node { struct list_head list; - struct tt_change change; + struct batadv_tt_change change; }; -struct tt_req_node { +struct batadv_tt_req_node { uint8_t addr[ETH_ALEN]; unsigned long issued_at; struct list_head list; }; -struct tt_roam_node { +struct batadv_tt_roam_node { uint8_t addr[ETH_ALEN]; atomic_t counter; unsigned long first_time; @@ -325,7 +325,7 @@ struct tt_roam_node { /* forw_packet - structure for forw_list maintaining packets to be * send/forwarded */ -struct forw_packet { +struct batadv_forw_packet { struct hlist_node list; unsigned long send_time; uint8_t own; @@ -334,20 +334,20 @@ struct forw_packet { uint32_t direct_link_flags; uint8_t num_packets; struct delayed_work delayed_work; - struct hard_iface *if_incoming; + struct batadv_hard_iface *if_incoming; }; /* While scanning for vis-entries of a particular vis-originator * this list collects its interfaces to create a subgraph/cluster * out of them later */ -struct if_list_entry { +struct batadv_if_list_entry { uint8_t addr[ETH_ALEN]; bool primary; struct hlist_node list; }; -struct debug_log { +struct batadv_debug_log { char log_buff[BATADV_LOG_BUF_LEN]; unsigned long log_start; unsigned long log_end; @@ -355,13 +355,13 @@ struct debug_log { wait_queue_head_t queue_wait; }; -struct frag_packet_list_entry { +struct batadv_frag_packet_list_entry { struct list_head list; uint16_t seqno; struct sk_buff *skb; }; -struct vis_info { +struct batadv_vis_info { unsigned long first_seen; /* list of server-neighbors we received a vis-packet * from. we should not reply to them. @@ -370,40 +370,40 @@ struct vis_info { struct list_head send_list; struct kref refcount; struct hlist_node hash_entry; - struct bat_priv *bat_priv; + struct batadv_priv *bat_priv; /* this packet might be part of the vis send queue. */ struct sk_buff *skb_packet; /* vis_info may follow here */ } __packed; -struct vis_info_entry { +struct batadv_vis_info_entry { uint8_t src[ETH_ALEN]; uint8_t dest[ETH_ALEN]; uint8_t quality; /* quality = 0 client */ } __packed; -struct recvlist_node { +struct batadv_recvlist_node { struct list_head list; uint8_t mac[ETH_ALEN]; }; -struct bat_algo_ops { +struct batadv_algo_ops { struct hlist_node list; char *name; /* init routing info when hard-interface is enabled */ - int (*bat_iface_enable)(struct hard_iface *hard_iface); + int (*bat_iface_enable)(struct batadv_hard_iface *hard_iface); /* de-init routing info when hard-interface is disabled */ - void (*bat_iface_disable)(struct hard_iface *hard_iface); + void (*bat_iface_disable)(struct batadv_hard_iface *hard_iface); /* (re-)init mac addresses of the protocol information * belonging to this hard-interface */ - void (*bat_iface_update_mac)(struct hard_iface *hard_iface); + void (*bat_iface_update_mac)(struct batadv_hard_iface *hard_iface); /* called when primary interface is selected / changed */ - void (*bat_primary_iface_set)(struct hard_iface *hard_iface); + void (*bat_primary_iface_set)(struct batadv_hard_iface *hard_iface); /* prepare a new outgoing OGM for the send queue */ - void (*bat_ogm_schedule)(struct hard_iface *hard_iface); + void (*bat_ogm_schedule)(struct batadv_hard_iface *hard_iface); /* send scheduled OGM */ - void (*bat_ogm_emit)(struct forw_packet *forw_packet); + void (*bat_ogm_emit)(struct batadv_forw_packet *forw_packet); }; #endif /* _NET_BATMAN_ADV_TYPES_H_ */ diff --git a/net/batman-adv/unicast.c b/net/batman-adv/unicast.c index 8454d916cd01..00164645b3f7 100644 --- a/net/batman-adv/unicast.c +++ b/net/batman-adv/unicast.c @@ -31,18 +31,18 @@ static struct sk_buff * batadv_frag_merge_packet(struct list_head *head, - struct frag_packet_list_entry *tfp, + struct batadv_frag_packet_list_entry *tfp, struct sk_buff *skb) { - struct unicast_frag_packet *up = - (struct unicast_frag_packet *)skb->data; + struct batadv_unicast_frag_packet *up; struct sk_buff *tmp_skb; - struct unicast_packet *unicast_packet; + struct batadv_unicast_packet *unicast_packet; int hdr_len = sizeof(*unicast_packet); int uni_diff = sizeof(*up) - hdr_len; + up = (struct batadv_unicast_frag_packet *)skb->data; /* set skb to the first part and tmp_skb to the second part */ - if (up->flags & UNI_FRAG_HEAD) { + if (up->flags & BATADV_UNI_FRAG_HEAD) { tmp_skb = tfp->skb; } else { tmp_skb = skb; @@ -65,8 +65,9 @@ batadv_frag_merge_packet(struct list_head *head, kfree_skb(tmp_skb); memmove(skb->data + uni_diff, skb->data, hdr_len); - unicast_packet = (struct unicast_packet *)skb_pull(skb, uni_diff); - unicast_packet->header.packet_type = BAT_UNICAST; + unicast_packet = (struct batadv_unicast_packet *)skb_pull(skb, + uni_diff); + unicast_packet->header.packet_type = BATADV_UNICAST; return skb; @@ -79,9 +80,10 @@ err: static void batadv_frag_create_entry(struct list_head *head, struct sk_buff *skb) { - struct frag_packet_list_entry *tfp; - struct unicast_frag_packet *up = - (struct unicast_frag_packet *)skb->data; + struct batadv_frag_packet_list_entry *tfp; + struct batadv_unicast_frag_packet *up; + + up = (struct batadv_unicast_frag_packet *)skb->data; /* free and oldest packets stand at the end */ tfp = list_entry((head)->prev, typeof(*tfp), list); @@ -96,7 +98,7 @@ static void batadv_frag_create_entry(struct list_head *head, static int batadv_frag_create_buffer(struct list_head *head) { int i; - struct frag_packet_list_entry *tfp; + struct batadv_frag_packet_list_entry *tfp; for (i = 0; i < BATADV_FRAG_BUFFER_SIZE; i++) { tfp = kmalloc(sizeof(*tfp), GFP_ATOMIC); @@ -113,15 +115,15 @@ static int batadv_frag_create_buffer(struct list_head *head) return 0; } -static struct frag_packet_list_entry * +static struct batadv_frag_packet_list_entry * batadv_frag_search_packet(struct list_head *head, - const struct unicast_frag_packet *up) + const struct batadv_unicast_frag_packet *up) { - struct frag_packet_list_entry *tfp; - struct unicast_frag_packet *tmp_up = NULL; + struct batadv_frag_packet_list_entry *tfp; + struct batadv_unicast_frag_packet *tmp_up = NULL; uint16_t search_seqno; - if (up->flags & UNI_FRAG_HEAD) + if (up->flags & BATADV_UNI_FRAG_HEAD) search_seqno = ntohs(up->seqno)+1; else search_seqno = ntohs(up->seqno)-1; @@ -134,12 +136,12 @@ batadv_frag_search_packet(struct list_head *head, if (tfp->seqno == ntohs(up->seqno)) goto mov_tail; - tmp_up = (struct unicast_frag_packet *)tfp->skb->data; + tmp_up = (struct batadv_unicast_frag_packet *)tfp->skb->data; if (tfp->seqno == search_seqno) { - if ((tmp_up->flags & UNI_FRAG_HEAD) != - (up->flags & UNI_FRAG_HEAD)) + if ((tmp_up->flags & BATADV_UNI_FRAG_HEAD) != + (up->flags & BATADV_UNI_FRAG_HEAD)) return tfp; else goto mov_tail; @@ -154,7 +156,7 @@ mov_tail: void batadv_frag_list_free(struct list_head *head) { - struct frag_packet_list_entry *pf, *tmp_pf; + struct batadv_frag_packet_list_entry *pf, *tmp_pf; if (!list_empty(head)) { @@ -173,15 +175,16 @@ void batadv_frag_list_free(struct list_head *head) * or the skb could be reassembled (skb_new will point to the new packet and * skb was freed) */ -int batadv_frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv, +int batadv_frag_reassemble_skb(struct sk_buff *skb, + struct batadv_priv *bat_priv, struct sk_buff **new_skb) { - struct orig_node *orig_node; - struct frag_packet_list_entry *tmp_frag_entry; + struct batadv_orig_node *orig_node; + struct batadv_frag_packet_list_entry *tmp_frag_entry; int ret = NET_RX_DROP; - struct unicast_frag_packet *unicast_packet = - (struct unicast_frag_packet *)skb->data; + struct batadv_unicast_frag_packet *unicast_packet; + unicast_packet = (struct batadv_unicast_frag_packet *)skb->data; *new_skb = NULL; orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->orig); @@ -217,13 +220,14 @@ out: return ret; } -int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, - struct hard_iface *hard_iface, const uint8_t dstaddr[]) +int batadv_frag_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv, + struct batadv_hard_iface *hard_iface, + const uint8_t dstaddr[]) { - struct unicast_packet tmp_uc, *unicast_packet; - struct hard_iface *primary_if; + struct batadv_unicast_packet tmp_uc, *unicast_packet; + struct batadv_hard_iface *primary_if; struct sk_buff *frag_skb; - struct unicast_frag_packet *frag1, *frag2; + struct batadv_unicast_frag_packet *frag1, *frag2; int uc_hdr_len = sizeof(*unicast_packet); int ucf_hdr_len = sizeof(*frag1); int data_len = skb->len - uc_hdr_len; @@ -239,7 +243,7 @@ int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, goto dropped; skb_reserve(frag_skb, ucf_hdr_len); - unicast_packet = (struct unicast_packet *)skb->data; + unicast_packet = (struct batadv_unicast_packet *)skb->data; memcpy(&tmp_uc, unicast_packet, uc_hdr_len); skb_split(skb, frag_skb, data_len / 2 + uc_hdr_len); @@ -247,22 +251,22 @@ int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, batadv_skb_head_push(frag_skb, ucf_hdr_len) < 0) goto drop_frag; - frag1 = (struct unicast_frag_packet *)skb->data; - frag2 = (struct unicast_frag_packet *)frag_skb->data; + frag1 = (struct batadv_unicast_frag_packet *)skb->data; + frag2 = (struct batadv_unicast_frag_packet *)frag_skb->data; memcpy(frag1, &tmp_uc, sizeof(tmp_uc)); frag1->header.ttl--; frag1->header.version = BATADV_COMPAT_VERSION; - frag1->header.packet_type = BAT_UNICAST_FRAG; + frag1->header.packet_type = BATADV_UNICAST_FRAG; memcpy(frag1->orig, primary_if->net_dev->dev_addr, ETH_ALEN); memcpy(frag2, frag1, sizeof(*frag2)); if (data_len & 1) - large_tail = UNI_FRAG_LARGETAIL; + large_tail = BATADV_UNI_FRAG_LARGETAIL; - frag1->flags = UNI_FRAG_HEAD | large_tail; + frag1->flags = BATADV_UNI_FRAG_HEAD | large_tail; frag2->flags = large_tail; seqno = atomic_add_return(2, &hard_iface->frag_seqno); @@ -284,14 +288,15 @@ out: return ret; } -int batadv_unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv) +int batadv_unicast_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv) { struct ethhdr *ethhdr = (struct ethhdr *)skb->data; - struct unicast_packet *unicast_packet; - struct orig_node *orig_node; - struct neigh_node *neigh_node; + struct batadv_unicast_packet *unicast_packet; + struct batadv_orig_node *orig_node; + struct batadv_neigh_node *neigh_node; int data_len = skb->len; int ret = 1; + unsigned int dev_mtu; /* get routing information */ if (is_multicast_ether_addr(ethhdr->h_dest)) { @@ -305,23 +310,25 @@ int batadv_unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv) */ orig_node = batadv_transtable_search(bat_priv, ethhdr->h_source, ethhdr->h_dest); + find_router: /* find_router(): * - if orig_node is NULL it returns NULL * - increases neigh_nodes refcount if found. */ neigh_node = batadv_find_router(bat_priv, orig_node, NULL); + if (!neigh_node) goto out; if (batadv_skb_head_push(skb, sizeof(*unicast_packet)) < 0) goto out; - unicast_packet = (struct unicast_packet *)skb->data; + unicast_packet = (struct batadv_unicast_packet *)skb->data; unicast_packet->header.version = BATADV_COMPAT_VERSION; /* batman packet type: unicast */ - unicast_packet->header.packet_type = BAT_UNICAST; + unicast_packet->header.packet_type = BATADV_UNICAST; /* set unicast ttl */ unicast_packet->header.ttl = BATADV_TTL; /* copy the destination for faster routing */ @@ -338,9 +345,9 @@ find_router: if (batadv_tt_global_client_is_roaming(bat_priv, ethhdr->h_dest)) unicast_packet->ttvn = unicast_packet->ttvn - 1; + dev_mtu = neigh_node->if_incoming->net_dev->mtu; if (atomic_read(&bat_priv->fragmentation) && - data_len + sizeof(*unicast_packet) > - neigh_node->if_incoming->net_dev->mtu) { + data_len + sizeof(*unicast_packet) > dev_mtu) { /* send frag skb decreases ttl */ unicast_packet->header.ttl++; ret = batadv_frag_send_skb(skb, bat_priv, diff --git a/net/batman-adv/unicast.h b/net/batman-adv/unicast.h index 936287f552ee..1c46e2eb1ef9 100644 --- a/net/batman-adv/unicast.h +++ b/net/batman-adv/unicast.h @@ -25,31 +25,32 @@ #define BATADV_FRAG_TIMEOUT 10000 /* purge frag list entries after time in ms */ #define BATADV_FRAG_BUFFER_SIZE 6 /* number of list elements in buffer */ -int batadv_frag_reassemble_skb(struct sk_buff *skb, struct bat_priv *bat_priv, +int batadv_frag_reassemble_skb(struct sk_buff *skb, + struct batadv_priv *bat_priv, struct sk_buff **new_skb); void batadv_frag_list_free(struct list_head *head); -int batadv_unicast_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv); -int batadv_frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, - struct hard_iface *hard_iface, +int batadv_unicast_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv); +int batadv_frag_send_skb(struct sk_buff *skb, struct batadv_priv *bat_priv, + struct batadv_hard_iface *hard_iface, const uint8_t dstaddr[]); static inline int batadv_frag_can_reassemble(const struct sk_buff *skb, int mtu) { - const struct unicast_frag_packet *unicast_packet; + const struct batadv_unicast_frag_packet *unicast_packet; int uneven_correction = 0; unsigned int merged_size; - unicast_packet = (struct unicast_frag_packet *)skb->data; + unicast_packet = (struct batadv_unicast_frag_packet *)skb->data; - if (unicast_packet->flags & UNI_FRAG_LARGETAIL) { - if (unicast_packet->flags & UNI_FRAG_HEAD) + if (unicast_packet->flags & BATADV_UNI_FRAG_LARGETAIL) { + if (unicast_packet->flags & BATADV_UNI_FRAG_HEAD) uneven_correction = 1; else uneven_correction = -1; } merged_size = (skb->len - sizeof(*unicast_packet)) * 2; - merged_size += sizeof(struct unicast_packet) + uneven_correction; + merged_size += sizeof(struct batadv_unicast_packet) + uneven_correction; return merged_size <= mtu; } diff --git a/net/batman-adv/vis.c b/net/batman-adv/vis.c index 74181696eef6..2a2ea0681469 100644 --- a/net/batman-adv/vis.c +++ b/net/batman-adv/vis.c @@ -28,14 +28,17 @@ #define BATADV_MAX_VIS_PACKET_SIZE 1000 -static void batadv_start_vis_timer(struct bat_priv *bat_priv); +static void batadv_start_vis_timer(struct batadv_priv *bat_priv); /* free the info */ static void batadv_free_info(struct kref *ref) { - struct vis_info *info = container_of(ref, struct vis_info, refcount); - struct bat_priv *bat_priv = info->bat_priv; - struct recvlist_node *entry, *tmp; + struct batadv_vis_info *info; + struct batadv_priv *bat_priv; + struct batadv_recvlist_node *entry, *tmp; + + info = container_of(ref, struct batadv_vis_info, refcount); + bat_priv = info->bat_priv; list_del_init(&info->send_list); spin_lock_bh(&bat_priv->vis_list_lock); @@ -52,13 +55,13 @@ static void batadv_free_info(struct kref *ref) /* Compare two vis packets, used by the hashing algorithm */ static int batadv_vis_info_cmp(const struct hlist_node *node, const void *data2) { - const struct vis_info *d1, *d2; - const struct vis_packet *p1, *p2; + const struct batadv_vis_info *d1, *d2; + const struct batadv_vis_packet *p1, *p2; - d1 = container_of(node, struct vis_info, hash_entry); + d1 = container_of(node, struct batadv_vis_info, hash_entry); d2 = data2; - p1 = (struct vis_packet *)d1->skb_packet->data; - p2 = (struct vis_packet *)d2->skb_packet->data; + p1 = (struct batadv_vis_packet *)d1->skb_packet->data; + p2 = (struct batadv_vis_packet *)d2->skb_packet->data; return batadv_compare_eth(p1->vis_orig, p2->vis_orig); } @@ -67,13 +70,13 @@ static int batadv_vis_info_cmp(const struct hlist_node *node, const void *data2) */ static uint32_t batadv_vis_info_choose(const void *data, uint32_t size) { - const struct vis_info *vis_info = data; - const struct vis_packet *packet; + const struct batadv_vis_info *vis_info = data; + const struct batadv_vis_packet *packet; const unsigned char *key; uint32_t hash = 0; size_t i; - packet = (struct vis_packet *)vis_info->skb_packet->data; + packet = (struct batadv_vis_packet *)vis_info->skb_packet->data; key = packet->vis_orig; for (i = 0; i < ETH_ALEN; i++) { hash += key[i]; @@ -88,13 +91,13 @@ static uint32_t batadv_vis_info_choose(const void *data, uint32_t size) return hash % size; } -static struct vis_info *batadv_vis_hash_find(struct bat_priv *bat_priv, - const void *data) +static struct batadv_vis_info * +batadv_vis_hash_find(struct batadv_priv *bat_priv, const void *data) { - struct hashtable_t *hash = bat_priv->vis_hash; + struct batadv_hashtable *hash = bat_priv->vis_hash; struct hlist_head *head; struct hlist_node *node; - struct vis_info *vis_info, *vis_info_tmp = NULL; + struct batadv_vis_info *vis_info, *vis_info_tmp = NULL; uint32_t index; if (!hash) @@ -123,7 +126,7 @@ static void batadv_vis_data_insert_interface(const uint8_t *interface, struct hlist_head *if_list, bool primary) { - struct if_list_entry *entry; + struct batadv_if_list_entry *entry; struct hlist_node *pos; hlist_for_each_entry(entry, pos, if_list, list) { @@ -143,7 +146,7 @@ static void batadv_vis_data_insert_interface(const uint8_t *interface, static void batadv_vis_data_read_prim_sec(struct seq_file *seq, const struct hlist_head *if_list) { - struct if_list_entry *entry; + struct batadv_if_list_entry *entry; struct hlist_node *pos; hlist_for_each_entry(entry, pos, if_list, list) { @@ -155,9 +158,10 @@ static void batadv_vis_data_read_prim_sec(struct seq_file *seq, } /* read an entry */ -static ssize_t batadv_vis_data_read_entry(struct seq_file *seq, - const struct vis_info_entry *entry, - const uint8_t *src, bool primary) +static ssize_t +batadv_vis_data_read_entry(struct seq_file *seq, + const struct batadv_vis_info_entry *entry, + const uint8_t *src, bool primary) { if (primary && entry->quality == 0) return seq_printf(seq, "TT %pM, ", entry->dest); @@ -168,9 +172,10 @@ static ssize_t batadv_vis_data_read_entry(struct seq_file *seq, return 0; } -static void batadv_vis_data_insert_interfaces(struct hlist_head *list, - struct vis_packet *packet, - struct vis_info_entry *entries) +static void +batadv_vis_data_insert_interfaces(struct hlist_head *list, + struct batadv_vis_packet *packet, + struct batadv_vis_info_entry *entries) { int i; @@ -187,11 +192,11 @@ static void batadv_vis_data_insert_interfaces(struct hlist_head *list, static void batadv_vis_data_read_entries(struct seq_file *seq, struct hlist_head *list, - struct vis_packet *packet, - struct vis_info_entry *entries) + struct batadv_vis_packet *packet, + struct batadv_vis_info_entry *entries) { int i; - struct if_list_entry *entry; + struct batadv_if_list_entry *entry; struct hlist_node *pos; hlist_for_each_entry(entry, pos, list, list) { @@ -213,19 +218,19 @@ static void batadv_vis_seq_print_text_bucket(struct seq_file *seq, const struct hlist_head *head) { struct hlist_node *node; - struct vis_info *info; - struct vis_packet *packet; + struct batadv_vis_info *info; + struct batadv_vis_packet *packet; uint8_t *entries_pos; - struct vis_info_entry *entries; - struct if_list_entry *entry; + struct batadv_vis_info_entry *entries; + struct batadv_if_list_entry *entry; struct hlist_node *pos, *n; HLIST_HEAD(vis_if_list); hlist_for_each_entry_rcu(info, node, head, hash_entry) { - packet = (struct vis_packet *)info->skb_packet->data; + packet = (struct batadv_vis_packet *)info->skb_packet->data; entries_pos = (uint8_t *)packet + sizeof(*packet); - entries = (struct vis_info_entry *)entries_pos; + entries = (struct batadv_vis_info_entry *)entries_pos; batadv_vis_data_insert_interface(packet->vis_orig, &vis_if_list, true); @@ -243,11 +248,11 @@ static void batadv_vis_seq_print_text_bucket(struct seq_file *seq, int batadv_vis_seq_print_text(struct seq_file *seq, void *offset) { - struct hard_iface *primary_if; + struct batadv_hard_iface *primary_if; struct hlist_head *head; struct net_device *net_dev = (struct net_device *)seq->private; - struct bat_priv *bat_priv = netdev_priv(net_dev); - struct hashtable_t *hash = bat_priv->vis_hash; + struct batadv_priv *bat_priv = netdev_priv(net_dev); + struct batadv_hashtable *hash = bat_priv->vis_hash; uint32_t i; int ret = 0; int vis_server = atomic_read(&bat_priv->vis_mode); @@ -256,7 +261,7 @@ int batadv_vis_seq_print_text(struct seq_file *seq, void *offset) if (!primary_if) goto out; - if (vis_server == VIS_TYPE_CLIENT_UPDATE) + if (vis_server == BATADV_VIS_TYPE_CLIENT_UPDATE) goto out; spin_lock_bh(&bat_priv->vis_hash_lock); @@ -275,8 +280,8 @@ out: /* add the info packet to the send list, if it was not * already linked in. */ -static void batadv_send_list_add(struct bat_priv *bat_priv, - struct vis_info *info) +static void batadv_send_list_add(struct batadv_priv *bat_priv, + struct batadv_vis_info *info) { if (list_empty(&info->send_list)) { kref_get(&info->refcount); @@ -287,7 +292,7 @@ static void batadv_send_list_add(struct bat_priv *bat_priv, /* delete the info packet from the send list, if it was * linked in. */ -static void batadv_send_list_del(struct vis_info *info) +static void batadv_send_list_del(struct batadv_vis_info *info) { if (!list_empty(&info->send_list)) { list_del_init(&info->send_list); @@ -296,10 +301,10 @@ static void batadv_send_list_del(struct vis_info *info) } /* tries to add one entry to the receive list. */ -static void batadv_recv_list_add(struct bat_priv *bat_priv, +static void batadv_recv_list_add(struct batadv_priv *bat_priv, struct list_head *recv_list, const char *mac) { - struct recvlist_node *entry; + struct batadv_recvlist_node *entry; entry = kmalloc(sizeof(*entry), GFP_ATOMIC); if (!entry) @@ -312,11 +317,11 @@ static void batadv_recv_list_add(struct bat_priv *bat_priv, } /* returns 1 if this mac is in the recv_list */ -static int batadv_recv_list_is_in(struct bat_priv *bat_priv, +static int batadv_recv_list_is_in(struct batadv_priv *bat_priv, const struct list_head *recv_list, const char *mac) { - const struct recvlist_node *entry; + const struct batadv_recvlist_node *entry; spin_lock_bh(&bat_priv->vis_list_lock); list_for_each_entry(entry, recv_list, list) { @@ -333,16 +338,19 @@ static int batadv_recv_list_is_in(struct bat_priv *bat_priv, * broken.. ). vis hash must be locked outside. is_new is set when the packet * is newer than old entries in the hash. */ -static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv, - struct vis_packet *vis_packet, - int vis_info_len, int *is_new, - int make_broadcast) +static struct batadv_vis_info * +batadv_add_packet(struct batadv_priv *bat_priv, + struct batadv_vis_packet *vis_packet, int vis_info_len, + int *is_new, int make_broadcast) { - struct vis_info *info, *old_info; - struct vis_packet *search_packet, *old_packet; - struct vis_info search_elem; - struct vis_packet *packet; + struct batadv_vis_info *info, *old_info; + struct batadv_vis_packet *search_packet, *old_packet; + struct batadv_vis_info search_elem; + struct batadv_vis_packet *packet; + struct sk_buff *tmp_skb; int hash_added; + size_t len; + size_t max_entries; *is_new = 0; /* sanity check */ @@ -353,15 +361,17 @@ static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv, search_elem.skb_packet = dev_alloc_skb(sizeof(*search_packet)); if (!search_elem.skb_packet) return NULL; - search_packet = (struct vis_packet *)skb_put(search_elem.skb_packet, - sizeof(*search_packet)); + len = sizeof(*search_packet); + tmp_skb = search_elem.skb_packet; + search_packet = (struct batadv_vis_packet *)skb_put(tmp_skb, len); memcpy(search_packet->vis_orig, vis_packet->vis_orig, ETH_ALEN); old_info = batadv_vis_hash_find(bat_priv, &search_elem); kfree_skb(search_elem.skb_packet); if (old_info) { - old_packet = (struct vis_packet *)old_info->skb_packet->data; + tmp_skb = old_info->skb_packet; + old_packet = (struct batadv_vis_packet *)tmp_skb->data; if (!batadv_seq_after(ntohl(vis_packet->seqno), ntohl(old_packet->seqno))) { if (old_packet->seqno == vis_packet->seqno) { @@ -385,22 +395,21 @@ static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv, if (!info) return NULL; - info->skb_packet = dev_alloc_skb(sizeof(*packet) + vis_info_len + - ETH_HLEN); + len = sizeof(*packet) + vis_info_len; + info->skb_packet = dev_alloc_skb(len + ETH_HLEN); if (!info->skb_packet) { kfree(info); return NULL; } skb_reserve(info->skb_packet, ETH_HLEN); - packet = (struct vis_packet *)skb_put(info->skb_packet, sizeof(*packet) - + vis_info_len); + packet = (struct batadv_vis_packet *)skb_put(info->skb_packet, len); kref_init(&info->refcount); INIT_LIST_HEAD(&info->send_list); INIT_LIST_HEAD(&info->recv_list); info->first_seen = jiffies; info->bat_priv = bat_priv; - memcpy(packet, vis_packet, sizeof(*packet) + vis_info_len); + memcpy(packet, vis_packet, len); /* initialize and add new packet. */ *is_new = 1; @@ -410,8 +419,9 @@ static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv, memcpy(packet->target_orig, batadv_broadcast_addr, ETH_ALEN); /* repair if entries is longer than packet. */ - if (packet->entries * sizeof(struct vis_info_entry) > vis_info_len) - packet->entries = vis_info_len / sizeof(struct vis_info_entry); + max_entries = vis_info_len / sizeof(struct batadv_vis_info_entry); + if (packet->entries > max_entries) + packet->entries = max_entries; batadv_recv_list_add(bat_priv, &info->recv_list, packet->sender_orig); @@ -429,15 +439,15 @@ static struct vis_info *batadv_add_packet(struct bat_priv *bat_priv, } /* handle the server sync packet, forward if needed. */ -void batadv_receive_server_sync_packet(struct bat_priv *bat_priv, - struct vis_packet *vis_packet, +void batadv_receive_server_sync_packet(struct batadv_priv *bat_priv, + struct batadv_vis_packet *vis_packet, int vis_info_len) { - struct vis_info *info; + struct batadv_vis_info *info; int is_new, make_broadcast; int vis_server = atomic_read(&bat_priv->vis_mode); - make_broadcast = (vis_server == VIS_TYPE_SERVER_SYNC); + make_broadcast = (vis_server == BATADV_VIS_TYPE_SERVER_SYNC); spin_lock_bh(&bat_priv->vis_hash_lock); info = batadv_add_packet(bat_priv, vis_packet, vis_info_len, @@ -448,19 +458,19 @@ void batadv_receive_server_sync_packet(struct bat_priv *bat_priv, /* only if we are server ourselves and packet is newer than the one in * hash. */ - if (vis_server == VIS_TYPE_SERVER_SYNC && is_new) + if (vis_server == BATADV_VIS_TYPE_SERVER_SYNC && is_new) batadv_send_list_add(bat_priv, info); end: spin_unlock_bh(&bat_priv->vis_hash_lock); } /* handle an incoming client update packet and schedule forward if needed. */ -void batadv_receive_client_update_packet(struct bat_priv *bat_priv, - struct vis_packet *vis_packet, +void batadv_receive_client_update_packet(struct batadv_priv *bat_priv, + struct batadv_vis_packet *vis_packet, int vis_info_len) { - struct vis_info *info; - struct vis_packet *packet; + struct batadv_vis_info *info; + struct batadv_vis_packet *packet; int is_new; int vis_server = atomic_read(&bat_priv->vis_mode); int are_target = 0; @@ -470,7 +480,7 @@ void batadv_receive_client_update_packet(struct bat_priv *bat_priv, return; /* Are we the target for this VIS packet? */ - if (vis_server == VIS_TYPE_SERVER_SYNC && + if (vis_server == BATADV_VIS_TYPE_SERVER_SYNC && batadv_is_my_mac(vis_packet->target_orig)) are_target = 1; @@ -482,11 +492,11 @@ void batadv_receive_client_update_packet(struct bat_priv *bat_priv, goto end; /* note that outdated packets will be dropped at this point. */ - packet = (struct vis_packet *)info->skb_packet->data; + packet = (struct batadv_vis_packet *)info->skb_packet->data; /* send only if we're the target server or ... */ if (are_target && is_new) { - packet->vis_type = VIS_TYPE_SERVER_SYNC; /* upgrade! */ + packet->vis_type = BATADV_VIS_TYPE_SERVER_SYNC; /* upgrade! */ batadv_send_list_add(bat_priv, info); /* ... we're not the recipient (and thus need to forward). */ @@ -503,19 +513,19 @@ end: * * Must be called with the originator hash locked */ -static int batadv_find_best_vis_server(struct bat_priv *bat_priv, - struct vis_info *info) +static int batadv_find_best_vis_server(struct batadv_priv *bat_priv, + struct batadv_vis_info *info) { - struct hashtable_t *hash = bat_priv->orig_hash; - struct neigh_node *router; + struct batadv_hashtable *hash = bat_priv->orig_hash; + struct batadv_neigh_node *router; struct hlist_node *node; struct hlist_head *head; - struct orig_node *orig_node; - struct vis_packet *packet; + struct batadv_orig_node *orig_node; + struct batadv_vis_packet *packet; int best_tq = -1; uint32_t i; - packet = (struct vis_packet *)info->skb_packet->data; + packet = (struct batadv_vis_packet *)info->skb_packet->data; for (i = 0; i < hash->size; i++) { head = &hash->table[i]; @@ -526,7 +536,7 @@ static int batadv_find_best_vis_server(struct bat_priv *bat_priv, if (!router) continue; - if ((orig_node->flags & VIS_SERVER) && + if ((orig_node->flags & BATADV_VIS_SERVER) && (router->tq_avg > best_tq)) { best_tq = router->tq_avg; memcpy(packet->target_orig, orig_node->orig, @@ -541,15 +551,15 @@ static int batadv_find_best_vis_server(struct bat_priv *bat_priv, } /* Return true if the vis packet is full. */ -static bool batadv_vis_packet_full(const struct vis_info *info) +static bool batadv_vis_packet_full(const struct batadv_vis_info *info) { - const struct vis_packet *packet; - size_t num_items; + const struct batadv_vis_packet *packet; + size_t num; - packet = (struct vis_packet *)info->skb_packet->data; - num_items = BATADV_MAX_VIS_PACKET_SIZE / sizeof(struct vis_info_entry); + packet = (struct batadv_vis_packet *)info->skb_packet->data; + num = BATADV_MAX_VIS_PACKET_SIZE / sizeof(struct batadv_vis_info_entry); - if (num_items < packet->entries + 1) + if (num < packet->entries + 1) return true; return false; } @@ -557,30 +567,32 @@ static bool batadv_vis_packet_full(const struct vis_info *info) /* generates a packet of own vis data, * returns 0 on success, -1 if no packet could be generated */ -static int batadv_generate_vis_packet(struct bat_priv *bat_priv) +static int batadv_generate_vis_packet(struct batadv_priv *bat_priv) { - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_node *node; struct hlist_head *head; - struct orig_node *orig_node; - struct neigh_node *router; - struct vis_info *info = bat_priv->my_vis_info; - struct vis_packet *packet = (struct vis_packet *)info->skb_packet->data; - struct vis_info_entry *entry; - struct tt_common_entry *tt_common_entry; + struct batadv_orig_node *orig_node; + struct batadv_neigh_node *router; + struct batadv_vis_info *info = bat_priv->my_vis_info; + struct batadv_vis_packet *packet; + struct batadv_vis_info_entry *entry; + struct batadv_tt_common_entry *tt_common_entry; int best_tq = -1; uint32_t i; info->first_seen = jiffies; + packet = (struct batadv_vis_packet *)info->skb_packet->data; packet->vis_type = atomic_read(&bat_priv->vis_mode); memcpy(packet->target_orig, batadv_broadcast_addr, ETH_ALEN); packet->header.ttl = BATADV_TTL; packet->seqno = htonl(ntohl(packet->seqno) + 1); packet->entries = 0; + packet->reserved = 0; skb_trim(info->skb_packet, sizeof(*packet)); - if (packet->vis_type == VIS_TYPE_CLIENT_UPDATE) { + if (packet->vis_type == BATADV_VIS_TYPE_CLIENT_UPDATE) { best_tq = batadv_find_best_vis_server(bat_priv, info); if (best_tq < 0) @@ -599,14 +611,14 @@ static int batadv_generate_vis_packet(struct bat_priv *bat_priv) if (!batadv_compare_eth(router->addr, orig_node->orig)) goto next; - if (router->if_incoming->if_status != IF_ACTIVE) + if (router->if_incoming->if_status != BATADV_IF_ACTIVE) goto next; if (router->tq_avg < 1) goto next; /* fill one entry into buffer. */ - entry = (struct vis_info_entry *) + entry = (struct batadv_vis_info_entry *) skb_put(info->skb_packet, sizeof(*entry)); memcpy(entry->src, router->if_incoming->net_dev->dev_addr, @@ -632,7 +644,7 @@ next: rcu_read_lock(); hlist_for_each_entry_rcu(tt_common_entry, node, head, hash_entry) { - entry = (struct vis_info_entry *) + entry = (struct batadv_vis_info_entry *) skb_put(info->skb_packet, sizeof(*entry)); memset(entry->src, 0, ETH_ALEN); @@ -656,13 +668,13 @@ unlock: /* free old vis packets. Must be called with this vis_hash_lock * held */ -static void batadv_purge_vis_packets(struct bat_priv *bat_priv) +static void batadv_purge_vis_packets(struct batadv_priv *bat_priv) { uint32_t i; - struct hashtable_t *hash = bat_priv->vis_hash; + struct batadv_hashtable *hash = bat_priv->vis_hash; struct hlist_node *node, *node_tmp; struct hlist_head *head; - struct vis_info *info; + struct batadv_vis_info *info; for (i = 0; i < hash->size; i++) { head = &hash->table[i]; @@ -683,22 +695,22 @@ static void batadv_purge_vis_packets(struct bat_priv *bat_priv) } } -static void batadv_broadcast_vis_packet(struct bat_priv *bat_priv, - struct vis_info *info) +static void batadv_broadcast_vis_packet(struct batadv_priv *bat_priv, + struct batadv_vis_info *info) { - struct neigh_node *router; - struct hashtable_t *hash = bat_priv->orig_hash; + struct batadv_neigh_node *router; + struct batadv_hashtable *hash = bat_priv->orig_hash; struct hlist_node *node; struct hlist_head *head; - struct orig_node *orig_node; - struct vis_packet *packet; + struct batadv_orig_node *orig_node; + struct batadv_vis_packet *packet; struct sk_buff *skb; - struct hard_iface *hard_iface; + struct batadv_hard_iface *hard_iface; uint8_t dstaddr[ETH_ALEN]; uint32_t i; - packet = (struct vis_packet *)info->skb_packet->data; + packet = (struct batadv_vis_packet *)info->skb_packet->data; /* send to all routers in range. */ for (i = 0; i < hash->size; i++) { @@ -707,7 +719,7 @@ static void batadv_broadcast_vis_packet(struct bat_priv *bat_priv, rcu_read_lock(); hlist_for_each_entry_rcu(orig_node, node, head, hash_entry) { /* if it's a vis server and reachable, send it. */ - if (!(orig_node->flags & VIS_SERVER)) + if (!(orig_node->flags & BATADV_VIS_SERVER)) continue; router = batadv_orig_node_get_router(orig_node); @@ -739,15 +751,15 @@ static void batadv_broadcast_vis_packet(struct bat_priv *bat_priv, } } -static void batadv_unicast_vis_packet(struct bat_priv *bat_priv, - struct vis_info *info) +static void batadv_unicast_vis_packet(struct batadv_priv *bat_priv, + struct batadv_vis_info *info) { - struct orig_node *orig_node; - struct neigh_node *router = NULL; + struct batadv_orig_node *orig_node; + struct batadv_neigh_node *router = NULL; struct sk_buff *skb; - struct vis_packet *packet; + struct batadv_vis_packet *packet; - packet = (struct vis_packet *)info->skb_packet->data; + packet = (struct batadv_vis_packet *)info->skb_packet->data; orig_node = batadv_orig_hash_find(bat_priv, packet->target_orig); if (!orig_node) @@ -769,17 +781,17 @@ out: } /* only send one vis packet. called from batadv_send_vis_packets() */ -static void batadv_send_vis_packet(struct bat_priv *bat_priv, - struct vis_info *info) +static void batadv_send_vis_packet(struct batadv_priv *bat_priv, + struct batadv_vis_info *info) { - struct hard_iface *primary_if; - struct vis_packet *packet; + struct batadv_hard_iface *primary_if; + struct batadv_vis_packet *packet; primary_if = batadv_primary_if_get_selected(bat_priv); if (!primary_if) goto out; - packet = (struct vis_packet *)info->skb_packet->data; + packet = (struct batadv_vis_packet *)info->skb_packet->data; if (packet->header.ttl < 2) { pr_debug("Error - can't send vis packet: ttl exceeded\n"); goto out; @@ -804,10 +816,10 @@ static void batadv_send_vis_packets(struct work_struct *work) { struct delayed_work *delayed_work = container_of(work, struct delayed_work, work); - struct bat_priv *bat_priv = - container_of(delayed_work, struct bat_priv, vis_work); - struct vis_info *info; + struct batadv_priv *bat_priv; + struct batadv_vis_info *info; + bat_priv = container_of(delayed_work, struct batadv_priv, vis_work); spin_lock_bh(&bat_priv->vis_hash_lock); batadv_purge_vis_packets(bat_priv); @@ -836,12 +848,13 @@ static void batadv_send_vis_packets(struct work_struct *work) /* init the vis server. this may only be called when if_list is already * initialized (e.g. bat0 is initialized, interfaces have been added) */ -int batadv_vis_init(struct bat_priv *bat_priv) +int batadv_vis_init(struct batadv_priv *bat_priv) { - struct vis_packet *packet; + struct batadv_vis_packet *packet; int hash_added; unsigned int len; unsigned long first_seen; + struct sk_buff *tmp_skb; if (bat_priv->vis_hash) return 0; @@ -864,8 +877,8 @@ int batadv_vis_init(struct bat_priv *bat_priv) goto free_info; skb_reserve(bat_priv->my_vis_info->skb_packet, ETH_HLEN); - packet = (struct vis_packet *)skb_put(bat_priv->my_vis_info->skb_packet, - sizeof(*packet)); + tmp_skb = bat_priv->my_vis_info->skb_packet; + packet = (struct batadv_vis_packet *)skb_put(tmp_skb, sizeof(*packet)); /* prefill the vis info */ first_seen = jiffies - msecs_to_jiffies(BATADV_VIS_INTERVAL); @@ -875,9 +888,10 @@ int batadv_vis_init(struct bat_priv *bat_priv) kref_init(&bat_priv->my_vis_info->refcount); bat_priv->my_vis_info->bat_priv = bat_priv; packet->header.version = BATADV_COMPAT_VERSION; - packet->header.packet_type = BAT_VIS; + packet->header.packet_type = BATADV_VIS; packet->header.ttl = BATADV_TTL; packet->seqno = 0; + packet->reserved = 0; packet->entries = 0; INIT_LIST_HEAD(&bat_priv->vis_send_list); @@ -909,15 +923,15 @@ err: /* Decrease the reference count on a hash item info */ static void batadv_free_info_ref(struct hlist_node *node, void *arg) { - struct vis_info *info; + struct batadv_vis_info *info; - info = container_of(node, struct vis_info, hash_entry); + info = container_of(node, struct batadv_vis_info, hash_entry); batadv_send_list_del(info); kref_put(&info->refcount, batadv_free_info); } /* shutdown vis-server */ -void batadv_vis_quit(struct bat_priv *bat_priv) +void batadv_vis_quit(struct batadv_priv *bat_priv) { if (!bat_priv->vis_hash) return; @@ -933,7 +947,7 @@ void batadv_vis_quit(struct bat_priv *bat_priv) } /* schedule packets for (re)transmission */ -static void batadv_start_vis_timer(struct bat_priv *bat_priv) +static void batadv_start_vis_timer(struct batadv_priv *bat_priv) { INIT_DELAYED_WORK(&bat_priv->vis_work, batadv_send_vis_packets); queue_delayed_work(batadv_event_workqueue, &bat_priv->vis_work, diff --git a/net/batman-adv/vis.h b/net/batman-adv/vis.h index 16a1a6b7e2c3..84e716ed8963 100644 --- a/net/batman-adv/vis.h +++ b/net/batman-adv/vis.h @@ -24,13 +24,13 @@ #define BATADV_VIS_TIMEOUT 200000 int batadv_vis_seq_print_text(struct seq_file *seq, void *offset); -void batadv_receive_server_sync_packet(struct bat_priv *bat_priv, - struct vis_packet *vis_packet, +void batadv_receive_server_sync_packet(struct batadv_priv *bat_priv, + struct batadv_vis_packet *vis_packet, int vis_info_len); -void batadv_receive_client_update_packet(struct bat_priv *bat_priv, - struct vis_packet *vis_packet, +void batadv_receive_client_update_packet(struct batadv_priv *bat_priv, + struct batadv_vis_packet *vis_packet, int vis_info_len); -int batadv_vis_init(struct bat_priv *bat_priv); -void batadv_vis_quit(struct bat_priv *bat_priv); +int batadv_vis_init(struct batadv_priv *bat_priv); +void batadv_vis_quit(struct batadv_priv *bat_priv); #endif /* _NET_BATMAN_ADV_VIS_H_ */ |