This series of patches is a request for comments on the redesigned bridge loop avoidance. The general concept is described in the wiki [1]. I've already performed a few testcases [2] which worked fine in my kvm environment. No crashes while running or unloading the extension either.
The last patch in the series uses the cached address of the primary interface (the originator address known through the mesh) to save some code at various positions, there may be side effects I don't see however (e.g. implicit checking whether the module was configured correctly was removed).
Marek already pointed quite a few issues out, these changes are reflected in the respective commit logs. These commit comments will be removed in the final version.
Any comments and suggestions are appreciated.
Thanks Simon
[1] http://www.open-mesh.org/wiki/batman-adv/Bridge-loop-avoidance-II [2] http://www.open-mesh.org/wiki/batman-adv/Bridge-loop-avoidance-Testcases
Simon Wunderlich (11): batman-adv: remove old bridge loop avoidance code batman-adv: add basic bridge loop avoidance code batman-adv: make bridge loop avoidance switchable batman-adv: export claim tables through debugfs batman-adv: allow multiple entries in tt_global_entries batman-adv: don't let backbone gateways exchange tt entries batman-adv: add broadcast duplicate check batman-adv: drop STP over batman batman-adv: form groups in the bridge loop avoidance batman-adv: Update README and sysfs description [RFC] batman-adv: get primaries address through bat_priv->own_orig
Makefile.kbuild | 1 + README | 28 +- bat_debugfs.c | 18 +- bat_sysfs.c | 4 +- bridge_loop_avoidance.c | 1509 +++++++++++++++++++++++++++++++++++++++++++++++ bridge_loop_avoidance.h | 34 ++ compat.c | 16 +- compat.h | 3 +- hard-interface.c | 8 +- icmp_socket.c | 12 +- main.c | 9 +- main.h | 9 +- originator.c | 3 +- packet.h | 16 + routing.c | 41 +- soft-interface.c | 490 +--------------- soft-interface.h | 2 - sysfs-class-net-mesh | 9 + translation-table.c | 366 ++++++++---- types.h | 70 ++- unicast.c | 9 +- vis.c | 20 +- 22 files changed, 1965 insertions(+), 712 deletions(-) create mode 100644 bridge_loop_avoidance.c create mode 100644 bridge_loop_avoidance.h
The functionality is to be replaced by an improved implementation, so first clean up.
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de
--- [2011-10-30] Changes: * remove obsolete softfif_batman_recv() function
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- bat_debugfs.c | 8 - compat.c | 8 - compat.h | 1 - main.c | 5 - main.h | 2 - originator.c | 2 - soft-interface.c | 477 +----------------------------------------------------- soft-interface.h | 2 - types.h | 21 --- 9 files changed, 1 insertions(+), 525 deletions(-)
diff --git a/bat_debugfs.c b/bat_debugfs.c index d0af9bf..492eec7 100644 --- a/bat_debugfs.c +++ b/bat_debugfs.c @@ -233,12 +233,6 @@ static int gateways_open(struct inode *inode, struct file *file) return single_open(file, gw_client_seq_print_text, net_dev); }
-static int softif_neigh_open(struct inode *inode, struct file *file) -{ - struct net_device *net_dev = (struct net_device *)inode->i_private; - return single_open(file, softif_neigh_seq_print_text, net_dev); -} - static int transtable_global_open(struct inode *inode, struct file *file) { struct net_device *net_dev = (struct net_device *)inode->i_private; @@ -276,7 +270,6 @@ struct bat_debuginfo bat_debuginfo_##_name = { \
static BAT_DEBUGINFO(originators, S_IRUGO, originators_open); static BAT_DEBUGINFO(gateways, S_IRUGO, gateways_open); -static BAT_DEBUGINFO(softif_neigh, S_IRUGO, softif_neigh_open); static BAT_DEBUGINFO(transtable_global, S_IRUGO, transtable_global_open); static BAT_DEBUGINFO(transtable_local, S_IRUGO, transtable_local_open); static BAT_DEBUGINFO(vis_data, S_IRUGO, vis_data_open); @@ -284,7 +277,6 @@ static BAT_DEBUGINFO(vis_data, S_IRUGO, vis_data_open); static struct bat_debuginfo *mesh_debuginfos[] = { &bat_debuginfo_originators, &bat_debuginfo_gateways, - &bat_debuginfo_softif_neigh, &bat_debuginfo_transtable_global, &bat_debuginfo_transtable_local, &bat_debuginfo_vis_data, diff --git a/compat.c b/compat.c index 1793904..4c12468 100644 --- a/compat.c +++ b/compat.c @@ -20,14 +20,6 @@ void free_rcu_neigh_node(struct rcu_head *rcu) kfree(neigh_node); }
-void free_rcu_softif_neigh(struct rcu_head *rcu) -{ - struct softif_neigh *softif_neigh; - - softif_neigh = container_of(rcu, struct softif_neigh, rcu); - kfree(softif_neigh); -} - void free_rcu_tt_local_entry(struct rcu_head *rcu) { struct tt_local_entry *tt_local_entry; diff --git a/compat.h b/compat.h index 964c066..531ba85 100644 --- a/compat.h +++ b/compat.h @@ -68,7 +68,6 @@
void free_rcu_gw_node(struct rcu_head *rcu); void free_rcu_neigh_node(struct rcu_head *rcu); -void free_rcu_softif_neigh(struct rcu_head *rcu); void free_rcu_tt_local_entry(struct rcu_head *rcu);
#endif /* < KERNEL_VERSION(3, 0, 0) */ diff --git a/main.c b/main.c index fb87bdc..36661b4 100644 --- a/main.c +++ b/main.c @@ -90,13 +90,10 @@ int mesh_init(struct net_device *soft_iface) spin_lock_init(&bat_priv->gw_list_lock); spin_lock_init(&bat_priv->vis_hash_lock); spin_lock_init(&bat_priv->vis_list_lock); - spin_lock_init(&bat_priv->softif_neigh_lock); - spin_lock_init(&bat_priv->softif_neigh_vid_lock);
INIT_HLIST_HEAD(&bat_priv->forw_bat_list); INIT_HLIST_HEAD(&bat_priv->forw_bcast_list); INIT_HLIST_HEAD(&bat_priv->gw_list); - INIT_HLIST_HEAD(&bat_priv->softif_neigh_vids); INIT_LIST_HEAD(&bat_priv->tt_changes_list); INIT_LIST_HEAD(&bat_priv->tt_req_list); INIT_LIST_HEAD(&bat_priv->tt_roam_list); @@ -139,8 +136,6 @@ void mesh_free(struct net_device *soft_iface)
tt_free(bat_priv);
- softif_neigh_purge(bat_priv); - atomic_set(&bat_priv->mesh_state, MESH_INACTIVE); }
diff --git a/main.h b/main.h index 53e5d9f..b395c7b 100644 --- a/main.h +++ b/main.h @@ -79,8 +79,6 @@ #define MAX_AGGREGATION_BYTES 512 #define MAX_AGGREGATION_MS 100
-#define SOFTIF_NEIGH_TIMEOUT 180000 /* 3 minutes */ - /* don't reset again within 30 seconds */ #define RESET_PROTECTION_MS 30000 #define EXPECTED_SEQNO_RANGE 65536 diff --git a/originator.c b/originator.c index 0bc2045..a9c8b66 100644 --- a/originator.c +++ b/originator.c @@ -380,8 +380,6 @@ static void _purge_orig(struct bat_priv *bat_priv)
gw_node_purge(bat_priv); gw_election(bat_priv); - - softif_neigh_purge(bat_priv); }
static void purge_orig(struct work_struct *work) diff --git a/soft-interface.c b/soft-interface.c index 45297c8..4806deb 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -73,440 +73,6 @@ int my_skb_head_push(struct sk_buff *skb, unsigned int len) return 0; }
-static void softif_neigh_free_ref(struct softif_neigh *softif_neigh) -{ - if (atomic_dec_and_test(&softif_neigh->refcount)) - kfree_rcu(softif_neigh, rcu); -} - -static void softif_neigh_vid_free_rcu(struct rcu_head *rcu) -{ - struct softif_neigh_vid *softif_neigh_vid; - struct softif_neigh *softif_neigh; - struct hlist_node *node, *node_tmp; - struct bat_priv *bat_priv; - - softif_neigh_vid = container_of(rcu, struct softif_neigh_vid, rcu); - bat_priv = softif_neigh_vid->bat_priv; - - spin_lock_bh(&bat_priv->softif_neigh_lock); - hlist_for_each_entry_safe(softif_neigh, node, node_tmp, - &softif_neigh_vid->softif_neigh_list, list) { - hlist_del_rcu(&softif_neigh->list); - softif_neigh_free_ref(softif_neigh); - } - spin_unlock_bh(&bat_priv->softif_neigh_lock); - - kfree(softif_neigh_vid); -} - -static void softif_neigh_vid_free_ref(struct softif_neigh_vid *softif_neigh_vid) -{ - if (atomic_dec_and_test(&softif_neigh_vid->refcount)) - call_rcu(&softif_neigh_vid->rcu, softif_neigh_vid_free_rcu); -} - -static struct softif_neigh_vid *softif_neigh_vid_get(struct bat_priv *bat_priv, - short vid) -{ - struct softif_neigh_vid *softif_neigh_vid; - struct hlist_node *node; - - rcu_read_lock(); - hlist_for_each_entry_rcu(softif_neigh_vid, node, - &bat_priv->softif_neigh_vids, list) { - if (softif_neigh_vid->vid != vid) - continue; - - if (!atomic_inc_not_zero(&softif_neigh_vid->refcount)) - continue; - - goto out; - } - - softif_neigh_vid = kzalloc(sizeof(*softif_neigh_vid), GFP_ATOMIC); - if (!softif_neigh_vid) - goto out; - - softif_neigh_vid->vid = vid; - softif_neigh_vid->bat_priv = bat_priv; - - /* initialize with 2 - caller decrements counter by one */ - atomic_set(&softif_neigh_vid->refcount, 2); - INIT_HLIST_HEAD(&softif_neigh_vid->softif_neigh_list); - INIT_HLIST_NODE(&softif_neigh_vid->list); - spin_lock_bh(&bat_priv->softif_neigh_vid_lock); - hlist_add_head_rcu(&softif_neigh_vid->list, - &bat_priv->softif_neigh_vids); - spin_unlock_bh(&bat_priv->softif_neigh_vid_lock); - -out: - rcu_read_unlock(); - return softif_neigh_vid; -} - -static struct softif_neigh *softif_neigh_get(struct bat_priv *bat_priv, - const uint8_t *addr, short vid) -{ - struct softif_neigh_vid *softif_neigh_vid; - struct softif_neigh *softif_neigh = NULL; - struct hlist_node *node; - - softif_neigh_vid = softif_neigh_vid_get(bat_priv, vid); - if (!softif_neigh_vid) - goto out; - - rcu_read_lock(); - hlist_for_each_entry_rcu(softif_neigh, node, - &softif_neigh_vid->softif_neigh_list, - list) { - if (!compare_eth(softif_neigh->addr, addr)) - continue; - - if (!atomic_inc_not_zero(&softif_neigh->refcount)) - continue; - - softif_neigh->last_seen = jiffies; - goto unlock; - } - - softif_neigh = kzalloc(sizeof(*softif_neigh), GFP_ATOMIC); - if (!softif_neigh) - goto unlock; - - memcpy(softif_neigh->addr, addr, ETH_ALEN); - softif_neigh->last_seen = jiffies; - /* initialize with 2 - caller decrements counter by one */ - atomic_set(&softif_neigh->refcount, 2); - - INIT_HLIST_NODE(&softif_neigh->list); - spin_lock_bh(&bat_priv->softif_neigh_lock); - hlist_add_head_rcu(&softif_neigh->list, - &softif_neigh_vid->softif_neigh_list); - spin_unlock_bh(&bat_priv->softif_neigh_lock); - -unlock: - rcu_read_unlock(); -out: - if (softif_neigh_vid) - softif_neigh_vid_free_ref(softif_neigh_vid); - return softif_neigh; -} - -static struct softif_neigh *softif_neigh_get_selected( - struct softif_neigh_vid *softif_neigh_vid) -{ - struct softif_neigh *softif_neigh; - - rcu_read_lock(); - softif_neigh = rcu_dereference(softif_neigh_vid->softif_neigh); - - if (softif_neigh && !atomic_inc_not_zero(&softif_neigh->refcount)) - softif_neigh = NULL; - - rcu_read_unlock(); - return softif_neigh; -} - -static struct softif_neigh *softif_neigh_vid_get_selected( - struct bat_priv *bat_priv, - short vid) -{ - struct softif_neigh_vid *softif_neigh_vid; - struct softif_neigh *softif_neigh = NULL; - - softif_neigh_vid = softif_neigh_vid_get(bat_priv, vid); - if (!softif_neigh_vid) - goto out; - - softif_neigh = softif_neigh_get_selected(softif_neigh_vid); -out: - if (softif_neigh_vid) - softif_neigh_vid_free_ref(softif_neigh_vid); - return softif_neigh; -} - -static void softif_neigh_vid_select(struct bat_priv *bat_priv, - struct softif_neigh *new_neigh, - short vid) -{ - struct softif_neigh_vid *softif_neigh_vid; - struct softif_neigh *curr_neigh; - - softif_neigh_vid = softif_neigh_vid_get(bat_priv, vid); - if (!softif_neigh_vid) - goto out; - - spin_lock_bh(&bat_priv->softif_neigh_lock); - - if (new_neigh && !atomic_inc_not_zero(&new_neigh->refcount)) - new_neigh = NULL; - - curr_neigh = rcu_dereference_protected(softif_neigh_vid->softif_neigh, - 1); - rcu_assign_pointer(softif_neigh_vid->softif_neigh, new_neigh); - - if ((curr_neigh) && (!new_neigh)) - bat_dbg(DBG_ROUTES, bat_priv, - "Removing mesh exit point on vid: %d (prev: %pM).\n", - vid, curr_neigh->addr); - else if ((curr_neigh) && (new_neigh)) - bat_dbg(DBG_ROUTES, bat_priv, - "Changing mesh exit point on vid: %d from %pM " - "to %pM.\n", vid, curr_neigh->addr, new_neigh->addr); - else if ((!curr_neigh) && (new_neigh)) - bat_dbg(DBG_ROUTES, bat_priv, - "Setting mesh exit point on vid: %d to %pM.\n", - vid, new_neigh->addr); - - if (curr_neigh) - softif_neigh_free_ref(curr_neigh); - - spin_unlock_bh(&bat_priv->softif_neigh_lock); - -out: - if (softif_neigh_vid) - softif_neigh_vid_free_ref(softif_neigh_vid); -} - -static void softif_neigh_vid_deselect(struct bat_priv *bat_priv, - struct softif_neigh_vid *softif_neigh_vid) -{ - struct softif_neigh *curr_neigh; - struct softif_neigh *softif_neigh = NULL, *softif_neigh_tmp; - struct hard_iface *primary_if = NULL; - struct hlist_node *node; - - primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto out; - - /* find new softif_neigh immediately to avoid temporary loops */ - rcu_read_lock(); - curr_neigh = rcu_dereference(softif_neigh_vid->softif_neigh); - - hlist_for_each_entry_rcu(softif_neigh_tmp, node, - &softif_neigh_vid->softif_neigh_list, - list) { - if (softif_neigh_tmp == curr_neigh) - continue; - - /* we got a neighbor but its mac is 'bigger' than ours */ - if (memcmp(primary_if->net_dev->dev_addr, - softif_neigh_tmp->addr, ETH_ALEN) < 0) - continue; - - if (!atomic_inc_not_zero(&softif_neigh_tmp->refcount)) - continue; - - softif_neigh = softif_neigh_tmp; - goto unlock; - } - -unlock: - rcu_read_unlock(); -out: - softif_neigh_vid_select(bat_priv, softif_neigh, softif_neigh_vid->vid); - - if (primary_if) - hardif_free_ref(primary_if); - if (softif_neigh) - softif_neigh_free_ref(softif_neigh); -} - -int softif_neigh_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 softif_neigh_vid *softif_neigh_vid; - struct softif_neigh *softif_neigh; - struct hard_iface *primary_if; - struct hlist_node *node, *node_tmp; - struct softif_neigh *curr_softif_neigh; - int ret = 0, last_seen_secs, last_seen_msecs; - - primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) { - ret = seq_printf(seq, "BATMAN mesh %s disabled - " - "please specify interfaces to enable it\n", - net_dev->name); - goto out; - } - - if (primary_if->if_status != IF_ACTIVE) { - ret = seq_printf(seq, "BATMAN mesh %s " - "disabled - primary interface not active\n", - net_dev->name); - goto out; - } - - seq_printf(seq, "Softif neighbor list (%s)\n", net_dev->name); - - rcu_read_lock(); - hlist_for_each_entry_rcu(softif_neigh_vid, node, - &bat_priv->softif_neigh_vids, list) { - seq_printf(seq, " %-15s %s on vid: %d\n", - "Originator", "last-seen", softif_neigh_vid->vid); - - curr_softif_neigh = softif_neigh_get_selected(softif_neigh_vid); - - hlist_for_each_entry_rcu(softif_neigh, node_tmp, - &softif_neigh_vid->softif_neigh_list, - list) { - last_seen_secs = jiffies_to_msecs(jiffies - - softif_neigh->last_seen) / 1000; - last_seen_msecs = jiffies_to_msecs(jiffies - - softif_neigh->last_seen) % 1000; - seq_printf(seq, "%s %pM %3i.%03is\n", - curr_softif_neigh == softif_neigh - ? "=>" : " ", softif_neigh->addr, - last_seen_secs, last_seen_msecs); - } - - if (curr_softif_neigh) - softif_neigh_free_ref(curr_softif_neigh); - - seq_printf(seq, "\n"); - } - rcu_read_unlock(); - -out: - if (primary_if) - hardif_free_ref(primary_if); - return ret; -} - -void softif_neigh_purge(struct bat_priv *bat_priv) -{ - struct softif_neigh *softif_neigh, *curr_softif_neigh; - struct softif_neigh_vid *softif_neigh_vid; - struct hlist_node *node, *node_tmp, *node_tmp2; - int do_deselect; - - rcu_read_lock(); - hlist_for_each_entry_rcu(softif_neigh_vid, node, - &bat_priv->softif_neigh_vids, list) { - if (!atomic_inc_not_zero(&softif_neigh_vid->refcount)) - continue; - - curr_softif_neigh = softif_neigh_get_selected(softif_neigh_vid); - do_deselect = 0; - - spin_lock_bh(&bat_priv->softif_neigh_lock); - hlist_for_each_entry_safe(softif_neigh, node_tmp, node_tmp2, - &softif_neigh_vid->softif_neigh_list, - list) { - if ((!time_after(jiffies, softif_neigh->last_seen + - msecs_to_jiffies(SOFTIF_NEIGH_TIMEOUT))) && - (atomic_read(&bat_priv->mesh_state) == MESH_ACTIVE)) - continue; - - if (curr_softif_neigh == softif_neigh) { - bat_dbg(DBG_ROUTES, bat_priv, - "Current mesh exit point on vid: %d " - "'%pM' vanished.\n", - softif_neigh_vid->vid, - softif_neigh->addr); - do_deselect = 1; - } - - hlist_del_rcu(&softif_neigh->list); - softif_neigh_free_ref(softif_neigh); - } - spin_unlock_bh(&bat_priv->softif_neigh_lock); - - /* soft_neigh_vid_deselect() needs to acquire the - * softif_neigh_lock */ - if (do_deselect) - softif_neigh_vid_deselect(bat_priv, softif_neigh_vid); - - if (curr_softif_neigh) - softif_neigh_free_ref(curr_softif_neigh); - - softif_neigh_vid_free_ref(softif_neigh_vid); - } - rcu_read_unlock(); - - spin_lock_bh(&bat_priv->softif_neigh_vid_lock); - hlist_for_each_entry_safe(softif_neigh_vid, node, node_tmp, - &bat_priv->softif_neigh_vids, list) { - if (!hlist_empty(&softif_neigh_vid->softif_neigh_list)) - continue; - - hlist_del_rcu(&softif_neigh_vid->list); - softif_neigh_vid_free_ref(softif_neigh_vid); - } - spin_unlock_bh(&bat_priv->softif_neigh_vid_lock); - -} - -static void softif_batman_recv(struct sk_buff *skb, struct net_device *dev, - short vid) -{ - struct bat_priv *bat_priv = netdev_priv(dev); - struct ethhdr *ethhdr = (struct ethhdr *)skb->data; - struct batman_ogm_packet *batman_ogm_packet; - struct softif_neigh *softif_neigh = NULL; - struct hard_iface *primary_if = NULL; - struct softif_neigh *curr_softif_neigh = NULL; - - if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) - batman_ogm_packet = (struct batman_ogm_packet *) - (skb->data + ETH_HLEN + VLAN_HLEN); - else - batman_ogm_packet = (struct batman_ogm_packet *) - (skb->data + ETH_HLEN); - - if (batman_ogm_packet->version != COMPAT_VERSION) - goto out; - - if (batman_ogm_packet->packet_type != BAT_OGM) - goto out; - - if (!(batman_ogm_packet->flags & PRIMARIES_FIRST_HOP)) - goto out; - - if (is_my_mac(batman_ogm_packet->orig)) - goto out; - - softif_neigh = softif_neigh_get(bat_priv, batman_ogm_packet->orig, vid); - if (!softif_neigh) - goto out; - - curr_softif_neigh = softif_neigh_vid_get_selected(bat_priv, vid); - if (curr_softif_neigh == softif_neigh) - goto out; - - primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto out; - - /* we got a neighbor but its mac is 'bigger' than ours */ - if (memcmp(primary_if->net_dev->dev_addr, - softif_neigh->addr, ETH_ALEN) < 0) - goto out; - - /* close own batX device and use softif_neigh as exit node */ - if (!curr_softif_neigh) { - softif_neigh_vid_select(bat_priv, softif_neigh, vid); - goto out; - } - - /* switch to new 'smallest neighbor' */ - if (memcmp(softif_neigh->addr, curr_softif_neigh->addr, ETH_ALEN) < 0) - softif_neigh_vid_select(bat_priv, softif_neigh, vid); - -out: - kfree_skb(skb); - if (softif_neigh) - softif_neigh_free_ref(softif_neigh); - if (curr_softif_neigh) - softif_neigh_free_ref(curr_softif_neigh); - if (primary_if) - hardif_free_ref(primary_if); - return; -} - static int interface_open(struct net_device *dev) { netif_start_queue(dev); @@ -562,7 +128,6 @@ static int interface_tx(struct sk_buff *skb, struct net_device *soft_iface) struct hard_iface *primary_if = NULL; struct bcast_packet *bcast_packet; struct vlan_ethhdr *vhdr; - struct softif_neigh *curr_softif_neigh = NULL; unsigned int header_len = 0; int data_len = skb->len, ret; short vid = -1; @@ -583,17 +148,8 @@ static int interface_tx(struct sk_buff *skb, struct net_device *soft_iface)
/* fall through */ case ETH_P_BATMAN: - softif_batman_recv(skb, soft_iface, vid); - goto end; - } - - /** - * if we have a another chosen mesh exit node in range - * it will transport the packets to the mesh - */ - curr_softif_neigh = softif_neigh_vid_get_selected(bat_priv, vid); - if (curr_softif_neigh) goto dropped; + }
/* Register the client MAC in the transtable */ tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif); @@ -675,8 +231,6 @@ dropped: dropped_freed: bat_priv->stats.tx_dropped++; end: - if (curr_softif_neigh) - softif_neigh_free_ref(curr_softif_neigh); if (primary_if) hardif_free_ref(primary_if); return NETDEV_TX_OK; @@ -687,12 +241,9 @@ void interface_rx(struct net_device *soft_iface, int hdr_size) { struct bat_priv *bat_priv = netdev_priv(soft_iface); - struct unicast_packet *unicast_packet; struct ethhdr *ethhdr; struct vlan_ethhdr *vhdr; - struct softif_neigh *curr_softif_neigh = NULL; short vid = -1; - int ret;
/* check if enough space is available for pulling, and pull */ if (!pskb_may_pull(skb, hdr_size)) @@ -716,30 +267,6 @@ void interface_rx(struct net_device *soft_iface, goto dropped; }
- /** - * if we have a another chosen mesh exit node in range - * it will transport the packets to the non-mesh network - */ - curr_softif_neigh = softif_neigh_vid_get_selected(bat_priv, vid); - if (curr_softif_neigh) { - skb_push(skb, hdr_size); - unicast_packet = (struct unicast_packet *)skb->data; - - if ((unicast_packet->packet_type != BAT_UNICAST) && - (unicast_packet->packet_type != BAT_UNICAST_FRAG)) - goto dropped; - - skb_reset_mac_header(skb); - - memcpy(unicast_packet->dest, - curr_softif_neigh->addr, ETH_ALEN); - ret = route_unicast_packet(skb, recv_if); - if (ret == NET_RX_DROP) - goto dropped; - - goto out; - } - /* skb->dev & skb->pkt_type are set here */ if (unlikely(!pskb_may_pull(skb, ETH_HLEN))) goto dropped; @@ -765,8 +292,6 @@ void interface_rx(struct net_device *soft_iface, dropped: kfree_skb(skb); out: - if (curr_softif_neigh) - softif_neigh_free_ref(curr_softif_neigh); return; }
diff --git a/soft-interface.h b/soft-interface.h index 001546f..694f0f6 100644 --- a/soft-interface.h +++ b/soft-interface.h @@ -23,8 +23,6 @@ #define _NET_BATMAN_ADV_SOFT_INTERFACE_H_
int my_skb_head_push(struct sk_buff *skb, unsigned int len); -int softif_neigh_seq_print_text(struct seq_file *seq, void *offset); -void softif_neigh_purge(struct bat_priv *bat_priv); void interface_rx(struct net_device *soft_iface, struct sk_buff *skb, struct hard_iface *recv_if, int hdr_size); diff --git a/types.h b/types.h index ab8d0fe..db6ae2b 100644 --- a/types.h +++ b/types.h @@ -173,7 +173,6 @@ struct bat_priv { struct hlist_head forw_bat_list; struct hlist_head forw_bcast_list; struct hlist_head gw_list; - struct hlist_head softif_neigh_vids; struct list_head tt_changes_list; /* tracks changes in a OGM int */ struct list_head vis_send_list; struct hashtable_t *orig_hash; @@ -190,8 +189,6 @@ struct bat_priv { spinlock_t gw_list_lock; /* protects gw_list and curr_gw */ spinlock_t vis_hash_lock; /* protects vis_hash */ spinlock_t vis_list_lock; /* protects vis_info::recv_list */ - spinlock_t softif_neigh_lock; /* protects soft-interface neigh list */ - spinlock_t softif_neigh_vid_lock; /* protects soft-interface vid list */ atomic_t num_local_tt; /* Checksum of the local table, recomputed before sending a new OGM */ atomic_t tt_crc; @@ -325,22 +322,4 @@ struct recvlist_node { uint8_t mac[ETH_ALEN]; };
-struct softif_neigh_vid { - struct hlist_node list; - struct bat_priv *bat_priv; - short vid; - atomic_t refcount; - struct softif_neigh __rcu *softif_neigh; - struct rcu_head rcu; - struct hlist_head softif_neigh_list; -}; - -struct softif_neigh { - struct hlist_node list; - uint8_t addr[ETH_ALEN]; - unsigned long last_seen; - atomic_t refcount; - struct rcu_head rcu; -}; - #endif /* _NET_BATMAN_ADV_TYPES_H_ */
This second version of the bridge loop avoidance for batman-adv avoids loops between the mesh and a backbone (usually a LAN).
By connecting multiple batman-adv mesh nodes to the same ethernet segment a loop can be created when the soft-interface is bridged into that ethernet segment. A simple visualization of the loop involving the most common case - a LAN as ethernet segment:
node1 <-- LAN --> node2 | | wifi <-- mesh --> wifi
Packets from the LAN (e.g. ARP broadcasts) will circle forever from node1 or node2 over the mesh back into the LAN.
With this patch, batman recognizes backbone gateways, nodes which are part of the mesh and backbone/LAN at the same time. Each backbone gateway "claims" clients from within the mesh to handle them exclusively. By restricting that only responsible backbone gateways may handle their claimed clients traffic, loops are effectively avoided.
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de
--- [2011-10-27] Changes suggested by Marek Lindner:
* move claim types into packet.h * uint16_t -> short for vid in compare_* * remove refcount debugging * add comments to spinlocks to silence checkpatch --strict * move hardif_free_ref at the end of the function in bla_send_claim() * bla_del_claim(): move free ref up to make it more clear why we free * the reference * bla_purge_claims() does not need spinlock * move rcu_read_lock() more into the loops
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de
[2011-10-27] add a type for the bla destinations
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de
[2011-10-30] Changes suggested by Marek Lindner:
* add BLA_CRC_INIT to show more visibly the initializiation of the CRC * put own_orig into bat_priv instead using a function which needlessly copies around * update backbone gws when primary if address changes * add bla_send_announce() as own function for readability * fix some comments * give hw_src and hw_dst as parameter in handle_*() and check_claim_group() to avoid code duplicates * change various debugging code * replace add_own_claim and del_own_claim with handle_claim() and handle_unclaim() to reduce code size * pimp up claim table debugfs output
VLAN fixes: * reset skb_mac_header(), it might not be set when its a VLAN frame * always become a backbone gw for a VLAN when there is traffic, even if there are no claims, to let at least let other backbone gw nodes that we are able to receive on that VLAN and avoid broadcast loops.
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- Makefile.kbuild | 1 + bat_sysfs.c | 2 +- bridge_loop_avoidance.c | 1240 +++++++++++++++++++++++++++++++++++++++++++++++ bridge_loop_avoidance.h | 30 ++ compat.c | 8 + compat.h | 2 + hard-interface.c | 8 +- main.c | 6 + main.h | 6 +- originator.c | 1 + packet.h | 16 + routing.c | 6 + soft-interface.c | 11 + types.h | 28 ++ 14 files changed, 1362 insertions(+), 3 deletions(-) create mode 100644 bridge_loop_avoidance.c create mode 100644 bridge_loop_avoidance.h
diff --git a/Makefile.kbuild b/Makefile.kbuild index bd7e93c..d626513 100644 --- a/Makefile.kbuild +++ b/Makefile.kbuild @@ -51,3 +51,4 @@ batman-adv-y += translation-table.o batman-adv-y += unicast.o batman-adv-y += vis.o batman-adv-y += compat.o +batman-adv-y += bridge_loop_avoidance.o diff --git a/bat_sysfs.c b/bat_sysfs.c index c25492f..ec2e437 100644 --- a/bat_sysfs.c +++ b/bat_sysfs.c @@ -390,7 +390,7 @@ BAT_ATTR_UINT(gw_sel_class, S_IRUGO | S_IWUSR, 1, TQ_MAX_VALUE, static BAT_ATTR(gw_bandwidth, S_IRUGO | S_IWUSR, show_gw_bwidth, store_gw_bwidth); #ifdef CONFIG_BATMAN_ADV_DEBUG -BAT_ATTR_UINT(log_level, S_IRUGO | S_IWUSR, 0, 7, NULL); +BAT_ATTR_UINT(log_level, S_IRUGO | S_IWUSR, 0, 15, NULL); #endif
static struct bat_attribute *mesh_attrs[] = { diff --git a/bridge_loop_avoidance.c b/bridge_loop_avoidance.c new file mode 100644 index 0000000..641dbcc --- /dev/null +++ b/bridge_loop_avoidance.c @@ -0,0 +1,1240 @@ +/* + * Copyright (C) 2011 B.A.T.M.A.N. contributors: + * + * Simon Wunderlich + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of version 2 of the GNU General Public + * License as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + * + */ + +#include "main.h" +#include "hash.h" +#include "hard-interface.h" +#include "originator.h" +#include "bridge_loop_avoidance.h" +#include "send.h" + +#include <linux/etherdevice.h> +#include <linux/crc16.h> +#include <linux/if_arp.h> +#include <net/arp.h> +#include <linux/if_vlan.h> + +static const uint8_t claim_dest[6] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00}; +static const uint8_t announce_mac[6] = {0x43, 0x05, 0x43, 0x05, 0x00, 0x00}; + +static void bla_periodic_work(struct work_struct *work); +static void bla_send_announce(struct bat_priv *bat_priv, + struct backbone_gw *backbone_gw); + +/** + * + * @mac: MAC address of the client which is to be checked + * @vid: VID of the VLAN + * + * Returns 1 if the mac is already claimed by ourselves or another node. + */ + +static inline uint32_t choose_claim(const void *data, uint32_t size) +{ + const unsigned char *key = data; + uint32_t hash = 0; + size_t i; + + for (i = 0; i < ETH_ALEN + sizeof(short); i++) { + hash += key[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + + return hash % size; +} + +/* compares address and vid of two backbone gws */ +static int compare_backbone_gw(const struct hlist_node *node, const void *data2) +{ + const void *data1 = container_of(node, struct backbone_gw, + hash_entry); + + return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0); +} + +/* compares address and vid of two claims */ +static int compare_claim(const struct hlist_node *node, const void *data2) +{ + const void *data1 = container_of(node, struct claim, + hash_entry); + + return (memcmp(data1, data2, ETH_ALEN + sizeof(short)) == 0 ? 1 : 0); +} + +/* free a backbone gw */ +static void backbone_gw_free_ref(struct backbone_gw *backbone_gw) +{ + if (atomic_dec_and_test(&backbone_gw->refcount)) + kfree_rcu(backbone_gw, rcu); +} + +/* finally deinitialize the claim */ +static void claim_free_rcu(struct rcu_head *rcu) +{ + struct claim *claim; + + claim = container_of(rcu, struct claim, rcu); + + backbone_gw_free_ref(claim->backbone_gw); + kfree(claim); +} + +/* free a claim, call claim_free_rcu if its the last reference */ +static void claim_free_ref(struct claim *claim) +{ + if (atomic_dec_and_test(&claim->refcount)) + call_rcu(&claim->rcu, claim_free_rcu); +} + +/* + * @bat_priv: the bat priv with all the soft interface information + * @data: search data (may be local/static data) + * + * looks for a claim in the hash, and returns it if found + * or NULL otherwise. + */ + +static struct claim *claim_hash_find(struct bat_priv *bat_priv, + struct claim *data) +{ + struct hashtable_t *hash = bat_priv->claim_hash; + struct hlist_head *head; + struct hlist_node *node; + struct claim *claim; + struct claim *claim_tmp = NULL; + int index; + + if (!hash) + return NULL; + + index = choose_claim(data, hash->size); + head = &hash->table[index]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(claim, node, head, hash_entry) { + if (!compare_claim(&claim->hash_entry, data)) + continue; + + if (!atomic_inc_not_zero(&claim->refcount)) + continue; + + claim_tmp = claim; + break; + } + rcu_read_unlock(); + + return claim_tmp; +} + +/* + * @bat_priv: the bat priv with all the soft interface information + * @addr: the address of the originator + * @vid: the VLAN ID + * + * looks for a claim in the hash, and returns it if found + * or NULL otherwise. + */ + +static struct backbone_gw *backbone_hash_find(struct bat_priv *bat_priv, + uint8_t *addr, short vid) +{ + struct hashtable_t *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; + int index; + + if (!hash) + return NULL; + + memcpy(search_entry.orig, addr, ETH_ALEN); + search_entry.vid = vid; + + /* *_claim() works for backbone gws too */ + index = choose_claim(&search_entry, hash->size); + head = &hash->table[index]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) { + if (!compare_backbone_gw(&backbone_gw->hash_entry, + &search_entry)) + continue; + + if (!atomic_inc_not_zero(&backbone_gw->refcount)) + continue; + + backbone_gw_tmp = backbone_gw; + break; + } + rcu_read_unlock(); + + return backbone_gw_tmp; +} + +/* delete all claims for a backbone */ +static void bla_del_backbone_claims(struct backbone_gw *backbone_gw) +{ + struct hashtable_t *hash; + struct hlist_node *node, *node_tmp; + struct hlist_head *head; + struct claim *claim; + int i; + spinlock_t *list_lock; /* protects write access to the hash lists */ + + hash = backbone_gw->bat_priv->claim_hash; + if (!hash) + return; + + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + list_lock = &hash->list_locks[i]; + + spin_lock_bh(list_lock); + hlist_for_each_entry_safe(claim, node, node_tmp, + head, hash_entry) { + + if (claim->backbone_gw != backbone_gw) + continue; + + claim_free_ref(claim); + hlist_del_rcu(node); + } + spin_unlock_bh(list_lock); + } + + /* all claims gone, intialize CRC */ + backbone_gw->crc = BLA_CRC_INIT; +} + +/* + * @bat_priv: the bat priv with all the soft interface information + * @orig: the mac address to be announced within the claim + * @vid: the VLAN ID + * @claimtype: the type of the claim (CLAIM, UNCLAIM, ANNOUNCE, ...) + * + * sends a claim frame according to the provided info. + */ + +static void bla_send_claim(struct bat_priv *bat_priv, uint8_t *mac, + short vid, int claimtype) +{ + struct sk_buff *skb; + struct ethhdr *ethhdr; + struct hard_iface *primary_if; + struct net_device *soft_iface; + uint8_t *hw_src; + struct bla_claim_dst local_claim_dest; + uint32_t zeroip = 0; + + primary_if = primary_if_get_selected(bat_priv); + if (!primary_if) + return; + + memcpy(&local_claim_dest, claim_dest, + sizeof(local_claim_dest)); + local_claim_dest.type = claimtype; + + soft_iface = primary_if->soft_iface; + + skb = arp_create(ARPOP_REPLY, ETH_P_ARP, + zeroip, /* IP DST: 0.0.0.0 */ + primary_if->soft_iface, + zeroip, /* IP SRC: 0.0.0.0 */ + NULL, /* Ethernet DST: Broadcast */ + primary_if->net_dev->dev_addr, /* Ethernet SRC/HW SRC: + * originator mac */ + (uint8_t *)&local_claim_dest /* HW DST: FF:43:05:XX:00:00 + * with XX = claim type */ + ); + + if (!skb) + goto out; + + ethhdr = (struct ethhdr *)skb->data; + hw_src = (uint8_t *) ethhdr + + sizeof(struct ethhdr) + sizeof(struct arphdr); + + /* now we pretend that the client would have sent this ... */ + switch (claimtype) { + case CLAIM_TYPE_ADD: + /* + * normal claim frame + * set Ethernet SRC to the clients mac + */ + memcpy(ethhdr->h_source, mac, ETH_ALEN); + bat_dbg(DBG_BLA, bat_priv, + "bla_send_claim(): CLAIM %pM on vid %d\n", mac, vid); + break; + case CLAIM_TYPE_DEL: + /* + * unclaim frame + * set HW SRC to the clients mac + */ + memcpy(hw_src, mac, ETH_ALEN); + bat_dbg(DBG_BLA, bat_priv, + "bla_send_claim(): UNCLAIM %pM on vid %d\n", mac, vid); + break; + case CLAIM_TYPE_ANNOUNCE: + /* + * announcement frame + * set HW SRC to the special mac containg the crc + */ + memcpy(hw_src, mac, ETH_ALEN); + bat_dbg(DBG_BLA, bat_priv, + "bla_send_claim(): ANNOUNCE of %pM on vid %d\n", + ethhdr->h_source, vid); + break; + case 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); + bat_dbg(DBG_BLA, bat_priv, + "bla_send_claim(): REQUEST of %pM to %pMon vid %d\n", + ethhdr->h_source, ethhdr->h_dest, vid); + break; + + } + + if (vid != -1) + skb = vlan_insert_tag(skb, vid); + + skb_reset_mac_header(skb); + skb->protocol = eth_type_trans(skb, soft_iface); + bat_priv->stats.rx_packets++; + bat_priv->stats.rx_bytes += skb->len + sizeof(struct ethhdr); + soft_iface->last_rx = jiffies; + + netif_rx(skb); +out: + if (primary_if) + hardif_free_ref(primary_if); +} + +/* + * @bat_priv: the bat priv with all the soft interface information + * @orig: the mac address of the originator + * @vid: the VLAN ID + * + * searches for the backbone gw or creates a new one if it could not + * be found. + */ + +static struct backbone_gw *bla_get_backbone_gw(struct bat_priv *bat_priv, + uint8_t *orig, short vid) +{ + struct backbone_gw *entry; + + entry = backbone_hash_find(bat_priv, orig, vid); + + if (entry) + return entry; + + bat_dbg(DBG_BLA, bat_priv, + "bla_get_backbone_gw(): not found (%pM, %d)," + " creating new entry\n", orig, vid); + + entry = kzalloc(sizeof(*entry), GFP_ATOMIC); + if (!entry) + return NULL; + + entry->vid = vid; + entry->lasttime = jiffies; + entry->crc = BLA_CRC_INIT; + entry->bat_priv = bat_priv; + atomic_set(&entry->request_sent, 0); + memcpy(entry->orig, orig, ETH_ALEN); + + /* one for the hash, one for returning */ + atomic_set(&entry->refcount, 2); + + hash_add(bat_priv->backbone_hash, compare_backbone_gw, choose_claim, + entry, &entry->hash_entry); + + return entry; +} + +/* + * update or add the own backbone gw to make sure we announce + * where we receive other backbone gws + */ +void bla_update_own_backbone_gw(struct bat_priv *bat_priv, short vid) +{ + struct backbone_gw *backbone_gw; + + backbone_gw = bla_get_backbone_gw(bat_priv, bat_priv->own_orig, vid); + backbone_gw->lasttime = jiffies; +} + +/* + * @bat_priv: the bat priv with all the soft interface information + * @vid: the vid where the request came on + * + * 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 bla_handle_request(struct bat_priv *bat_priv, short vid) +{ + struct hlist_node *node; + struct hlist_head *head; + struct hashtable_t *hash; + struct claim *claim; + struct backbone_gw *backbone_gw; + int i; + + bat_dbg(DBG_BLA, bat_priv, + "bla_handle_request(): received a " + "claim request, send all of our own claims again\n"); + + backbone_gw = backbone_hash_find(bat_priv, bat_priv->own_orig, vid); + + hash = bat_priv->claim_hash; + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(claim, node, + head, hash_entry) { + /* only own claims are interesting */ + if (claim->backbone_gw != backbone_gw) + continue; + + bla_send_claim(bat_priv, claim->addr, claim->vid, + CLAIM_TYPE_ADD); + } + rcu_read_unlock(); + } + + /* finally, send an announcement frame */ + bla_send_announce(bat_priv, backbone_gw); + backbone_gw_free_ref(backbone_gw); +} + +/* + * @backbone_gw: the backbone gateway from whom we are out of sync + * + * When the crc is wrong, ask the backbone gateway for a full table update. + * 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 bla_send_request(struct backbone_gw *backbone_gw) +{ + /* first, remove all old entries */ + bla_del_backbone_claims(backbone_gw); + + bat_dbg(DBG_BLA, backbone_gw->bat_priv, + "Sending REQUEST to %pM\n", + backbone_gw->orig); + + /* send request */ + bla_send_claim(backbone_gw->bat_priv, backbone_gw->orig, + backbone_gw->vid, CLAIM_TYPE_REQUEST); + + /* no local broadcasts should be sent or received, for now. */ + if (!atomic_read(&backbone_gw->request_sent)) { + atomic_inc(&backbone_gw->bat_priv->bla_num_requests); + atomic_set(&backbone_gw->request_sent, 1); + } +} + +/* + * @bat_priv: the bat priv with all the soft interface information + * @backbone_gw: our backbone gateway which should be announced + * + * This function sends an announcement. It is called from multiple + * places. + */ +static void bla_send_announce(struct bat_priv *bat_priv, + struct backbone_gw *backbone_gw) +{ + uint8_t mac[6]; + uint16_t crc; + + memcpy(mac, announce_mac, 4); + crc = htons(backbone_gw->crc); + memcpy(&mac[4], (uint8_t *) &crc, 2); + + bla_send_claim(bat_priv, mac, backbone_gw->vid, CLAIM_TYPE_ANNOUNCE); + +} + +/* + * @bat_priv: the bat priv with all the soft interface information + * @mac: the mac address of the claim + * @vid: the VLAN ID of the frame + * @backbone_gw: the backbone gateway which claims it + * + * Adds a claim in the claim hash. + */ + +static void bla_add_claim(struct bat_priv *bat_priv, const uint8_t *mac, + const short vid, struct backbone_gw *backbone_gw) +{ + struct claim *claim; + struct claim search_claim; + + memcpy(search_claim.addr, mac, ETH_ALEN); + search_claim.vid = vid; + claim = claim_hash_find(bat_priv, &search_claim); + + /* create a new claim entry if it does not exist yet. */ + if (!claim) { + claim = kzalloc(sizeof(*claim), GFP_ATOMIC); + if (!claim) + return; + + memcpy(claim->addr, mac, ETH_ALEN); + claim->vid = vid; + claim->lasttime = jiffies; + claim->backbone_gw = backbone_gw; + + atomic_set(&claim->refcount, 2); + bat_dbg(DBG_BLA, bat_priv, + "bla_add_claim(): adding new entry %pM, vid %d to hash ...\n", + mac, vid); + hash_add(bat_priv->claim_hash, compare_claim, choose_claim, + claim, &claim->hash_entry); + } else { + claim->lasttime = jiffies; + if (claim->backbone_gw == backbone_gw) + /* no need to register a new backbone */ + goto claim_free_ref; + + bat_dbg(DBG_BLA, bat_priv, + "bla_add_claim(): changing ownership for %pM, vid %d\n", + mac, vid); + + claim->backbone_gw->crc ^= + crc16(0, claim->addr, ETH_ALEN); + backbone_gw_free_ref(claim->backbone_gw); + + } + /* set (new) backbone gw */ + atomic_inc(&backbone_gw->refcount); + claim->backbone_gw = backbone_gw; + + backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN); + backbone_gw->lasttime = jiffies; + +claim_free_ref: + claim_free_ref(claim); +} + +/* + * Delete a claim from the claim hash which has the + * given mac address and vid. + */ +static void bla_del_claim(struct bat_priv *bat_priv, const uint8_t *mac, + const short vid) +{ + struct claim search_claim, *claim; + + memcpy(search_claim.addr, mac, ETH_ALEN); + search_claim.vid = vid; + claim = claim_hash_find(bat_priv, &search_claim); + if (!claim) + return; + + bat_dbg(DBG_BLA, bat_priv, "bla_del_claim(): %pM, vid %d\n", mac, vid); + + hash_remove(bat_priv->claim_hash, compare_claim, choose_claim, + claim); + claim_free_ref(claim); /* reference from the hash is gone */ + + claim->backbone_gw->crc ^= crc16(0, claim->addr, ETH_ALEN); + + /* don't need the reference from hash_find() anymore */ + claim_free_ref(claim); +} + +/* check for ANNOUNCE frame, return 1 if handled */ +static int handle_announce(struct bat_priv *bat_priv, + uint8_t *an_addr, uint8_t *backbone_addr, short vid) +{ + struct backbone_gw *backbone_gw; + uint16_t crc; + + if (memcmp(an_addr, announce_mac, 4) != 0) + return 0; + + backbone_gw = bla_get_backbone_gw(bat_priv, backbone_addr, vid); + + if (unlikely(!backbone_gw)) + return 1; + + + /* handle as ANNOUNCE frame */ + backbone_gw->lasttime = jiffies; + crc = ntohs(*((uint16_t *) (&an_addr[4]))); + + bat_dbg(DBG_BLA, bat_priv, + "handle_announce(): ANNOUNCE vid %d (sent " + "by %pM)... CRC = %04x (nw order)\n", + vid, backbone_gw->orig, crc); + + if (backbone_gw->crc != crc) { + bat_dbg(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); + + bla_send_request(backbone_gw); + } else { + /* if we have sent a request and the crc was OK, + * we can allow traffic again. */ + if (atomic_read(&backbone_gw->request_sent)) { + atomic_dec(&backbone_gw->bat_priv->bla_num_requests); + atomic_set(&backbone_gw->request_sent, 0); + } + } + + backbone_gw_free_ref(backbone_gw); + return 1; +} + +/* check for REQUEST frame, return 1 if handled */ +static int handle_request(struct bat_priv *bat_priv, + uint8_t *backbone_addr, struct ethhdr *ethhdr, short vid) +{ + /* check for REQUEST frame */ + if (!compare_eth(backbone_addr, ethhdr->h_dest)) + return 0; + + /* sanity check, this should not happen on a normal switch, + * we ignore it in this case. */ + if (!compare_eth(ethhdr->h_dest, bat_priv->own_orig)) + return 1; + + bat_dbg(DBG_BLA, bat_priv, + "handle_request(): REQUEST vid %d (sent " + "by %pM)...\n", + vid, ethhdr->h_source); + + bla_handle_request(bat_priv, vid); + return 1; +} + +/* check for UNCLAIM frame, return 1 if handled */ +static int handle_unclaim(struct bat_priv *bat_priv, + uint8_t *backbone_addr, uint8_t *claim_addr, short vid) +{ + struct backbone_gw *backbone_gw; + + /* unclaim in any case if it is our own */ + if (compare_eth(backbone_addr, bat_priv->own_orig)) + bla_send_claim(bat_priv, claim_addr, vid, CLAIM_TYPE_DEL); + + backbone_gw = backbone_hash_find(bat_priv, backbone_addr, vid); + + if (!backbone_gw) + return 0; + + /* this must be an UNCLAIM frame */ + bat_dbg(DBG_BLA, bat_priv, "handle_unclaim():" + "UNCLAIM %pM on vid %d (sent by %pM)...\n", + claim_addr, vid, backbone_gw->orig); + + bla_del_claim(bat_priv, claim_addr, vid); + backbone_gw_free_ref(backbone_gw); + return 1; +} + +/* check for CLAIM frame, return 1 if handled */ +static int handle_claim(struct bat_priv *bat_priv, + uint8_t *backbone_addr, uint8_t *claim_addr, short vid) +{ + struct backbone_gw *backbone_gw; + + /* register the gateway if not yet available, and add the claim. */ + + backbone_gw = bla_get_backbone_gw(bat_priv, backbone_addr, vid); + + if (unlikely(!backbone_gw)) + return 0; + + /* this must be a CLAIM frame */ + bla_add_claim(bat_priv, claim_addr, vid, backbone_gw); + if (compare_eth(backbone_addr, bat_priv->own_orig)) + bla_send_claim(bat_priv, claim_addr, vid, CLAIM_TYPE_ADD); + + /* TODO: we could cal something like tt_local_del() here. */ + + backbone_gw_free_ref(backbone_gw); + return 1; +} + +/* + * @bat_priv: the bat priv with all the soft interface information + * @skb: the frame to be checked + * + * Check if this is a claim frame, and process it accordingly. + * + * 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 bla_process_claim(struct bat_priv *bat_priv, 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; + uint16_t proto; + int headlen; + short vid = -1; + + ethhdr = (struct ethhdr *)skb_mac_header(skb); + + if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) { + vhdr = (struct vlan_ethhdr *) ethhdr; + vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK; + proto = ntohs(vhdr->h_vlan_encapsulated_proto); + headlen = sizeof(*vhdr); + } else { + proto = ntohs(ethhdr->h_proto); + headlen = sizeof(*ethhdr); + } + + if (proto != ETH_P_ARP) + return 0; /* not a claim frame */ + + /* this must be a ARP frame. check if it is a claim. */ + + if (unlikely(!pskb_may_pull(skb, headlen + arp_hdr_len(skb->dev)))) + return 0; + + arphdr = (struct arphdr *) ((uint8_t *)ethhdr + headlen); + + /* Check whether the ARP frame carries a valid + * IP information */ + + if (arphdr->ar_hrd != htons(ARPHRD_ETHER)) + return 0; + if (arphdr->ar_pro != htons(ETH_P_IP)) + return 0; + if (arphdr->ar_hln != ETH_ALEN) + return 0; + if (arphdr->ar_pln != 4) + return 0; + + hw_src = (uint8_t *)arphdr + sizeof(struct arphdr); + hw_dst = hw_src + ETH_ALEN + 4; + bla_dst = (struct bla_claim_dst *) hw_dst; + + /* check if it is a claim frame. */ + if (memcmp(hw_dst, claim_dest, 3) != 0) + return 0; + + /* become a backbone gw ourselves on this vlan if not happened yet */ + bla_update_own_backbone_gw(bat_priv, vid); + + /* check for the different types of claim frames ... */ + switch (bla_dst->type) { + case CLAIM_TYPE_ADD: + if (handle_claim(bat_priv, hw_src, ethhdr->h_source, vid)) + return 1; + break; + case CLAIM_TYPE_DEL: + if (handle_unclaim(bat_priv, ethhdr->h_source, hw_src, vid)) + return 1; + break; + + case CLAIM_TYPE_ANNOUNCE: + if (handle_announce(bat_priv, hw_src, ethhdr->h_source, vid)) + return 1; + break; + case CLAIM_TYPE_REQUEST: + if (handle_request(bat_priv, hw_src, ethhdr, vid)) + return 1; + break; + } + + bat_dbg(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; +} + +/* + * Update the backbone gateways when the own orig address changes. + */ +void bla_update_orig_address(struct bat_priv *bat_priv, uint8_t *newaddr) +{ + struct backbone_gw *backbone_gw; + struct hlist_node *node; + struct hlist_head *head; + struct hashtable_t *hash; + int i; + + hash = bat_priv->backbone_hash; + if (!hash) + return; + + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) { + /* own orig still holds the old value. */ + if (!compare_eth(backbone_gw->orig, + bat_priv->own_orig)) + continue; + + memcpy(backbone_gw->orig, newaddr, ETH_ALEN); + /* send an announce frame so others will ask for our + * claims and update their tables. */ + bla_send_announce(bat_priv, backbone_gw); + } + rcu_read_unlock(); + } +} + +/* + * Check when we last heard from other nodes, and remove them in case of + * a time out. + */ +static void bla_purge_backbone_gw(struct bat_priv *bat_priv) +{ + struct backbone_gw *backbone_gw; + struct hlist_node *node, *node_tmp; + struct hlist_head *head; + struct hashtable_t *hash; + spinlock_t *list_lock; /* protects write access to the hash lists */ + int i; + + hash = bat_priv->backbone_hash; + if (!hash) + return; + + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + list_lock = &hash->list_locks[i]; + + spin_lock_bh(list_lock); + hlist_for_each_entry_safe(backbone_gw, node, node_tmp, + head, hash_entry) { + if (!time_after(jiffies, backbone_gw->lasttime + + msecs_to_jiffies(BLA_BACKBONE_TIMEOUT))) + continue; + + bat_dbg(DBG_BLA, backbone_gw->bat_priv, + "bla_purge_backbone_gw(): backbone gw %pM" + " timed out\n", backbone_gw->orig); + + /* don't wait for the pending request anymore */ + if (atomic_read(&backbone_gw->request_sent)) + atomic_dec(&bat_priv->bla_num_requests); + + bla_del_backbone_claims(backbone_gw); + + hlist_del_rcu(node); + backbone_gw_free_ref(backbone_gw); + } + spin_unlock_bh(list_lock); + } +} + +/* + * Check when we heard last time from our own claims, and remove them in case of + * a time out + */ +static void bla_purge_claims(struct bat_priv *bat_priv) +{ + struct claim *claim; + struct hlist_node *node; + struct hlist_head *head; + struct hashtable_t *hash; + int i; + + hash = bat_priv->claim_hash; + if (!hash) + return; + + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(claim, node, head, hash_entry) { + if (!compare_eth(claim->backbone_gw->orig, + bat_priv->own_orig)) + continue; + if (!time_after(jiffies, claim->lasttime + + msecs_to_jiffies(BLA_CLAIM_TIMEOUT))) + continue; + + bat_dbg(DBG_BLA, bat_priv, + "bla_purge_claims(): %pM, vid %d, time out\n", + claim->addr, claim->vid); + + handle_unclaim(bat_priv, bat_priv->own_orig, + claim->addr, claim->vid); + } + rcu_read_unlock(); + } +} + +/* (re)start the timer */ +static void bla_start_timer(struct bat_priv *bat_priv) +{ + INIT_DELAYED_WORK(&bat_priv->bla_work, bla_periodic_work); + queue_delayed_work(bat_event_workqueue, &bat_priv->bla_work, + msecs_to_jiffies(BLA_PERIOD_LENGTH)); +} + +/* + * periodic work to do: + * * purge structures when they are too old + * * send announcements + */ + +static void 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 hlist_node *node; + struct hlist_head *head; + struct backbone_gw *backbone_gw; + struct hashtable_t *hash; + int i; + + bla_purge_claims(bat_priv); + bla_purge_backbone_gw(bat_priv); + + if (!atomic_read(&bat_priv->bridge_loop_avoidance)) + goto timer; + + hash = bat_priv->backbone_hash; + if (!hash) + return; + + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) { + if (!compare_eth(backbone_gw->orig, bat_priv->own_orig)) + continue; + + backbone_gw->lasttime = jiffies; + + bla_send_announce(bat_priv, backbone_gw); + } + rcu_read_unlock(); + } +timer: + bla_start_timer(bat_priv); +} + +/* initialize all bla structures */ +int bla_init(struct bat_priv *bat_priv) +{ + bat_dbg(DBG_BLA, bat_priv, "bla hash registering\n"); + + if (bat_priv->claim_hash) + return 1; + + bat_priv->claim_hash = hash_new(128); + bat_priv->backbone_hash = hash_new(32); + + if (!bat_priv->claim_hash || !bat_priv->backbone_hash) + return -1; + + bat_dbg(DBG_BLA, bat_priv, "bla hashes initialized\n"); + + bla_start_timer(bat_priv); + return 1; +} + +/** + * @skb: the frame to be checked + * @orig_node: the orig_node of the frame + * @hdr_size: maximum length of the frame + * + * bla_is_backbone_gw inspects the skb for the VLAN ID and returns 1 + * if the orig_node is also a gateway on the soft interface, otherwise it + * returns 0. + * + **/ + +int bla_is_backbone_gw(struct sk_buff *skb, + struct orig_node *orig_node, int hdr_size) +{ + struct ethhdr *ethhdr; + struct vlan_ethhdr *vhdr; + struct backbone_gw *backbone_gw; + short vid = -1; + + if (!atomic_read(&orig_node->bat_priv->bridge_loop_avoidance)) + return 0; + + /* first, find out the vid. */ + if (!pskb_may_pull(skb, hdr_size + sizeof(struct ethhdr))) + return 0; + + ethhdr = (struct ethhdr *) (((uint8_t *)skb->data) + hdr_size); + + if (ntohs(ethhdr->h_proto) == ETH_P_8021Q) { + if (!pskb_may_pull(skb, hdr_size + sizeof(struct vlan_ethhdr))) + return 0; + + vhdr = (struct vlan_ethhdr *) ethhdr; + vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK; + } + + /* see if this originator is a backbone gw for this VLAN */ + + backbone_gw = backbone_hash_find(orig_node->bat_priv, + orig_node->orig, vid); + if (!backbone_gw) + return 0; + + bat_dbg(DBG_BLA, orig_node->bat_priv, + "bla_is_backbone_gw(): originator %pM has a claim " + "for vid %d on the LAN ...\n", orig_node->orig, vid); + backbone_gw_free_ref(backbone_gw); + return 1; +} + +/* free all bla structures (for softinterface free or module unload) */ +void bla_free(struct bat_priv *bat_priv) +{ + struct claim *claim; + struct backbone_gw *backbone_gw; + struct hlist_node *node, *node_tmp; + struct hlist_head *head; + struct hashtable_t *hash; + spinlock_t *list_lock; /* protects write access to the hash lists */ + int i; + + cancel_delayed_work_sync(&bat_priv->bla_work); + atomic_set(&bat_priv->bla_num_requests, 0); + + hash = bat_priv->claim_hash; + if (!hash) + goto free_backbone_hash; + + + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + list_lock = &hash->list_locks[i]; + + spin_lock_bh(list_lock); + hlist_for_each_entry_safe(claim, node, node_tmp, + head, hash_entry) { + hlist_del_rcu(node); + claim_free_ref(claim); + } + spin_unlock_bh(list_lock); + } + + hash_destroy(hash); + bat_priv->claim_hash = NULL; +free_backbone_hash: + hash = bat_priv->backbone_hash; + if (!hash) + return; + + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + list_lock = &hash->list_locks[i]; + + spin_lock_bh(list_lock); + hlist_for_each_entry_safe(backbone_gw, node, node_tmp, + head, hash_entry) { + hlist_del_rcu(node); + backbone_gw_free_ref(backbone_gw); + } + spin_unlock_bh(list_lock); + } + + hash_destroy(hash); + bat_priv->backbone_hash = NULL; + +} + +/** + * @bat_priv: the bat priv with all the soft interface information + * @skb: the frame to be checked + * @vid: the VLAN ID of the frame + * + * bla_rx avoidance checks if: + * * we have to race for a claim + * * if the frame is allowed on the LAN + * + * in these cases, the skb is further handled by this function and + * returns 1, otherwise it returns 0 and the caller shall further + * process the skb. + * + **/ + +int bla_rx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid) +{ + struct ethhdr *ethhdr; + struct claim search_claim, *claim = NULL; + + ethhdr = (struct ethhdr *)skb_mac_header(skb); + + if (!atomic_read(&bat_priv->bridge_loop_avoidance)) + goto allow; + + + if (unlikely(atomic_read(&bat_priv->bla_num_requests))) + /* don't allow broadcasts while requests are in flight */ + if (is_multicast_ether_addr(ethhdr->h_dest)) + goto handled; + + memcpy(search_claim.addr, ethhdr->h_source, ETH_ALEN); + search_claim.vid = vid; + claim = claim_hash_find(bat_priv, &search_claim); + + if (!claim) { + /* possible optimization: race for a claim */ + /* No claim exists yet, claim it for us! */ + handle_claim(bat_priv, bat_priv->own_orig, + ethhdr->h_source, vid); + goto allow; + } + + /* if it is our own claim ... */ + if (compare_eth(claim->backbone_gw->orig, bat_priv->own_orig)) { + /* ... allow it in any case */ + claim->lasttime = jiffies; + goto allow; + } + + /* if it is a broadcast ... */ + if (is_multicast_ether_addr(ethhdr->h_dest)) { + /* ... drop it. the responsible gateway is in charge. */ + goto handled; + } else { + /* seems the client considers us as its best gateway. + * send a claim and update the claim table + * immediately. */ + handle_claim(bat_priv, bat_priv->own_orig, + ethhdr->h_source, vid); + goto allow; + } +allow: + bla_update_own_backbone_gw(bat_priv, vid); + if (claim) + claim_free_ref(claim); + return 0; +handled: + kfree_skb(skb); + if (claim) + claim_free_ref(claim); + return 1; +} + +/** + * @bat_priv: the bat priv with all the soft interface information + * @skb: the frame to be checked + * @vid: the VLAN ID of the frame + * + * bla_tx checks if: + * * a claim was received which has to be processed + * * the frame is allowed on the mesh + * + * in these cases, the skb is further handled by this function and + * returns 1, otherwise it returns 0 and the caller shall further + * process the skb. + * + **/ + +int bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid) +{ + struct ethhdr *ethhdr; + struct claim search_claim, *claim = NULL; + + if (!atomic_read(&bat_priv->bridge_loop_avoidance)) + goto allow; + + /* in VLAN case, the mac header might not be set. */ + skb_reset_mac_header(skb); + + if (bla_process_claim(bat_priv, skb)) + goto handled; + + ethhdr = (struct ethhdr *)skb_mac_header(skb); + + if (unlikely(atomic_read(&bat_priv->bla_num_requests))) + /* don't allow broadcasts while requests are in flight */ + if (is_multicast_ether_addr(ethhdr->h_dest)) + goto handled; + + memcpy(search_claim.addr, ethhdr->h_source, ETH_ALEN); + search_claim.vid = vid; + + bat_dbg(DBG_BLA, bat_priv, + "bla_tx(): checked for claims, now starting ..." + "%pM -> %pM [%04x], vid %d\n", + ethhdr->h_source, ethhdr->h_dest, + ntohs(ethhdr->h_proto), search_claim.vid); + claim = claim_hash_find(bat_priv, &search_claim); + + /* if no claim exists, allow it. */ + if (!claim) + goto allow; + + /* check if we are responsible. */ + if (compare_eth(claim->backbone_gw->orig, bat_priv->own_orig)) { + /* if yes, the client has roamed and we have + * to unclaim it. */ + handle_unclaim(bat_priv, bat_priv->own_orig, + ethhdr->h_source, vid); + goto allow; + } + + /* check if it is a multicast/broadcast frame */ + if (is_multicast_ether_addr(ethhdr->h_dest)) { + /* drop it. the responsible gateway has forwarded it into + * the backbone network. */ + goto handled; + } else { + /* we must allow it. at least if we are + * responsible for the DESTINATION. */ + goto allow; + } +allow: + bla_update_own_backbone_gw(bat_priv, vid); + if (claim) + claim_free_ref(claim); + return 0; +handled: + if (claim) + claim_free_ref(claim); + return 1; +} diff --git a/bridge_loop_avoidance.h b/bridge_loop_avoidance.h new file mode 100644 index 0000000..8df5036 --- /dev/null +++ b/bridge_loop_avoidance.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2011 B.A.T.M.A.N. contributors: + * + * Simon Wunderlich + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of version 2 of the GNU General Public + * License as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + * + */ + +int bla_rx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid); +int bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid); +int bla_is_backbone_gw(struct sk_buff *skb, + struct orig_node *orig_node, int hdr_size); +void bla_update_orig_address(struct bat_priv *bat_priv, uint8_t *newaddr); +int bla_init(struct bat_priv *bat_priv); +void bla_free(struct bat_priv *bat_priv); + +#define BLA_CRC_INIT 0 diff --git a/compat.c b/compat.c index 4c12468..5b389b2 100644 --- a/compat.c +++ b/compat.c @@ -28,4 +28,12 @@ void free_rcu_tt_local_entry(struct rcu_head *rcu) kfree(tt_local_entry); }
+void free_rcu_backbone_gw(struct rcu_head *rcu) +{ + struct backbone_gw *backbone_gw; + + backbone_gw = container_of(rcu, struct backbone_gw, rcu); + kfree(backbone_gw); +} + #endif /* < KERNEL_VERSION(3, 0, 0) */ diff --git a/compat.h b/compat.h index 531ba85..41655a6 100644 --- a/compat.h +++ b/compat.h @@ -65,10 +65,12 @@ #if LINUX_VERSION_CODE < KERNEL_VERSION(3, 0, 0)
#define kfree_rcu(ptr, rcu_head) call_rcu(&ptr->rcu_head, free_rcu_##ptr) +#define vlan_insert_tag(skb, vid) __vlan_put_tag(skb, vid)
void free_rcu_gw_node(struct rcu_head *rcu); void free_rcu_neigh_node(struct rcu_head *rcu); void free_rcu_tt_local_entry(struct rcu_head *rcu); +void free_rcu_backbone_gw(struct rcu_head *rcu);
#endif /* < KERNEL_VERSION(3, 0, 0) */
diff --git a/hard-interface.c b/hard-interface.c index 7704df4..f64adff 100644 --- a/hard-interface.c +++ b/hard-interface.c @@ -29,6 +29,7 @@ #include "originator.h" #include "hash.h" #include "bat_ogm.h" +#include "bridge_loop_avoidance.h"
#include <linux/if_arp.h>
@@ -123,6 +124,11 @@ static void primary_if_update_addr(struct bat_priv *bat_priv) memcpy(vis_packet->sender_orig, primary_if->net_dev->dev_addr, ETH_ALEN);
+ /* before updating bat_priv->own_orig, + * change own addresses in backbone gw */ + bla_update_orig_address(bat_priv, primary_if->net_dev->dev_addr); + memcpy(bat_priv->own_orig, primary_if->net_dev->dev_addr, ETH_ALEN); + out: if (primary_if) hardif_free_ref(primary_if); @@ -634,7 +640,7 @@ static int batman_skb_recv(struct sk_buff *skb, struct net_device *dev, case BAT_TT_QUERY: ret = recv_tt_query(skb, hard_iface); break; - /* Roaming advertisement */ + /* bridge roop avoidance query */ case BAT_ROAM_ADV: ret = recv_roam_adv(skb, hard_iface); break; diff --git a/main.c b/main.c index 36661b4..85cb79b 100644 --- a/main.c +++ b/main.c @@ -30,6 +30,7 @@ #include "translation-table.h" #include "hard-interface.h" #include "gateway_client.h" +#include "bridge_loop_avoidance.h" #include "vis.h" #include "hash.h"
@@ -109,6 +110,9 @@ int mesh_init(struct net_device *soft_iface) if (vis_init(bat_priv) < 1) goto err;
+ if (bla_init(bat_priv) < 1) + goto err; + atomic_set(&bat_priv->gw_reselect, 0); atomic_set(&bat_priv->mesh_state, MESH_ACTIVE); goto end; @@ -136,6 +140,8 @@ void mesh_free(struct net_device *soft_iface)
tt_free(bat_priv);
+ bla_free(bat_priv); + atomic_set(&bat_priv->mesh_state, MESH_INACTIVE); }
diff --git a/main.h b/main.h index b395c7b..1bd41f1 100644 --- a/main.h +++ b/main.h @@ -79,6 +79,9 @@ #define MAX_AGGREGATION_BYTES 512 #define MAX_AGGREGATION_MS 100
+#define BLA_PERIOD_LENGTH 10000 /* 10 seconds */ +#define BLA_BACKBONE_TIMEOUT (BLA_PERIOD_LENGTH * 3) +#define BLA_CLAIM_TIMEOUT (BLA_PERIOD_LENGTH * 10) /* don't reset again within 30 seconds */ #define RESET_PROTECTION_MS 30000 #define EXPECTED_SEQNO_RANGE 65536 @@ -118,7 +121,8 @@ enum dbg_level { DBG_BATMAN = 1 << 0, DBG_ROUTES = 1 << 1, /* route added / changed / deleted */ DBG_TT = 1 << 2, /* translation table operations */ - DBG_ALL = 7 + DBG_BLA = 1 << 3, /* bridge loop avoidance */ + DBG_ALL = 15 };
diff --git a/originator.c b/originator.c index a9c8b66..52e778a 100644 --- a/originator.c +++ b/originator.c @@ -28,6 +28,7 @@ #include "hard-interface.h" #include "unicast.h" #include "soft-interface.h" +#include "bridge_loop_avoidance.h"
static void purge_orig(struct work_struct *work);
diff --git a/packet.h b/packet.h index 4d9e54c..48c7b74 100644 --- a/packet.h +++ b/packet.h @@ -90,6 +90,22 @@ enum tt_client_flags { 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 +}; + +/* the destination hardware field in the ARP frame is used to + * transport the claim type and the group id */ +struct bla_claim_dst { + uint8_t magic[3]; /* FF:43:05 */ + uint8_t type; /* bla_claimframe */ + uint16_t group; /* group id */ +} __packed; + struct batman_ogm_packet { uint8_t packet_type; uint8_t version; /* batman version field */ diff --git a/routing.c b/routing.c index ef24a72..8050fb2 100644 --- a/routing.c +++ b/routing.c @@ -30,6 +30,7 @@ #include "vis.h" #include "unicast.h" #include "bat_ogm.h" +#include "bridge_loop_avoidance.h"
void slide_own_bcast_window(struct hard_iface *hard_iface) { @@ -1074,6 +1075,11 @@ int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if) /* rebroadcast packet */ add_bcast_packet_to_list(bat_priv, skb, 1);
+ /* don't hand the broadcast up if it is from an originator + * from the same backbone. */ + if (bla_is_backbone_gw(skb, orig_node, hdr_size)) + goto out; + /* broadcast for me */ interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size); ret = NET_RX_SUCCESS; diff --git a/soft-interface.c b/soft-interface.c index 4806deb..46dd328 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -36,6 +36,7 @@ #include <linux/etherdevice.h> #include <linux/if_vlan.h> #include "unicast.h" +#include "bridge_loop_avoidance.h"
static int bat_get_settings(struct net_device *dev, struct ethtool_cmd *cmd); @@ -151,6 +152,9 @@ static int interface_tx(struct sk_buff *skb, struct net_device *soft_iface) goto dropped; }
+ if (bla_tx(bat_priv, skb, vid)) + goto dropped; + /* Register the client MAC in the transtable */ tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
@@ -286,6 +290,11 @@ void interface_rx(struct net_device *soft_iface, if (is_ap_isolated(bat_priv, ethhdr->h_source, ethhdr->h_dest)) goto dropped;
+ /* Let the bridge loop avoidance check the packet. If will + * not handle it, we can safely push it up. */ + if (bla_rx(bat_priv, skb, vid)) + goto out; + netif_rx(skb); goto out;
@@ -355,6 +364,7 @@ struct net_device *softif_create(const char *name)
atomic_set(&bat_priv->aggregated_ogms, 1); atomic_set(&bat_priv->bonding, 0); + atomic_set(&bat_priv->bridge_loop_avoidance, 1); 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); @@ -372,6 +382,7 @@ struct net_device *softif_create(const char *name) atomic_set(&bat_priv->ttvn, 0); atomic_set(&bat_priv->tt_local_changes, 0); atomic_set(&bat_priv->tt_ogm_append_cnt, 0); + atomic_set(&bat_priv->bla_num_requests, 0);
bat_priv->tt_buff = NULL; bat_priv->tt_buff_len = 0; diff --git a/types.h b/types.h index db6ae2b..3cffe8d 100644 --- a/types.h +++ b/types.h @@ -147,6 +147,7 @@ struct bat_priv { atomic_t bonding; /* boolean */ atomic_t fragmentation; /* boolean */ atomic_t ap_isolation; /* boolean */ + atomic_t bridge_loop_avoidance; /* boolean */ atomic_t vis_mode; /* VIS_TYPE_* */ atomic_t gw_mode; /* GW_MODE_* */ atomic_t gw_sel_class; /* uint */ @@ -160,6 +161,7 @@ struct bat_priv { atomic_t ttvn; /* translation table version number */ atomic_t tt_ogm_append_cnt; atomic_t tt_local_changes; /* changes registered in a OGM interval */ + atomic_t bla_num_requests; /* number of bla requests in flight */ /* The tt_poss_change flag is used to detect an ongoing roaming phase. * If true, then I received a Roaming_adv and I have to inspect every * packet directed to me to check whether I am still the true @@ -178,6 +180,8 @@ struct bat_priv { struct hashtable_t *orig_hash; struct hashtable_t *tt_local_hash; struct hashtable_t *tt_global_hash; + struct hashtable_t *claim_hash; + struct hashtable_t *backbone_hash; struct list_head tt_req_list; /* list of pending tt_requests */ struct list_head tt_roam_list; struct hashtable_t *vis_hash; @@ -198,10 +202,12 @@ struct bat_priv { struct delayed_work tt_work; struct delayed_work orig_work; struct delayed_work vis_work; + struct delayed_work bla_work; struct 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; + uint8_t own_orig[6]; /* cache primary hardifs address */ };
struct socket_client { @@ -239,6 +245,28 @@ struct tt_global_entry { struct rcu_head rcu; };
+struct backbone_gw { + uint8_t orig[ETH_ALEN]; + short vid; /* used VLAN ID */ + struct hlist_node hash_entry; + struct bat_priv *bat_priv; + unsigned long lasttime; /* last time we heard of this backbone gw */ + atomic_t request_sent; + atomic_t refcount; + struct rcu_head rcu; + uint16_t crc; /* crc checksum over all claims */ +} __packed; + +struct claim { + uint8_t addr[ETH_ALEN]; + short vid; + struct backbone_gw *backbone_gw; + unsigned long lasttime; /* last time we heard of claim (locals only) */ + struct rcu_head rcu; + atomic_t refcount; + struct hlist_node hash_entry; +} __packed; + struct tt_change_node { struct list_head list; struct tt_change change;
Hi,
- always become a backbone gw for a VLAN when there is traffic, even if there are no claims, to let at least let other backbone gw nodes that we are able to receive on that VLAN and avoid broadcast loops.
could you give some more details on this change ? Why is it not necessary without VLANs ?
Regards, Marek
Hi,
On Mon, Oct 31, 2011 at 12:20:24AM +0100, Marek Lindner wrote:
Hi,
- always become a backbone gw for a VLAN when there is traffic, even if there are no claims, to let at least let other backbone gw nodes that we are able to receive on that VLAN and avoid broadcast loops.
could you give some more details on this change ? Why is it not necessary without VLANs ?
Actually it's also useful for cases without VLANs, e.g. if there has not been any traffic yet. However if there is traffic it soon happens in both directions and therefore claims are added and situation resolves automatically.
I had the situation that on some VLANs there were no traffic at all for some time and when it suddenly started, the bla system did some weird things.
Cheers Simon
On Sunday, October 30, 2011 23:51:03 Simon Wunderlich wrote:
+static const uint8_t announce_mac[6] = {0x43, 0x05, 0x43, 0x05, 0x00, 0x00};
All we ever use are 4 bytes - we could make this shorter. Otherwise please use ETH_ALEN. Please use ETH_ALEN throughout the code instead of 6.
bat_dbg(DBG_BLA, bat_priv,"handle_announce(): ANNOUNCE vid %d (sent ""by %pM)... CRC = %04x (nw order)\n",vid, backbone_gw->orig, crc);
It is not network byte order anymore ..
+ /* TODO: we could cal something like tt_local_del() here. */
Why should we ?
@@ -634,7 +640,7 @@ static int batman_skb_recv(struct sk_buff *skb, struct net_device *dev, case BAT_TT_QUERY: ret = recv_tt_query(skb, hard_iface); break;
/* Roaming advertisement */
/* bridge roop avoidance query */ case BAT_ROAM_ADV: ret = recv_roam_adv(skb, hard_iface); break;
Small typo here but why are you even changing the comment ?
atomic_t gw_reselect; struct hard_iface __rcu *primary_if; /* rcu protected pointer */ struct vis_info *my_vis_info;
uint8_t own_orig[6]; /* cache primary hardifs address */};
I'd call this "primary_addr" instead of "own_orig" to be consistent with "primary_if". Furthermore ETH_ALEN should be used for the length.
+struct backbone_gw {
uint8_t orig[ETH_ALEN];short vid; /* used VLAN ID */struct hlist_node hash_entry;struct bat_priv *bat_priv;unsigned long lasttime; /* last time we heard of this backbone gw */atomic_t request_sent;atomic_t refcount;struct rcu_head rcu;uint16_t crc; /* crc checksum over all claims */+} __packed;
+struct claim {
uint8_t addr[ETH_ALEN];short vid;struct backbone_gw *backbone_gw;unsigned long lasttime; /* last time we heard of claim (locals only)*/
struct rcu_head rcu;atomic_t refcount;struct hlist_node hash_entry;+} __packed;
Why are these structs packed ?
Regards, Marek
Hi,
On Tue, Nov 01, 2011 at 11:52:45AM +0100, Marek Lindner wrote:
On Sunday, October 30, 2011 23:51:03 Simon Wunderlich wrote:
+static const uint8_t announce_mac[6] = {0x43, 0x05, 0x43, 0x05, 0x00, 0x00};
All we ever use are 4 bytes - we could make this shorter. Otherwise please use ETH_ALEN. Please use ETH_ALEN throughout the code instead of 6.
OK, that's right, i'll change it to 4 and use ETH_ALEN at the other place where i missed it.
bat_dbg(DBG_BLA, bat_priv,"handle_announce(): ANNOUNCE vid %d (sent ""by %pM)... CRC = %04x (nw order)\n",vid, backbone_gw->orig, crc);It is not network byte order anymore ..
OK
/* TODO: we could cal something like tt_local_del() here. */Why should we ?
Because when someone claims the adress, the the client has roamed to the mesh.
Usually this is handled by the tt roaming code, this will only fail in a limited horizon scenario where a node does not know the other node the client roamed to. In this case, the tt will time out after a long while.
This is just an idea/optimization to add the tt_local_del(). :)
@@ -634,7 +640,7 @@ static int batman_skb_recv(struct sk_buff *skb, struct net_device *dev, case BAT_TT_QUERY: ret = recv_tt_query(skb, hard_iface); break;
/* Roaming advertisement */
/* bridge roop avoidance query */ case BAT_ROAM_ADV: ret = recv_roam_adv(skb, hard_iface); break;Small typo here but why are you even changing the comment ?
Oh thanks, this is wrong. This comes from an earlier version of the BLA table changes where I used a special packet type.
The comment should not be changed.
atomic_t gw_reselect; struct hard_iface __rcu *primary_if; /* rcu protected pointer */ struct vis_info *my_vis_info;
uint8_t own_orig[6]; /* cache primary hardifs address */};
I'd call this "primary_addr" instead of "own_orig" to be consistent with "primary_if". Furthermore ETH_ALEN should be used for the length.
OK.
+struct backbone_gw {
uint8_t orig[ETH_ALEN];short vid; /* used VLAN ID */struct hlist_node hash_entry;struct bat_priv *bat_priv;unsigned long lasttime; /* last time we heard of this backbone gw */atomic_t request_sent;atomic_t refcount;struct rcu_head rcu;uint16_t crc; /* crc checksum over all claims */+} __packed;
+struct claim {
uint8_t addr[ETH_ALEN];short vid;struct backbone_gw *backbone_gw;unsigned long lasttime; /* last time we heard of claim (locals only)*/
struct rcu_head rcu;atomic_t refcount;struct hlist_node hash_entry;+} __packed;
Why are these structs packed ?
For similar reasons as the tt_global/local_entry issue: The hash functions both access orig and vid from these structures.
However, as there are not that many sharing function I'll split it into choose_claim()/choose_backbone_gw() and remove the __packed attribute.
In this case, it should be a little bit shorter and cleaner than using a common structure (no container_of() stuff).
Thanks for the comments, you'll find the changed stuff as patches in my blaII_dirty repo.
Cheers, Simon
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- bat_sysfs.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-)
diff --git a/bat_sysfs.c b/bat_sysfs.c index ec2e437..cb7a524 100644 --- a/bat_sysfs.c +++ b/bat_sysfs.c @@ -379,6 +379,7 @@ static ssize_t store_gw_bwidth(struct kobject *kobj, struct attribute *attr,
BAT_ATTR_BOOL(aggregated_ogms, S_IRUGO | S_IWUSR, NULL); BAT_ATTR_BOOL(bonding, S_IRUGO | S_IWUSR, NULL); +BAT_ATTR_BOOL(bridge_loop_avoidance, S_IRUGO | S_IWUSR, NULL); BAT_ATTR_BOOL(fragmentation, S_IRUGO | S_IWUSR, update_min_mtu); BAT_ATTR_BOOL(ap_isolation, S_IRUGO | S_IWUSR, NULL); static BAT_ATTR(vis_mode, S_IRUGO | S_IWUSR, show_vis_mode, store_vis_mode); @@ -396,6 +397,7 @@ BAT_ATTR_UINT(log_level, S_IRUGO | S_IWUSR, 0, 15, NULL); static struct bat_attribute *mesh_attrs[] = { &bat_attr_aggregated_ogms, &bat_attr_bonding, + &bat_attr_bridge_loop_avoidance, &bat_attr_fragmentation, &bat_attr_ap_isolation, &bat_attr_vis_mode,
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- [2011-10-27] Changes suggested by Marek Lindner: * move rcu_read_lock() more into the loops
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de
[2011-10-30] Changes suggested by Marek Lindner: * pimp up claim table debugfs output
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- bat_debugfs.c | 10 +++++++++ bridge_loop_avoidance.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++ bridge_loop_avoidance.h | 1 + 3 files changed, 62 insertions(+), 0 deletions(-)
diff --git a/bat_debugfs.c b/bat_debugfs.c index 492eec7..20d3fc9 100644 --- a/bat_debugfs.c +++ b/bat_debugfs.c @@ -32,6 +32,7 @@ #include "soft-interface.h" #include "vis.h" #include "icmp_socket.h" +#include "bridge_loop_avoidance.h"
static struct dentry *bat_debugfs;
@@ -239,6 +240,13 @@ static int transtable_global_open(struct inode *inode, struct file *file) return single_open(file, tt_global_seq_print_text, net_dev); }
+static int bla_claim_table_open(struct inode *inode, struct file *file) +{ + struct net_device *net_dev = (struct net_device *)inode->i_private; + return single_open(file, bla_claim_table_seq_print_text, net_dev); +} + + static int transtable_local_open(struct inode *inode, struct file *file) { struct net_device *net_dev = (struct net_device *)inode->i_private; @@ -271,6 +279,7 @@ struct bat_debuginfo bat_debuginfo_##_name = { \ static BAT_DEBUGINFO(originators, S_IRUGO, originators_open); static BAT_DEBUGINFO(gateways, S_IRUGO, gateways_open); static BAT_DEBUGINFO(transtable_global, S_IRUGO, transtable_global_open); +static BAT_DEBUGINFO(bla_claim_table, S_IRUGO, bla_claim_table_open); static BAT_DEBUGINFO(transtable_local, S_IRUGO, transtable_local_open); static BAT_DEBUGINFO(vis_data, S_IRUGO, vis_data_open);
@@ -278,6 +287,7 @@ static struct bat_debuginfo *mesh_debuginfos[] = { &bat_debuginfo_originators, &bat_debuginfo_gateways, &bat_debuginfo_transtable_global, + &bat_debuginfo_bla_claim_table, &bat_debuginfo_transtable_local, &bat_debuginfo_vis_data, NULL, diff --git a/bridge_loop_avoidance.c b/bridge_loop_avoidance.c index 641dbcc..bc4e57f 100644 --- a/bridge_loop_avoidance.c +++ b/bridge_loop_avoidance.c @@ -1238,3 +1238,54 @@ handled: claim_free_ref(claim); return 1; } + +int 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 hlist_node *node; + struct hlist_head *head; + uint32_t i; + int ret = 0; + + primary_if = primary_if_get_selected(bat_priv); + if (!primary_if) { + ret = seq_printf(seq, "BATMAN mesh %s disabled - please " + "specify interfaces to enable it\n", + net_dev->name); + goto out; + } + + if (primary_if->if_status != IF_ACTIVE) { + ret = seq_printf(seq, "BATMAN mesh %s disabled - " + "primary interface not active\n", + net_dev->name); + goto out; + } + + seq_printf(seq, "Claims announced for the mesh %s " + "(orig %pM)\n", + net_dev->name, bat_priv->own_orig); + seq_printf(seq, " %-17s %-5s %-17s [o] (%-4s)\n", + "Client", "VID", "Originator", "CRC"); + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(claim, node, head, hash_entry) + seq_printf(seq, " * %pM on % 5d by %pM [%c] (%04x)\n", + claim->addr, claim->vid, + claim->backbone_gw->orig, + (compare_eth(claim->backbone_gw->orig, + bat_priv->own_orig) ? 'x' : ' '), + claim->backbone_gw->crc); + rcu_read_unlock(); + } +out: + if (primary_if) + hardif_free_ref(primary_if); + return ret; +} diff --git a/bridge_loop_avoidance.h b/bridge_loop_avoidance.h index 8df5036..91aa515 100644 --- a/bridge_loop_avoidance.h +++ b/bridge_loop_avoidance.h @@ -23,6 +23,7 @@ int bla_rx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid); int bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid); int bla_is_backbone_gw(struct sk_buff *skb, struct orig_node *orig_node, int hdr_size); +int bla_claim_table_seq_print_text(struct seq_file *seq, void *offset); void bla_update_orig_address(struct bat_priv *bat_priv, uint8_t *newaddr); int bla_init(struct bat_priv *bat_priv); void bla_free(struct bat_priv *bat_priv);
as backbone gateways will all independently announce the same clients, also the tt global table must be able to hold multiple originators per client entry.
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de
--- [2011-10-30] recalculate global crc in any case:
this should not be required, but the crc diverges for some reason. Need to dig into this further ... --- translation-table.c | 333 ++++++++++++++++++++++++++++++++++++--------------- types.h | 13 ++- 2 files changed, 246 insertions(+), 100 deletions(-)
diff --git a/translation-table.c b/translation-table.c index 78b9528..946a872 100644 --- a/translation-table.c +++ b/translation-table.c @@ -30,10 +30,8 @@
#include <linux/crc16.h>
-static void _tt_global_del(struct bat_priv *bat_priv, - struct tt_global_entry *tt_global_entry, - const char *message); static void tt_purge(struct work_struct *work); +static void tt_global_del_orig_list(struct tt_global_entry *tt_global_entry);
/* returns 1 if they are the same mac addr */ static int compare_ltt(const struct hlist_node *node, const void *data2) @@ -142,17 +140,30 @@ static void tt_global_entry_free_rcu(struct rcu_head *rcu) struct tt_global_entry *tt_global_entry;
tt_global_entry = container_of(rcu, struct tt_global_entry, rcu); - - if (tt_global_entry->orig_node) - orig_node_free_ref(tt_global_entry->orig_node); - kfree(tt_global_entry); }
static void tt_global_entry_free_ref(struct tt_global_entry *tt_global_entry) { - if (atomic_dec_and_test(&tt_global_entry->refcount)) + if (atomic_dec_and_test(&tt_global_entry->refcount)) { + tt_global_del_orig_list(tt_global_entry); call_rcu(&tt_global_entry->rcu, tt_global_entry_free_rcu); + } +} + +static void tt_orig_list_entry_free_rcu(struct rcu_head *rcu) +{ + struct tt_orig_list_entry *orig_entry; + + orig_entry = container_of(rcu, struct tt_orig_list_entry, rcu); + atomic_dec(&orig_entry->orig_node->tt_size); + orig_node_free_ref(orig_entry->orig_node); + kfree(orig_entry); +} + +static void tt_orig_list_entry_free_ref(struct tt_orig_list_entry *orig_entry) +{ + call_rcu(&orig_entry->rcu, tt_orig_list_entry_free_rcu); }
static void tt_local_event(struct bat_priv *bat_priv, const uint8_t *addr, @@ -201,6 +212,9 @@ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr, 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 hlist_head *head; + struct hlist_node *node; + struct tt_orig_list_entry *orig_entry;
tt_local_entry = tt_local_hash_find(bat_priv, addr);
@@ -243,13 +257,20 @@ void tt_local_add(struct net_device *soft_iface, const uint8_t *addr,
/* Check whether it is a roaming! */ if (tt_global_entry) { - /* This node is probably going to update its tt table */ - tt_global_entry->orig_node->tt_poss_change = true; - /* The global entry has to be marked as PENDING and has to be - * kept for consistency purpose */ + /* These node are probably going to update their tt table */ + head = &tt_global_entry->orig_list; + rcu_read_lock(); + hlist_for_each_entry_rcu(orig_entry, + node, head, list) { + orig_entry->orig_node->tt_poss_change = true; + + /* The global entry has to be marked as PENDING and + * has to be kept for consistency purpose */ + send_roam_adv(bat_priv, tt_global_entry->addr, + orig_entry->orig_node); + } + rcu_read_unlock(); tt_global_entry->flags |= TT_CLIENT_PENDING; - send_roam_adv(bat_priv, tt_global_entry->addr, - tt_global_entry->orig_node); } out: if (tt_local_entry) @@ -494,49 +515,90 @@ static void tt_changes_list_free(struct bat_priv *bat_priv) spin_unlock_bh(&bat_priv->tt_changes_list_lock); }
+/* find out if an orig_node is already in the list of a tt_global_entry. + * we expect to have an rcu_readlock outside. */ +static struct tt_orig_list_entry *tt_global_entry_find_orig( + struct tt_global_entry *tt_global_entry, + struct orig_node *orig_node) +{ + struct tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL; + struct hlist_head *head; + struct hlist_node *node; + + head = &tt_global_entry->orig_list; + hlist_for_each_entry_rcu(tmp_orig_entry, + node, head, list) { + if (tmp_orig_entry->orig_node == orig_node) { + orig_entry = tmp_orig_entry; + break; + } + } + return orig_entry; +} + /* caller must hold orig_node refcount */ int tt_global_add(struct bat_priv *bat_priv, struct orig_node *orig_node, const unsigned char *tt_addr, uint8_t ttvn, bool roaming, bool wifi) { - struct tt_global_entry *tt_global_entry; - struct orig_node *orig_node_tmp; + struct tt_global_entry *tt_global_entry = NULL; + struct tt_orig_list_entry *orig_entry = NULL; int ret = 0;
tt_global_entry = tt_global_hash_find(bat_priv, tt_addr);
if (!tt_global_entry) { - tt_global_entry = - kmalloc(sizeof(*tt_global_entry), - GFP_ATOMIC); + tt_global_entry = kzalloc(sizeof(*tt_global_entry), + GFP_ATOMIC); if (!tt_global_entry) goto out; + orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC); + if (!orig_entry) { + kfree(tt_global_entry); + tt_global_entry = NULL; + goto out; + }
memcpy(tt_global_entry->addr, tt_addr, ETH_ALEN); - /* Assign the new orig_node */ - atomic_inc(&orig_node->refcount); - tt_global_entry->orig_node = orig_node; - tt_global_entry->ttvn = ttvn; + tt_global_entry->flags = NO_FLAGS; tt_global_entry->roam_at = 0; atomic_set(&tt_global_entry->refcount, 2);
+ INIT_HLIST_HEAD(&tt_global_entry->orig_list); + spin_lock_init(&tt_global_entry->list_lock); + hash_add(bat_priv->tt_global_hash, compare_gtt, choose_orig, tt_global_entry, &tt_global_entry->hash_entry); + } else { + rcu_read_lock(); + orig_entry = tt_global_entry_find_orig(tt_global_entry, + orig_node); + rcu_read_unlock(); + + if (orig_entry) + /* already in the list, no need to add it again */ + orig_entry = NULL; + else + orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC); + + tt_global_entry->flags = NO_FLAGS; + tt_global_entry->roam_at = 0; + } + + /* new orig_entry needs to be added */ + if (orig_entry) { + INIT_HLIST_NODE(&orig_entry->list); + atomic_inc(&orig_node->refcount); atomic_inc(&orig_node->tt_size); - } else { - if (tt_global_entry->orig_node != orig_node) { - atomic_dec(&tt_global_entry->orig_node->tt_size); - orig_node_tmp = tt_global_entry->orig_node; - atomic_inc(&orig_node->refcount); - tt_global_entry->orig_node = orig_node; - orig_node_free_ref(orig_node_tmp); - atomic_inc(&orig_node->tt_size); - } - tt_global_entry->ttvn = ttvn; - tt_global_entry->flags = NO_FLAGS; - tt_global_entry->roam_at = 0; + orig_entry->orig_node = orig_node; + orig_entry->ttvn = ttvn; + + spin_lock_bh(&tt_global_entry->list_lock); + hlist_add_head_rcu(&orig_entry->list, + &tt_global_entry->orig_list); + spin_unlock_bh(&tt_global_entry->list_lock); }
if (wifi) @@ -556,6 +618,33 @@ out: return ret; }
+/* + * print all orig nodes who announce the address for this global entry. + * it is assumed that the caller holds rcu_read_lock(); + */ +static void tt_global_print_entry(struct 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; + + head = &tt_global_entry->orig_list; + + hlist_for_each_entry_rcu(orig_entry, node, head, list) { + seq_printf(seq, " * %pM (%3u) via %pM (%3u) " + "[%c%c%c]\n", tt_global_entry->addr, + orig_entry->ttvn, + orig_entry->orig_node->orig, + (uint8_t) atomic_read(&orig_entry->orig_node-> + last_ttvn), + (tt_global_entry->flags & TT_CLIENT_ROAM ? 'R' : '.'), + (tt_global_entry->flags & + TT_CLIENT_PENDING ? 'X' : '.'), + (tt_global_entry->flags & TT_CLIENT_WIFI ? 'W' : '.')); + } +} + int tt_global_seq_print_text(struct seq_file *seq, void *offset) { struct net_device *net_dev = (struct net_device *)seq->private; @@ -594,21 +683,8 @@ int tt_global_seq_print_text(struct seq_file *seq, void *offset)
rcu_read_lock(); hlist_for_each_entry_rcu(tt_global_entry, node, - head, hash_entry) { - seq_printf(seq, " * %pM (%3u) via %pM (%3u) " - "[%c%c%c]\n", tt_global_entry->addr, - tt_global_entry->ttvn, - tt_global_entry->orig_node->orig, - (uint8_t) atomic_read( - &tt_global_entry->orig_node-> - last_ttvn), - (tt_global_entry->flags & - TT_CLIENT_ROAM ? 'R' : '.'), - (tt_global_entry->flags & - TT_CLIENT_PENDING ? 'X' : '.'), - (tt_global_entry->flags & - TT_CLIENT_WIFI ? 'W' : '.')); - } + head, hash_entry) + tt_global_print_entry(tt_global_entry, seq); rcu_read_unlock(); } out: @@ -617,27 +693,47 @@ out: return ret; }
-static void _tt_global_del(struct bat_priv *bat_priv, - struct tt_global_entry *tt_global_entry, - const char *message) +/* deletes the orig list of a tt_global_entry */ +static void tt_global_del_orig_list(struct tt_global_entry *tt_global_entry) { - if (!tt_global_entry) - goto out; + struct hlist_head *head; + struct hlist_node *node, *safe; + struct tt_orig_list_entry *orig_entry;
- bat_dbg(DBG_TT, bat_priv, - "Deleting global tt entry %pM (via %pM): %s\n", - tt_global_entry->addr, tt_global_entry->orig_node->orig, - message); + 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) { + hlist_del_rcu(node); + tt_orig_list_entry_free_ref(orig_entry); + } + spin_unlock_bh(&tt_global_entry->list_lock);
- atomic_dec(&tt_global_entry->orig_node->tt_size); +} + +static void tt_global_del_orig_entry(struct bat_priv *bat_priv, + struct tt_global_entry *tt_global_entry, + struct orig_node *orig_node, const char *message) +{ + struct hlist_head *head; + struct hlist_node *node, *safe; + struct tt_orig_list_entry *orig_entry;
- hash_remove(bat_priv->tt_global_hash, compare_gtt, choose_orig, - tt_global_entry->addr); -out: - if (tt_global_entry) - tt_global_entry_free_ref(tt_global_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) { + bat_dbg(DBG_TT, bat_priv, + "Deleting %pM from global tt entry %pM: %s\n", + orig_node->orig, tt_global_entry->addr, + message); + hlist_del_rcu(node); + tt_orig_list_entry_free_ref(orig_entry); + } + } + spin_unlock_bh(&tt_global_entry->list_lock); }
+ void tt_global_del(struct bat_priv *bat_priv, struct orig_node *orig_node, const unsigned char *addr, const char *message, bool roaming) @@ -648,13 +744,23 @@ void tt_global_del(struct bat_priv *bat_priv, if (!tt_global_entry) goto out;
- if (tt_global_entry->orig_node == orig_node) { - if (roaming) { - tt_global_entry->flags |= TT_CLIENT_ROAM; - tt_global_entry->roam_at = jiffies; - goto out; - } - _tt_global_del(bat_priv, tt_global_entry, message); + if (roaming) { + tt_global_entry->flags |= TT_CLIENT_ROAM; + tt_global_entry->roam_at = jiffies; + goto out; + } + tt_global_del_orig_entry(bat_priv, tt_global_entry, + orig_node, message); + + if (hlist_empty(&tt_global_entry->orig_list)) { + bat_dbg(DBG_TT, bat_priv, + "Deleting global tt entry %pM (via %pM): %s\n", + tt_global_entry->addr, orig_node->orig, + message); + + hash_remove(bat_priv->tt_global_hash, compare_gtt, choose_orig, + tt_global_entry->addr); + tt_global_entry_free_ref(tt_global_entry); } out: if (tt_global_entry) @@ -681,12 +787,13 @@ void tt_global_del_orig(struct bat_priv *bat_priv, spin_lock_bh(list_lock); hlist_for_each_entry_safe(tt_global_entry, node, safe, head, hash_entry) { - if (tt_global_entry->orig_node == orig_node) { + tt_global_del_orig_entry(bat_priv, tt_global_entry, + orig_node, message); + + if (hlist_empty(&tt_global_entry->orig_list)) { bat_dbg(DBG_TT, bat_priv, - "Deleting global tt entry %pM " - "(via %pM): %s\n", + "Deleting global tt entry %pM: %s\n", tt_global_entry->addr, - tt_global_entry->orig_node->orig, message); hlist_del_rcu(node); tt_global_entry_free_ref(tt_global_entry); @@ -718,11 +825,10 @@ static void tt_global_roam_purge(struct bat_priv *bat_priv) if (!is_out_of_time(tt_global_entry->roam_at, TT_CLIENT_ROAM_TIMEOUT * 1000)) continue; - bat_dbg(DBG_TT, bat_priv, "Deleting global " "tt entry (%pM): Roaming timeout\n", tt_global_entry->addr); - atomic_dec(&tt_global_entry->orig_node->tt_size); + hlist_del_rcu(node); tt_global_entry_free_ref(tt_global_entry); } @@ -781,6 +887,11 @@ struct orig_node *transtable_search(struct bat_priv *bat_priv, 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 hlist_head *head; + struct hlist_node *node; + struct tt_orig_list_entry *orig_entry; + int best_tq;
if (src && atomic_read(&bat_priv->ap_isolation)) { tt_local_entry = tt_local_hash_find(bat_priv, src); @@ -797,16 +908,30 @@ struct orig_node *transtable_search(struct bat_priv *bat_priv, if (tt_local_entry && _is_ap_isolated(tt_local_entry, tt_global_entry)) goto out;
- if (!atomic_inc_not_zero(&tt_global_entry->orig_node->refcount)) - goto out; - /* A global client marked as PENDING has already moved from that * originator */ if (tt_global_entry->flags & TT_CLIENT_PENDING) goto out;
- orig_node = tt_global_entry->orig_node; + best_tq = 0;
+ rcu_read_lock(); + head = &tt_global_entry->orig_list; + hlist_for_each_entry_rcu(orig_entry, node, head, list) { + router = orig_node_get_router(orig_entry->orig_node); + if (!router) + continue; + + if (router->tq_avg > best_tq) { + orig_node = orig_entry->orig_node; + best_tq = router->tq_avg; + } + neigh_node_free_ref(router); + } + /* found anything? */ + if (orig_node && !atomic_inc_not_zero(&orig_node->refcount)) + orig_node = NULL; + rcu_read_unlock(); out: if (tt_global_entry) tt_global_entry_free_ref(tt_global_entry); @@ -822,6 +947,7 @@ uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node) uint16_t total = 0, total_one; struct hashtable_t *hash = bat_priv->tt_global_hash; struct tt_global_entry *tt_global_entry; + struct tt_orig_list_entry *orig_entry; struct hlist_node *node; struct hlist_head *head; uint32_t i; @@ -833,20 +959,25 @@ uint16_t tt_global_crc(struct bat_priv *bat_priv, struct orig_node *orig_node) rcu_read_lock(); hlist_for_each_entry_rcu(tt_global_entry, node, head, hash_entry) { - if (compare_eth(tt_global_entry->orig_node, - orig_node)) { - /* 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->flags & TT_CLIENT_ROAM) - continue; - total_one = 0; - for (j = 0; j < ETH_ALEN; j++) - total_one = crc16_byte(total_one, - tt_global_entry->addr[j]); - total ^= total_one; - } + /* 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->flags & TT_CLIENT_ROAM) + continue; + + /* find out if this global entry is announced by this + * originator */ + orig_entry = tt_global_entry_find_orig(tt_global_entry, + orig_node); + if (!orig_entry) + continue; + + total_one = 0; + for (j = 0; j < ETH_ALEN; j++) + total_one = crc16_byte(total_one, + tt_global_entry->addr[j]); + total ^= total_one; } rcu_read_unlock(); } @@ -978,11 +1109,18 @@ static int tt_global_valid_entry(const void *entry_ptr, const void *data_ptr) { const struct tt_global_entry *tt_global_entry = entry_ptr; const struct orig_node *orig_node = data_ptr; + struct tt_orig_list_entry *orig_entry;
if (tt_global_entry->flags & TT_CLIENT_ROAM) return 0;
- return (tt_global_entry->orig_node == orig_node); + rcu_read_lock(); + orig_entry = tt_global_entry_find_orig( + (struct tt_global_entry *) tt_global_entry, + (struct orig_node *) orig_node); + rcu_read_unlock(); + + return (orig_entry != NULL); }
static struct sk_buff *tt_response_fill_table(uint16_t tt_len, uint8_t ttvn, @@ -1819,6 +1957,7 @@ void tt_update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node, } else { /* if we missed more than one change or our tables are not * in sync anymore -> request fresh tt data */ + orig_node->tt_crc = tt_global_crc(bat_priv, orig_node); if (ttvn != orig_ttvn || orig_node->tt_crc != tt_crc) { request_table: bat_dbg(DBG_TT, bat_priv, "TT inconsistency for %pM. " diff --git a/types.h b/types.h index 3cffe8d..0ca2d4c 100644 --- a/types.h +++ b/types.h @@ -237,12 +237,19 @@ struct tt_local_entry { struct tt_global_entry { uint8_t addr[ETH_ALEN]; struct hlist_node hash_entry; /* entry in the global table */ - struct orig_node *orig_node; - uint8_t ttvn; - uint16_t flags; /* only TT_GLOBAL_ROAM is used */ unsigned long roam_at; /* time at which TT_GLOBAL_ROAM was set */ + uint16_t flags; /* only TT_GLOBAL_ROAM is used */ atomic_t refcount; struct rcu_head rcu; + struct hlist_head orig_list; + spinlock_t list_lock; /* protects the list */ +}; + +struct tt_orig_list_entry { + struct orig_node *orig_node; + uint8_t ttvn; + struct rcu_head rcu; + struct hlist_node list; };
struct backbone_gw {
As the backbone gateways are connected to the same backbone, they should announce the same clients on the backbone non-exclusively.
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- [2011-10-27] Changes suggested by Marek Lindner: * move rcu_read_lock() more into the loops
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- bridge_loop_avoidance.c | 50 +++++++++++++++++++++++++++++++++++++++++++++++ bridge_loop_avoidance.h | 1 + routing.c | 6 +++++ translation-table.c | 17 ++++++++++++++- 4 files changed, 72 insertions(+), 2 deletions(-)
diff --git a/bridge_loop_avoidance.c b/bridge_loop_avoidance.c index bc4e57f..a787c96 100644 --- a/bridge_loop_avoidance.c +++ b/bridge_loop_avoidance.c @@ -24,6 +24,7 @@ #include "hard-interface.h" #include "originator.h" #include "bridge_loop_avoidance.h" +#include "translation-table.h" #include "send.h"
#include <linux/etherdevice.h> @@ -350,6 +351,7 @@ static struct backbone_gw *bla_get_backbone_gw(struct bat_priv *bat_priv, uint8_t *orig, short vid) { struct backbone_gw *entry; + struct orig_node *orig_node;
entry = backbone_hash_find(bat_priv, orig, vid);
@@ -377,6 +379,13 @@ static struct backbone_gw *bla_get_backbone_gw(struct bat_priv *bat_priv, hash_add(bat_priv->backbone_hash, compare_backbone_gw, choose_claim, entry, &entry->hash_entry);
+ /* this is a gateway now, remove any tt entries */ + orig_node = orig_hash_find(bat_priv, orig); + if (orig_node) { + tt_global_del_orig(bat_priv, orig_node, + "became a backbone gateway"); + orig_node_free_ref(orig_node); + } return entry; }
@@ -979,6 +988,47 @@ int bla_init(struct bat_priv *bat_priv) }
/** + * @bat_priv: the bat priv with all the soft interface information + * @orig: originator mac address + * + * check if the originator is a gateway for any VLAN ID. + * + * returns 1 if it is found, 0 otherwise + * + **/ + +int bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig) +{ + struct hashtable_t *hash = bat_priv->backbone_hash; + struct hlist_head *head; + struct hlist_node *node; + struct backbone_gw *backbone_gw; + int i; + + if (!atomic_read(&bat_priv->bridge_loop_avoidance)) + return 0; + + if (!hash) + return 0; + + for (i = 0; i < hash->size; i++) { + head = &hash->table[i]; + + rcu_read_lock(); + hlist_for_each_entry_rcu(backbone_gw, node, head, hash_entry) { + if (compare_eth(backbone_gw->orig, orig)) { + rcu_read_unlock(); + return 1; + } + } + rcu_read_unlock(); + } + + return 0; +} + + +/** * @skb: the frame to be checked * @orig_node: the orig_node of the frame * @hdr_size: maximum length of the frame diff --git a/bridge_loop_avoidance.h b/bridge_loop_avoidance.h index 91aa515..bafcfac 100644 --- a/bridge_loop_avoidance.h +++ b/bridge_loop_avoidance.h @@ -24,6 +24,7 @@ int bla_tx(struct bat_priv *bat_priv, struct sk_buff *skb, short vid); int bla_is_backbone_gw(struct sk_buff *skb, struct orig_node *orig_node, int hdr_size); int bla_claim_table_seq_print_text(struct seq_file *seq, void *offset); +int bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig); void bla_update_orig_address(struct bat_priv *bat_priv, uint8_t *newaddr); int bla_init(struct bat_priv *bat_priv); void bla_free(struct bat_priv *bat_priv); diff --git a/routing.c b/routing.c index 8050fb2..1554f60 100644 --- a/routing.c +++ b/routing.c @@ -675,6 +675,12 @@ int recv_roam_adv(struct sk_buff *skb, struct hard_iface *recv_if) if (!is_my_mac(roam_adv_packet->dst)) return route_unicast_packet(skb, recv_if);
+ /* check if it is a backbone gateway. we don't accept + * roaming advertisement from it, as it has the same + * entries as we have. */ + if (bla_is_backbone_gw_orig(bat_priv, roam_adv_packet->src)) + goto out; + orig_node = orig_hash_find(bat_priv, roam_adv_packet->src); if (!orig_node) goto out; diff --git a/translation-table.c b/translation-table.c index 946a872..06a51e5 100644 --- a/translation-table.c +++ b/translation-table.c @@ -27,6 +27,7 @@ #include "hash.h" #include "originator.h" #include "routing.h" +#include "bridge_loop_avoidance.h"
#include <linux/crc16.h>
@@ -1501,9 +1502,13 @@ out: bool send_tt_response(struct bat_priv *bat_priv, struct tt_query_packet *tt_request) { - if (is_my_mac(tt_request->dst)) + if (is_my_mac(tt_request->dst)) { + /* don't answer backbone gws! */ + if (bla_is_backbone_gw_orig(bat_priv, tt_request->src)) + return true; + return send_my_tt_response(bat_priv, tt_request); - else + } else return send_other_tt_response(bat_priv, tt_request); }
@@ -1608,6 +1613,10 @@ void handle_tt_response(struct bat_priv *bat_priv, tt_response->tt_data, (tt_response->flags & TT_FULL_TABLE ? 'F' : '.'));
+ /* we should have never asked a backbone gw */ + if (bla_is_backbone_gw_orig(bat_priv, tt_response->src)) + goto out; + orig_node = orig_hash_find(bat_priv, tt_response->src); if (!orig_node) goto out; @@ -1922,6 +1931,10 @@ void tt_update_orig(struct bat_priv *bat_priv, struct orig_node *orig_node, uint8_t orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn); bool full_table = true;
+ /* don't care about a backbone gateways updates. */ + if (bla_is_backbone_gw_orig(bat_priv, orig_node->orig)) + return; + /* the ttvn increased by one -> we can apply the attached changes */ if (ttvn - orig_ttvn == 1) { /* the OGM could not contain the changes due to their size or
When multiple backbone gateways relay the same broadcast from the backbone into the mesh, other nodes in the mesh may receive this broadcast multiple times. To avoid this, the crc checksums of received broadcasts are recorded and new broadcast packets with the same content may be dropped if received by another gateway.
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- bridge_loop_avoidance.c | 73 +++++++++++++++++++++++++++++++++++++++++++++++ bridge_loop_avoidance.h | 2 + main.h | 3 ++ routing.c | 4 ++ types.h | 7 ++++ 5 files changed, 89 insertions(+), 0 deletions(-)
diff --git a/bridge_loop_avoidance.c b/bridge_loop_avoidance.c index a787c96..b1f2abc 100644 --- a/bridge_loop_avoidance.c +++ b/bridge_loop_avoidance.c @@ -970,8 +970,16 @@ timer: /* initialize all bla structures */ int bla_init(struct bat_priv *bat_priv) { + int i; + bat_dbg(DBG_BLA, bat_priv, "bla hash registering\n");
+ /* initialize the duplicate list */ + for (i = 0; i < DUPLIST_SIZE; i++) + bat_priv->bcast_duplist[i].entrytime = + jiffies - msecs_to_jiffies(DUPLIST_TIMEOUT); + bat_priv->bcast_duplist_curr = 0; + if (bat_priv->claim_hash) return 1;
@@ -989,6 +997,71 @@ int bla_init(struct bat_priv *bat_priv)
/** * @bat_priv: the bat priv with all the soft interface information + * @bcast_packet: originator mac address + * @hdr_size: maximum length of the frame + * + * check if it is on our broadcast list. Another gateway might + * have sent the same packet because it is connected to the same backbone, + * so we have to remove this duplicate. + * + * This is performed by checking the CRC, which will tell us + * with a good chance that it is the same packet. If it is furthermore + * sent by another host, drop it. We allow equal packets from + * the same host however as this might be intended. + * + **/ + +int bla_check_bcast_duplist(struct bat_priv *bat_priv, + struct bcast_packet *bcast_packet, int hdr_size) +{ + int i, length, curr; + uint8_t *content; + uint16_t crc; + struct bcast_duplist_entry *entry; + + length = hdr_size - sizeof(*bcast_packet); + content = (uint8_t *) bcast_packet; + content += sizeof(*bcast_packet); + + /* calculate the crc ... */ + crc = crc16(0, content, length); + + for (i = 0 ; i < DUPLIST_SIZE; i++) { + curr = (bat_priv->bcast_duplist_curr + i) % DUPLIST_SIZE; + entry = &bat_priv->bcast_duplist[curr]; + + /* we can stop searching if the entry is too old ; + * later entries will be even older */ + if (time_after(jiffies, entry->entrytime + + msecs_to_jiffies(DUPLIST_TIMEOUT))) + break; + + if (entry->crc != crc) + continue; + + if (compare_eth(entry->orig, bcast_packet->orig)) + continue; + + /* this entry seems to match: same crc, not too old, + * and from another gw. therefore return 1 to forbid it. */ + return 1; + } + /* not found, add a new entry (overwrite the oldest entry) */ + curr = (bat_priv->bcast_duplist_curr + DUPLIST_SIZE - 1) % DUPLIST_SIZE; + entry = &bat_priv->bcast_duplist[curr]; + entry->crc = crc; + entry->entrytime = jiffies; + memcpy(entry->orig, bcast_packet->orig, ETH_ALEN); + bat_priv->bcast_duplist_curr = curr; + + /* allow it, its the first occurence. */ + return 0; +} + + + +/** + * @bat_priv: the bat priv with all the soft interface information * @orig: originator mac address * * check if the originator is a gateway for any VLAN ID. diff --git a/bridge_loop_avoidance.h b/bridge_loop_avoidance.h index bafcfac..60dcb1b 100644 --- a/bridge_loop_avoidance.h +++ b/bridge_loop_avoidance.h @@ -25,6 +25,8 @@ int bla_is_backbone_gw(struct sk_buff *skb, struct orig_node *orig_node, int hdr_size); int bla_claim_table_seq_print_text(struct seq_file *seq, void *offset); int bla_is_backbone_gw_orig(struct bat_priv *bat_priv, uint8_t *orig); +int bla_check_bcast_duplist(struct bat_priv *bat_priv, + struct bcast_packet *bcast_packet, int hdr_size); void bla_update_orig_address(struct bat_priv *bat_priv, uint8_t *newaddr); int bla_init(struct bat_priv *bat_priv); void bla_free(struct bat_priv *bat_priv); diff --git a/main.h b/main.h index 1bd41f1..f96d817 100644 --- a/main.h +++ b/main.h @@ -82,6 +82,9 @@ #define BLA_PERIOD_LENGTH 10000 /* 10 seconds */ #define BLA_BACKBONE_TIMEOUT (BLA_PERIOD_LENGTH * 3) #define BLA_CLAIM_TIMEOUT (BLA_PERIOD_LENGTH * 10) + +#define DUPLIST_SIZE 16 +#define DUPLIST_TIMEOUT 500 /* 500 ms */ /* don't reset again within 30 seconds */ #define RESET_PROTECTION_MS 30000 #define EXPECTED_SEQNO_RANGE 65536 diff --git a/routing.c b/routing.c index 1554f60..00e5339 100644 --- a/routing.c +++ b/routing.c @@ -1078,6 +1078,10 @@ int recv_bcast_packet(struct sk_buff *skb, struct hard_iface *recv_if)
spin_unlock_bh(&orig_node->bcast_seqno_lock);
+ /* check whether this has been sent by another originator before */ + if (bla_check_bcast_duplist(bat_priv, bcast_packet, hdr_size)) + goto out; + /* rebroadcast packet */ add_bcast_packet_to_list(bat_priv, skb, 1);
diff --git a/types.h b/types.h index 0ca2d4c..5f02447 100644 --- a/types.h +++ b/types.h @@ -139,6 +139,11 @@ struct neigh_node { spinlock_t tq_lock; /* protects: tq_recv, tq_index */ };
+struct bcast_duplist_entry { + uint8_t orig[ETH_ALEN]; + uint16_t crc; + unsigned long entrytime; +};
struct bat_priv { atomic_t mesh_state; @@ -185,6 +190,8 @@ struct bat_priv { struct list_head tt_req_list; /* list of pending tt_requests */ struct list_head tt_roam_list; struct hashtable_t *vis_hash; + struct bcast_duplist_entry bcast_duplist[DUPLIST_SIZE]; + int bcast_duplist_curr; spinlock_t forw_bat_list_lock; /* protects forw_bat_list */ spinlock_t forw_bcast_list_lock; /* protects */ spinlock_t tt_changes_list_lock; /* protects tt_changes */
On Sunday, October 30, 2011 23:51:08 Simon Wunderlich wrote:
+struct bcast_duplist_entry {
uint8_t orig[ETH_ALEN];uint16_t crc;unsigned long entrytime;+};
struct bat_priv { atomic_t mesh_state; @@ -185,6 +190,8 @@ struct bat_priv { struct list_head tt_req_list; /* list of pending tt_requests */ struct list_head tt_roam_list; struct hashtable_t *vis_hash;
struct bcast_duplist_entry bcast_duplist[DUPLIST_SIZE];
These are 200 bytes you are adding here. Any specific reason not to allocate it?
Regards, Marek
On Tue, Nov 01, 2011 at 11:47:12AM +0100, Marek Lindner wrote:
On Sunday, October 30, 2011 23:51:08 Simon Wunderlich wrote:
+struct bcast_duplist_entry {
uint8_t orig[ETH_ALEN];uint16_t crc;unsigned long entrytime;+};
struct bat_priv { atomic_t mesh_state; @@ -185,6 +190,8 @@ struct bat_priv { struct list_head tt_req_list; /* list of pending tt_requests */ struct list_head tt_roam_list; struct hashtable_t *vis_hash;
struct bcast_duplist_entry bcast_duplist[DUPLIST_SIZE];These are 200 bytes you are adding here. Any specific reason not to allocate it?
No specific reason, however I could not think of any reason to allocate link it: * bat_priv is kmalloc()d anyways * we will always need this structure once the patch is applied * we need it only once per bat_priv, no sharing, no lists etc * external allocation would require a few more lines plus sanity checking
no problem to change it, but I just could not think of a good reason why - maybe you have one? :)
best regards, Simon
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- soft-interface.c | 6 ++++++ 1 files changed, 6 insertions(+), 0 deletions(-)
diff --git a/soft-interface.c b/soft-interface.c index 46dd328..7f7efb9 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -129,6 +129,7 @@ static int interface_tx(struct sk_buff *skb, struct net_device *soft_iface) struct hard_iface *primary_if = NULL; struct bcast_packet *bcast_packet; struct vlan_ethhdr *vhdr; + uint8_t stp_addr[6] = {0x01, 0x80, 0xC2, 0x00, 0x00, 0x00}; unsigned int header_len = 0; int data_len = skb->len, ret; short vid = -1; @@ -158,6 +159,11 @@ static int interface_tx(struct sk_buff *skb, struct net_device *soft_iface) /* Register the client MAC in the transtable */ tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
+ /* don't accept stp packets. STP does not help in meshes. + * better use the bridge loop avoidance ... */ + if (compare_eth(ethhdr->h_dest, stp_addr)) + goto dropped; + if (is_multicast_ether_addr(ethhdr->h_dest)) { do_bcast = true;
backbone gateways may be part of the same LAN, but participate in different meshes. With this patch, backbone gateways form groups by applying the groupid of another backbone gateway if it is higher. After forming the group, they only accept messages from backbone gateways of the same group.
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- [2011-10-27] fix a nasty bug which has overwritten the claim type
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de
[2011-10-30] Changes suggested by Marek Lindner: * give hw_src and hw_dst as parameter in check_claim_group() to avoid code duplicates * update group id when primary if address is changed
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- bridge_loop_avoidance.c | 111 +++++++++++++++++++++++++++++++++++++++++++--- types.h | 1 + 2 files changed, 104 insertions(+), 8 deletions(-)
diff --git a/bridge_loop_avoidance.c b/bridge_loop_avoidance.c index b1f2abc..52575f2 100644 --- a/bridge_loop_avoidance.c +++ b/bridge_loop_avoidance.c @@ -33,7 +33,6 @@ #include <net/arp.h> #include <linux/if_vlan.h>
-static const uint8_t claim_dest[6] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00}; static const uint8_t announce_mac[6] = {0x43, 0x05, 0x43, 0x05, 0x00, 0x00};
static void bla_periodic_work(struct work_struct *work); @@ -255,7 +254,7 @@ static void bla_send_claim(struct bat_priv *bat_priv, uint8_t *mac, if (!primary_if) return;
- memcpy(&local_claim_dest, claim_dest, + memcpy(&local_claim_dest, &bat_priv->claim_dest, sizeof(local_claim_dest)); local_claim_dest.type = claimtype;
@@ -268,8 +267,9 @@ static void bla_send_claim(struct bat_priv *bat_priv, uint8_t *mac, NULL, /* Ethernet DST: Broadcast */ primary_if->net_dev->dev_addr, /* Ethernet SRC/HW SRC: * originator mac */ - (uint8_t *)&local_claim_dest /* HW DST: FF:43:05:XX:00:00 - * with XX = claim type */ + (uint8_t *)&local_claim_dest /* HW DST: FF:43:05:XX:YY:YY + * with XX = claim type + * and YY:YY = group id */ );
if (!skb) @@ -701,6 +701,82 @@ static int handle_claim(struct bat_priv *bat_priv, return 1; }
+/** + * + * @bat_priv: the bat priv with all the soft interface information + * @hw_src: the Hardware source in the ARP Header + * @hw_dst: the Hardware destination in the ARP Header + * @ethhdr: pointer to the Ethernet header of the claim frame + * + * checks if it is a claim packet and if its on the same group. + * This function also applies the group ID of the sender + * if it is in the same mesh. + * + * returns: + * 2 - if it is a claim packet and on the same group + * 1 - if is a claim packet from another group + * 0 - if it is not a claim packet + */ +static int check_claim_group(struct bat_priv *bat_priv, + 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; + + bla_dst = (struct bla_claim_dst *) hw_dst; + bla_dst_own = &bat_priv->claim_dest; + + /* check if it is a claim packet in general */ + if (memcmp(bla_dst->magic, bla_dst_own->magic, + sizeof(bla_dst->magic)) != 0) + return 0; + + /* if announcement packet, use the source, + * otherwise assume it is in the hw_src */ + switch (bla_dst->type) { + case CLAIM_TYPE_ADD: + backbone_addr = hw_src; + break; + case CLAIM_TYPE_REQUEST: + case CLAIM_TYPE_ANNOUNCE: + case CLAIM_TYPE_DEL: + backbone_addr = ethhdr->h_source; + break; + default: + return 0; + } + + /* don't accept claim frames from ourselves */ + if (compare_eth(backbone_addr, bat_priv->own_orig)) + return 0; + + /* if its already the same group, it is fine. */ + if (bla_dst->group == bla_dst_own->group) + return 2; + + /* lets see if this originator is in our mesh */ + orig_node = orig_hash_find(bat_priv, backbone_addr); + + /* dont accept claims from gateways which are not in + * the same mesh or group. */ + if (!orig_node) + return 1; + + /* if our mesh friends mac is bigger, use it for ourselves. */ + if (ntohs(bla_dst->group) > ntohs(bla_dst_own->group)) { + bat_dbg(DBG_BLA, bat_priv, + "taking other backbones claim group: %04x\n", + ntohs(bla_dst->group)); + bla_dst_own->group = bla_dst->group; + } + + orig_node_free_ref(orig_node); + + return 2; +} + + /* * @bat_priv: the bat priv with all the soft interface information * @skb: the frame to be checked @@ -721,6 +797,7 @@ static int bla_process_claim(struct bat_priv *bat_priv, struct sk_buff *skb) uint16_t proto; int headlen; short vid = -1; + int ret;
ethhdr = (struct ethhdr *)skb_mac_header(skb);
@@ -761,8 +838,15 @@ static int bla_process_claim(struct bat_priv *bat_priv, struct sk_buff *skb) bla_dst = (struct bla_claim_dst *) hw_dst;
/* check if it is a claim frame. */ - if (memcmp(hw_dst, claim_dest, 3) != 0) - return 0; + ret = check_claim_group(bat_priv, hw_src, hw_dst, ethhdr); + if (ret == 1) + bat_dbg(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); + + if (ret < 2) + return ret;
/* become a backbone gw ourselves on this vlan if not happened yet */ bla_update_own_backbone_gw(bat_priv, vid); @@ -806,6 +890,9 @@ void bla_update_orig_address(struct bat_priv *bat_priv, uint8_t *newaddr) struct hashtable_t *hash; int i;
+ /* reset bridge loop avoidance group id */ + bat_priv->claim_dest.group = htons(crc16(0, newaddr, ETH_ALEN)); + hash = bat_priv->backbone_hash; if (!hash) return; @@ -971,9 +1058,16 @@ timer: int bla_init(struct bat_priv *bat_priv) { int i; + uint8_t claim_dest[6] = {0xff, 0x43, 0x05, 0x00, 0x00, 0x00};
bat_dbg(DBG_BLA, bat_priv, "bla hash registering\n");
+ /* setting claim destination address */ + memcpy(&bat_priv->claim_dest.magic, claim_dest, 3); + bat_priv->claim_dest.type = 0; + bat_priv->claim_dest.group = + htons(crc16(0, bat_priv->own_orig, ETH_ALEN)); + /* initialize the duplicate list */ for (i = 0; i < DUPLIST_SIZE; i++) bat_priv->bcast_duplist[i].entrytime = @@ -1390,8 +1484,9 @@ int bla_claim_table_seq_print_text(struct seq_file *seq, void *offset) }
seq_printf(seq, "Claims announced for the mesh %s " - "(orig %pM)\n", - net_dev->name, bat_priv->own_orig); + "(orig %pM, group id %04x)\n", + net_dev->name, bat_priv->own_orig, + ntohs(bat_priv->claim_dest.group)); seq_printf(seq, " %-17s %-5s %-17s [o] (%-4s)\n", "Client", "VID", "Originator", "CRC"); for (i = 0; i < hash->size; i++) { diff --git a/types.h b/types.h index 5f02447..21c4f3e 100644 --- a/types.h +++ b/types.h @@ -192,6 +192,7 @@ struct bat_priv { struct hashtable_t *vis_hash; struct bcast_duplist_entry bcast_duplist[DUPLIST_SIZE]; int bcast_duplist_curr; + struct bla_claim_dst claim_dest; spinlock_t forw_bat_list_lock; /* protects forw_bat_list */ spinlock_t forw_bcast_list_lock; /* protects */ spinlock_t tt_changes_list_lock; /* protects tt_changes */
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- README | 28 +++++++++++++++------------- sysfs-class-net-mesh | 9 +++++++++ 2 files changed, 24 insertions(+), 13 deletions(-)
diff --git a/README b/README index 5ba56b5..44061af 100644 --- a/README +++ b/README @@ -1,4 +1,4 @@ -[state: 30-09-2011] +[state: 27-10-2011]
BATMAN-ADV ---------- @@ -82,17 +82,17 @@ To deactivate an interface you have to write "none" into its All mesh wide settings can be found in batman's own interface folder:
-# ls /sys/class/net/bat0/mesh/ -# aggregated_ogms fragmentation gw_sel_class vis_mode -# ap_isolation gw_bandwidth hop_penalty -# bonding gw_mode orig_interval +# ls /sys/class/net/bat0/mesh/ +# aggregated_ogms fragmentation hop_penalty +# ap_isolation gw_bandwidth log_level +# bonding gw_mode orig_interval +# bridge_loop_avoidance gw_sel_class vis_mode
There is a special folder for debugging information:
# ls /sys/kernel/debug/batman_adv/bat0/ -# gateways socket transtable_global vis_data -# originators softif_neigh transtable_local - +# bla_claim_table log socket transtable_local +# gateways originators transtable_global vis_data
Some of the files contain all sort of status information regard- ing the mesh network. For example, you can view the table of @@ -216,15 +216,17 @@ file in debugfs The additional debug output is by default disabled. It can be en- abled during run time. Following log_levels are defined:
-0 - All debug output disabled -1 - Enable messages related to routing / flooding / broadcasting -2 - Enable route or tt entry added / changed / deleted -3 - Enable all messages +0 - all debug output disabled +1 - messages related to routing / flooding / broadcasting +2 - messages related to route added / changed / deleted +4 - messages related to translation table operations +8 - messages related to bridge loop avoidance +15 - enable all messages
The debug output can be changed at runtime using the file /sys/class/net/bat0/mesh/log_level. e.g.
-# echo 2 > /sys/class/net/bat0/mesh/log_level +# echo 6 > /sys/class/net/bat0/mesh/log_level
will enable debug messages for when routes or TTs change.
diff --git a/sysfs-class-net-mesh b/sysfs-class-net-mesh index b020014..1d39bc7 100644 --- a/sysfs-class-net-mesh +++ b/sysfs-class-net-mesh @@ -14,6 +14,15 @@ Description: mesh will be sent using multiple interfaces at the same time (if available).
+What: /sys/class/net/<mesh_iface>/mesh/bridge_loop_avoidance +Date: November 2011 +Contact: Simon Wunderlich siwu@hrz.tu-chemnitz.de +Description: + Indicates whether the bridge loop avoidance feature + is enabled. This feature detects and avoids loops + between the mesh and devices bridged with the soft + interface <mesh_iface>. + What: /sys/class/net/<mesh_iface>/mesh/fragmentation Date: October 2010 Contact: Andreas Langer an.langer@gmx.de
Instead of acquiring the first interfaces originator through hard interface (including referencing/dereferencing), we can use the cached value in bat_priv->own_orig.
There might be some cases where this function was implicitly used to check whether there is a hard interface configured at all (i.e. if batman is active), therfore this is patch is an RFC.
Signed-off-by: Simon Wunderlich siwu@hrz.tu-chemnitz.de --- icmp_socket.c | 12 +----------- routing.c | 25 +++---------------------- translation-table.c | 16 ++-------------- unicast.c | 9 +-------- vis.c | 20 ++------------------ 5 files changed, 9 insertions(+), 73 deletions(-)
diff --git a/icmp_socket.c b/icmp_socket.c index ac3520e..86dcffd 100644 --- a/icmp_socket.c +++ b/icmp_socket.c @@ -153,7 +153,6 @@ static ssize_t bat_socket_write(struct file *file, const char __user *buff, { struct socket_client *socket_client = file->private_data; struct bat_priv *bat_priv = socket_client->bat_priv; - struct hard_iface *primary_if = NULL; struct sk_buff *skb; struct icmp_packet_rr *icmp_packet;
@@ -168,13 +167,6 @@ static ssize_t bat_socket_write(struct file *file, const char __user *buff, return -EINVAL; }
- primary_if = primary_if_get_selected(bat_priv); - - if (!primary_if) { - len = -EFAULT; - goto out; - } - if (len >= sizeof(struct icmp_packet_rr)) packet_len = sizeof(struct icmp_packet_rr);
@@ -240,7 +232,7 @@ static ssize_t bat_socket_write(struct file *file, const char __user *buff, goto dst_unreach;
memcpy(icmp_packet->orig, - primary_if->net_dev->dev_addr, ETH_ALEN); + bat_priv->own_orig, ETH_ALEN);
if (packet_len == sizeof(struct icmp_packet_rr)) memcpy(icmp_packet->rr, @@ -255,8 +247,6 @@ dst_unreach: free_skb: kfree_skb(skb); out: - if (primary_if) - hardif_free_ref(primary_if); if (neigh_node) neigh_node_free_ref(neigh_node); if (orig_node) diff --git a/routing.c b/routing.c index 00e5339..5ef6f75 100644 --- a/routing.c +++ b/routing.c @@ -284,7 +284,6 @@ int recv_bat_ogm_packet(struct sk_buff *skb, struct hard_iface *hard_iface) static int recv_my_icmp_packet(struct bat_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; @@ -298,10 +297,6 @@ static int recv_my_icmp_packet(struct bat_priv *bat_priv, goto out; }
- primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto out; - /* answer echo request (ping) */ /* get routing information */ orig_node = orig_hash_find(bat_priv, icmp_packet->orig); @@ -319,7 +314,7 @@ static int recv_my_icmp_packet(struct bat_priv *bat_priv, icmp_packet = (struct 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); + memcpy(icmp_packet->orig, bat_priv->own_orig, ETH_ALEN); icmp_packet->msg_type = ECHO_REPLY; icmp_packet->ttl = TTL;
@@ -327,8 +322,6 @@ static int recv_my_icmp_packet(struct bat_priv *bat_priv, ret = NET_RX_SUCCESS;
out: - if (primary_if) - hardif_free_ref(primary_if); if (router) neigh_node_free_ref(router); if (orig_node) @@ -339,7 +332,6 @@ out: static int recv_icmp_ttl_exceeded(struct bat_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; @@ -355,10 +347,6 @@ static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv, goto out; }
- primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto out; - /* get routing information */ orig_node = orig_hash_find(bat_priv, icmp_packet->orig); if (!orig_node) @@ -375,7 +363,7 @@ static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv, icmp_packet = (struct 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); + memcpy(icmp_packet->orig, bat_priv->own_orig, ETH_ALEN); icmp_packet->msg_type = TTL_EXCEEDED; icmp_packet->ttl = TTL;
@@ -383,8 +371,6 @@ static int recv_icmp_ttl_exceeded(struct bat_priv *bat_priv, ret = NET_RX_SUCCESS;
out: - if (primary_if) - hardif_free_ref(primary_if); if (router) neigh_node_free_ref(router); if (orig_node) @@ -894,7 +880,6 @@ static int check_unicast_ttvn(struct bat_priv *bat_priv, uint8_t curr_ttvn; struct orig_node *orig_node; struct ethhdr *ethhdr; - struct hard_iface *primary_if; struct unicast_packet *unicast_packet; bool tt_poss_change;
@@ -931,12 +916,8 @@ static int check_unicast_ttvn(struct bat_priv *bat_priv, if (!orig_node) { if (!is_my_client(bat_priv, ethhdr->h_dest)) return 0; - primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - return 0; memcpy(unicast_packet->dest, - primary_if->net_dev->dev_addr, ETH_ALEN); - hardif_free_ref(primary_if); + bat_priv->own_orig, ETH_ALEN); } else { memcpy(unicast_packet->dest, orig_node->orig, ETH_ALEN); diff --git a/translation-table.c b/translation-table.c index 06a51e5..486f464 100644 --- a/translation-table.c +++ b/translation-table.c @@ -1195,14 +1195,9 @@ static int send_tt_request(struct bat_priv *bat_priv, 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; int ret = 1;
- primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto out; - /* The new tt_req will be issued only if I'm not waiting for a * reply from the same orig_node yet */ tt_req_node = new_tt_req_node(bat_priv, dst_orig_node); @@ -1220,7 +1215,7 @@ static int send_tt_request(struct bat_priv *bat_priv,
tt_request->packet_type = BAT_TT_QUERY; tt_request->version = COMPAT_VERSION; - memcpy(tt_request->src, primary_if->net_dev->dev_addr, ETH_ALEN); + memcpy(tt_request->src, bat_priv->own_orig, ETH_ALEN); memcpy(tt_request->dst, dst_orig_node->orig, ETH_ALEN); tt_request->ttl = TTL; tt_request->ttvn = ttvn; @@ -1244,8 +1239,6 @@ static int send_tt_request(struct bat_priv *bat_priv, out: if (neigh_node) neigh_node_free_ref(neigh_node); - if (primary_if) - hardif_free_ref(primary_if); if (ret) kfree_skb(skb); if (ret && tt_req_node) { @@ -1745,7 +1738,6 @@ void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client, struct sk_buff *skb = NULL; struct roam_adv_packet *roam_adv_packet; int ret = 1; - struct hard_iface *primary_if;
/* before going on we have to check whether the client has * already roamed to us too many times */ @@ -1764,11 +1756,7 @@ void send_roam_adv(struct bat_priv *bat_priv, uint8_t *client, roam_adv_packet->packet_type = BAT_ROAM_ADV; roam_adv_packet->version = COMPAT_VERSION; roam_adv_packet->ttl = TTL; - primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto out; - memcpy(roam_adv_packet->src, primary_if->net_dev->dev_addr, ETH_ALEN); - hardif_free_ref(primary_if); + memcpy(roam_adv_packet->src, bat_priv->own_orig, ETH_ALEN); memcpy(roam_adv_packet->dst, orig_node->orig, ETH_ALEN); memcpy(roam_adv_packet->client, client, ETH_ALEN);
diff --git a/unicast.c b/unicast.c index 07d1c1d..733da47 100644 --- a/unicast.c +++ b/unicast.c @@ -220,7 +220,6 @@ int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, struct hard_iface *hard_iface, const uint8_t dstaddr[]) { struct unicast_packet tmp_uc, *unicast_packet; - struct hard_iface *primary_if; struct sk_buff *frag_skb; struct unicast_frag_packet *frag1, *frag2; int uc_hdr_len = sizeof(*unicast_packet); @@ -229,10 +228,6 @@ int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, int large_tail = 0, ret = NET_RX_DROP; uint16_t seqno;
- primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto dropped; - frag_skb = dev_alloc_skb(data_len - (data_len / 2) + ucf_hdr_len); if (!frag_skb) goto dropped; @@ -255,7 +250,7 @@ int frag_send_skb(struct sk_buff *skb, struct bat_priv *bat_priv, frag1->version = COMPAT_VERSION; frag1->packet_type = BAT_UNICAST_FRAG;
- memcpy(frag1->orig, primary_if->net_dev->dev_addr, ETH_ALEN); + memcpy(frag1->orig, bat_priv->own_orig, ETH_ALEN); memcpy(frag2, frag1, sizeof(*frag2));
if (data_len & 1) @@ -278,8 +273,6 @@ drop_frag: dropped: kfree_skb(skb); out: - if (primary_if) - hardif_free_ref(primary_if); return ret; }
diff --git a/vis.c b/vis.c index 7445413..e08ecd7 100644 --- a/vis.c +++ b/vis.c @@ -190,7 +190,6 @@ static ssize_t vis_data_read_entry(char *buff,
int vis_seq_print_text(struct seq_file *seq, void *offset) { - struct hard_iface *primary_if; struct hlist_node *node; struct hlist_head *head; struct vis_info *info; @@ -209,10 +208,6 @@ int vis_seq_print_text(struct seq_file *seq, void *offset) char *buff; int compare;
- primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto out; - if (vis_server == VIS_TYPE_CLIENT_UPDATE) goto out;
@@ -321,8 +316,6 @@ int vis_seq_print_text(struct seq_file *seq, void *offset) kfree(buff);
out: - if (primary_if) - hardif_free_ref(primary_if); return ret; }
@@ -810,20 +803,15 @@ out: /* only send one vis packet. called from send_vis_packets() */ static void send_vis_packet(struct bat_priv *bat_priv, struct vis_info *info) { - struct hard_iface *primary_if; struct vis_packet *packet;
- primary_if = primary_if_get_selected(bat_priv); - if (!primary_if) - goto out; - packet = (struct vis_packet *)info->skb_packet->data; if (packet->ttl < 2) { pr_debug("Error - can't send vis packet: ttl exceeded\n"); - goto out; + return; }
- memcpy(packet->sender_orig, primary_if->net_dev->dev_addr, ETH_ALEN); + memcpy(packet->sender_orig, bat_priv->own_orig, ETH_ALEN); packet->ttl--;
if (is_broadcast_ether_addr(packet->target_orig)) @@ -831,10 +819,6 @@ static void send_vis_packet(struct bat_priv *bat_priv, struct vis_info *info) else unicast_vis_packet(bat_priv, info); packet->ttl++; /* restore TTL */ - -out: - if (primary_if) - hardif_free_ref(primary_if); }
/* called from timer; send (and maybe generate) vis packet. */
On Sunday, October 30, 2011 23:51:12 Simon Wunderlich wrote:
Instead of acquiring the first interfaces originator through hard interface (including referencing/dereferencing), we can use the cached value in bat_priv->own_orig.
There might be some cases where this function was implicitly used to check whether there is a hard interface configured at all (i.e. if batman is active), therfore this is patch is an RFC.
Most of the functions do not simply retrieve the addr but also check if there is a primary interface. So, what happens if batman-adv has no primary_if ? AFAIK that can occur if all added hard-interfaces are down.
What happens with BLAII if there is no primary interface ?
Cheers, Marek
Hey Marek,
as per our IRC discussion, I'm removing this RFC patch as well as the primary_addr caching in the bla code to avoid any debugging complexity with this cache. I first introduced it to avoid code bloating to fetch/check/release the primary_if in all the little functions, but I found an easy and non-bloating way to do that. ;)
Regarding BLAII after this change, all functions hooked up somewhere (bla_rx(), bla_tx(), bla_periodic_work(), ...) will more or less return as long as there is no primary_if - it is needed to find out the own address after all.
When a new primary_if is chosen, the claim table and backbone gw table are wiped to "simulate" a reboot - with the new interface, we might have new neighbors in the mesh after all ...
The patch is already included in my blaII_dirty repo, I'll update and rebase main patch series accordingly as there were no more comments in the last couple of days.
Thanks Simon
On Tue, Nov 01, 2011 at 11:08:47AM +0100, Marek Lindner wrote:
On Sunday, October 30, 2011 23:51:12 Simon Wunderlich wrote:
Instead of acquiring the first interfaces originator through hard interface (including referencing/dereferencing), we can use the cached value in bat_priv->own_orig.
There might be some cases where this function was implicitly used to check whether there is a hard interface configured at all (i.e. if batman is active), therfore this is patch is an RFC.
Most of the functions do not simply retrieve the addr but also check if there is a primary interface. So, what happens if batman-adv has no primary_if ? AFAIK that can occur if all added hard-interfaces are down.
What happens with BLAII if there is no primary interface ?
Cheers, Marek
Hey there,
There are also some online repositories which might be interesting for your review:
http://git.open-mesh.org/?p=simon/batman-adv.git;a=shortlog;h=refs/heads/bla... here are the separate fix patches on top of the original patchset. I'll add fixes here first.
http://git.open-mesh.org/?p=simon/batman-adv.git;a=shortlog;h=refs/heads/bla... this is the patchset as sent to the mailing list. Fixes are squashed from blaII_dirty into this branch later.
http://git.open-mesh.org/?p=simon/batctl.git;a=shortlog;h=refs/heads/blaII this is the batctl patch which adds some control and debugging functions.
Cheers, Simon
On Sun, Oct 30, 2011 at 11:51:01PM +0100, Simon Wunderlich wrote:
This series of patches is a request for comments on the redesigned bridge loop avoidance. The general concept is described in the wiki [1]. I've already performed a few testcases [2] which worked fine in my kvm environment. No crashes while running or unloading the extension either.
The last patch in the series uses the cached address of the primary interface (the originator address known through the mesh) to save some code at various positions, there may be side effects I don't see however (e.g. implicit checking whether the module was configured correctly was removed).
Marek already pointed quite a few issues out, these changes are reflected in the respective commit logs. These commit comments will be removed in the final version.
Any comments and suggestions are appreciated.
Thanks Simon
[1] http://www.open-mesh.org/wiki/batman-adv/Bridge-loop-avoidance-II [2] http://www.open-mesh.org/wiki/batman-adv/Bridge-loop-avoidance-Testcases
Simon Wunderlich (11): batman-adv: remove old bridge loop avoidance code batman-adv: add basic bridge loop avoidance code batman-adv: make bridge loop avoidance switchable batman-adv: export claim tables through debugfs batman-adv: allow multiple entries in tt_global_entries batman-adv: don't let backbone gateways exchange tt entries batman-adv: add broadcast duplicate check batman-adv: drop STP over batman batman-adv: form groups in the bridge loop avoidance batman-adv: Update README and sysfs description [RFC] batman-adv: get primaries address through bat_priv->own_orig
Makefile.kbuild | 1 + README | 28 +- bat_debugfs.c | 18 +- bat_sysfs.c | 4 +- bridge_loop_avoidance.c | 1509 +++++++++++++++++++++++++++++++++++++++++++++++ bridge_loop_avoidance.h | 34 ++ compat.c | 16 +- compat.h | 3 +- hard-interface.c | 8 +- icmp_socket.c | 12 +- main.c | 9 +- main.h | 9 +- originator.c | 3 +- packet.h | 16 + routing.c | 41 +- soft-interface.c | 490 +--------------- soft-interface.h | 2 - sysfs-class-net-mesh | 9 + translation-table.c | 366 ++++++++---- types.h | 70 ++- unicast.c | 9 +- vis.c | 20 +- 22 files changed, 1965 insertions(+), 712 deletions(-) create mode 100644 bridge_loop_avoidance.c create mode 100644 bridge_loop_avoidance.h
-- 1.7.7.1
b.a.t.m.a.n@lists.open-mesh.org
-
Marek Lindner -
Simon Wunderlich