From patchwork Sun Feb 9 03:48:57 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: =?utf-8?q?Linus_L=C3=BCssing?= X-Patchwork-Id: 3796 Return-Path: Received-SPF: None (no SPF record) identity=mailfrom; client-ip=212.227.15.4; helo=mout.web.de; envelope-from=linus.luessing@web.de; receiver=b.a.t.m.a.n@lists.open-mesh.org Received: from mout.web.de (mout.web.de [212.227.15.4]) by open-mesh.org (Postfix) with ESMTPS id 738E26022D4 for ; Sun, 9 Feb 2014 04:49:11 +0100 (CET) Received: from localhost ([95.211.148.154]) by smtp.web.de (mrweb103) with ESMTPSA (Nemesis) id 0LfztP-1VRflN3wex-00pec9 for ; Sun, 09 Feb 2014 04:49:11 +0100 From: =?UTF-8?q?Linus=20L=C3=BCssing?= To: b.a.t.m.a.n@lists.open-mesh.org Date: Sun, 9 Feb 2014 04:48:57 +0100 Message-Id: <1391917738-4483-6-git-send-email-linus.luessing@web.de> X-Mailer: git-send-email 1.9.rc1 In-Reply-To: <1391917738-4483-1-git-send-email-linus.luessing@web.de> References: <1391917738-4483-1-git-send-email-linus.luessing@web.de> MIME-Version: 1.0 X-Provags-ID: V03:K0:4z5s2ZV6e9ctU+bENpdTxfx6aDTHVvfKj+CnPvzzkgZEYG2zqtx Wqn5qT4P03J2gcQr+fFvKFelBLVw/T77h8cBO5fUSKoyCOxG0BYTQYLjVkOHomt7dYVMAGr ljjcVU96/kjDItwxg0rZYcthhK+oFm4jawE/ojKvjsLc5pAYe/UaQxvR68yJCVpg609FHMB Ywfrgj9bwbCb2fMbJ720w== Subject: [B.A.T.M.A.N.] [PATCHv13 5/6] batman-adv: Add IPv4 link-local/IPv6-ll-all-nodes multicast support X-BeenThere: b.a.t.m.a.n@lists.open-mesh.org X-Mailman-Version: 2.1.15 Precedence: list Reply-To: The list for a Better Approach To Mobile Ad-hoc Networking List-Id: The list for a Better Approach To Mobile Ad-hoc Networking List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sun, 09 Feb 2014 03:49:11 -0000 With this patch a node may additionally perform the dropping or unicasting behaviour for a link-local IPv4 and link-local-all-nodes IPv6 multicast packet, too. The extra counter and BATADV_MCAST_WANT_ALL_UNSNOOPABLES flag is needed because with a future bridge snooping support integration a node with a bridge on top of its soft interface is not able to reliably detect its multicast listeners for IPv4 link-local and the IPv6 link-local-all-nodes addresses anymore (see RFC4541, section 2.1.2.2 and section 3). Even though this new flag does make "no difference" now, it'll ensure a seamless integration of multicast bridge support without needing to break compatibility later. Also note, that even with multicast bridge support it won't be possible to optimize 224.0.0.x and ff02::1 towards nodes with bridges, they will always receive these ranges. Signed-off-by: Linus Lüssing --- main.c | 6 ++ main.h | 1 + multicast.c | 172 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- packet.h | 9 +++ soft-interface.c | 1 + types.h | 12 ++++ 6 files changed, 196 insertions(+), 5 deletions(-) diff --git a/main.c b/main.c index 8f11b67..57b09fa 100644 --- a/main.c +++ b/main.c @@ -111,6 +111,9 @@ int batadv_mesh_init(struct net_device *soft_iface) spin_lock_init(&bat_priv->tt.last_changeset_lock); spin_lock_init(&bat_priv->tt.commit_lock); spin_lock_init(&bat_priv->gw.list_lock); +#ifdef CONFIG_BATMAN_ADV_MCAST + spin_lock_init(&bat_priv->mcast.want_lists_lock); +#endif spin_lock_init(&bat_priv->tvlv.container_list_lock); spin_lock_init(&bat_priv->tvlv.handler_list_lock); spin_lock_init(&bat_priv->softif_vlan_list_lock); @@ -118,6 +121,9 @@ int batadv_mesh_init(struct net_device *soft_iface) INIT_HLIST_HEAD(&bat_priv->forw_bat_list); INIT_HLIST_HEAD(&bat_priv->forw_bcast_list); INIT_HLIST_HEAD(&bat_priv->gw.list); +#ifdef CONFIG_BATMAN_ADV_MCAST + INIT_HLIST_HEAD(&bat_priv->mcast.want_all_unsnoopables_list); +#endif INIT_LIST_HEAD(&bat_priv->tt.changes_list); INIT_LIST_HEAD(&bat_priv->tt.req_list); INIT_LIST_HEAD(&bat_priv->tt.roam_list); diff --git a/main.h b/main.h index dc6b4a2..a31da5a 100644 --- a/main.h +++ b/main.h @@ -177,6 +177,7 @@ enum batadv_uev_type { #include #include /* struct sock */ #include /* ipv6 address stuff */ +#include #include #include #include diff --git a/multicast.c b/multicast.c index 66a4fe8..c0b29bc 100644 --- a/multicast.c +++ b/multicast.c @@ -272,9 +272,48 @@ out: } /** + * batadv_mcast_forw_mode_check_ipv4 - check for optimized forwarding potential + * @bat_priv: the bat priv with all the soft interface information + * @skb: the IPv4 packet to check + * @is_unsnoopable: stores whether the destination is snoopable + * + * Check whether the given IPv4 packet has the potential to + * be forwarded with a mode more optimal than classic flooding. + * + * If so then return 0. Otherwise -EINVAL is returned or -ENOMEM if we are + * out of memory. + */ +static int batadv_mcast_forw_mode_check_ipv4(struct batadv_priv *bat_priv, + struct sk_buff *skb, + bool *is_unsnoopable) +{ + struct iphdr *iphdr; + + /* We might fail due to out-of-memory -> drop it */ + if (!pskb_may_pull(skb, sizeof(struct ethhdr) + sizeof(*iphdr))) + return -ENOMEM; + + iphdr = ip_hdr(skb); + + /* TODO: Implement Multicast Router Discovery (RFC4286), + * then allow scope > link local, too + */ + if (!ipv4_is_local_multicast(iphdr->daddr)) + return -EINVAL; + + /* link-local multicast listeners behind a bridge are + * not snoopable (see RFC4541, section 2.1.2.2) + */ + *is_unsnoopable = true; + + return 0; +} + +/** * batadv_mcast_forw_mode_check_ipv6 - check for optimized forwarding potential * @bat_priv: the bat priv with all the soft interface information * @skb: the IPv6 packet to check + * @is_unsnoopable: stores whether the destination is snoopable * * Check whether the given IPv6 packet has the potential to * be forwarded with a mode more optimal than classic flooding. @@ -283,7 +322,8 @@ out: * out of memory. */ static int batadv_mcast_forw_mode_check_ipv6(struct batadv_priv *bat_priv, - struct sk_buff *skb) + struct sk_buff *skb, + bool *is_unsnoopable) { struct ipv6hdr *ip6hdr; @@ -304,7 +344,7 @@ static int batadv_mcast_forw_mode_check_ipv6(struct batadv_priv *bat_priv, * not snoopable (see RFC4541, section 3, paragraph 3) */ if (ipv6_addr_is_ll_all_nodes(&ip6hdr->daddr)) - return -EINVAL; + *is_unsnoopable = true; return 0; } @@ -313,6 +353,7 @@ static int batadv_mcast_forw_mode_check_ipv6(struct batadv_priv *bat_priv, * batadv_mcast_forw_mode_check - check for optimized forwarding potential * @bat_priv: the bat priv with all the soft interface information * @skb: the multicast frame to check + * @is_unsnoopable: stores whether the destination is snoopable * * Check whether the given multicast ethernet frame has the potential to * be forwarded with a mode more optimal than classic flooding. @@ -321,7 +362,8 @@ static int batadv_mcast_forw_mode_check_ipv6(struct batadv_priv *bat_priv, * out of memory. */ static int batadv_mcast_forw_mode_check(struct batadv_priv *bat_priv, - struct sk_buff *skb) + struct sk_buff *skb, + bool *is_unsnoopable) { struct ethhdr *ethhdr = eth_hdr(skb); @@ -332,8 +374,12 @@ static int batadv_mcast_forw_mode_check(struct batadv_priv *bat_priv, return -EINVAL; switch (ntohs(ethhdr->h_proto)) { + case ETH_P_IP: + return batadv_mcast_forw_mode_check_ipv4(bat_priv, skb, + is_unsnoopable); case ETH_P_IPV6: - return batadv_mcast_forw_mode_check_ipv6(bat_priv, skb); + return batadv_mcast_forw_mode_check_ipv6(bat_priv, skb, + is_unsnoopable); default: return -EINVAL; } @@ -370,6 +416,42 @@ out: } /** + * batadv_mcast_want_unsnoop_count - count the number of WANT_ALL_UNSNOOPABLES + * @bat_priv: the bat priv with all the soft interface information + * @orig_node: a pointer to set to a node with a WANT_ALL_UNSNOOPABLES flag + * + * Set an orig_node with a BATADV_MCAST_WANT_ALL_UNSNOOPABLES flag and + * increase its refcount if *orig_node was not set yet. Or keep it unchanged + * if none with such a flag was found. Finally return the total number of + * orig_nodes with this flag. + */ +static int +batadv_mcast_want_unsnoop_count(struct batadv_priv *bat_priv, + struct batadv_orig_node **orig_node) +{ + int ret = atomic_read(&bat_priv->mcast.num_want_all_unsnoopables); + + if (!ret || *orig_node) + goto out; + + rcu_read_lock(); + hlist_for_each_entry_rcu(*orig_node, + &bat_priv->mcast.want_all_unsnoopables_list, + mcast_want_all_unsnoopables_node) { + if (atomic_inc_not_zero(&(*orig_node)->refcount)) + goto unlock; + } + + *orig_node = NULL; + ret = 0; + +unlock: + rcu_read_unlock(); +out: + return ret; +} + +/** * batadv_mcast_forw_mode - check on how to forward a multicast packet * @bat_priv: the bat priv with all the soft interface information * @skb: The multicast packet to check @@ -384,9 +466,10 @@ batadv_mcast_forw_mode(struct batadv_priv *bat_priv, struct sk_buff *skb, struct batadv_orig_node **mcast_single_orig) { struct ethhdr *ethhdr = eth_hdr(skb); + bool is_unsnoopable = false; int ret; - ret = batadv_mcast_forw_mode_check(bat_priv, skb); + ret = batadv_mcast_forw_mode_check(bat_priv, skb, &is_unsnoopable); if (ret == -ENOMEM) return BATADV_FORW_NONE; else if (ret < 0) @@ -394,17 +477,75 @@ batadv_mcast_forw_mode(struct batadv_priv *bat_priv, struct sk_buff *skb, ret = batadv_mcast_tt_count(bat_priv, ethhdr, mcast_single_orig); + if (is_unsnoopable) + ret += batadv_mcast_want_unsnoop_count(bat_priv, + mcast_single_orig); + switch (ret) { case 0: return BATADV_FORW_NONE; case 1: return BATADV_FORW_SINGLE; default: + batadv_orig_node_free_ref(*mcast_single_orig); + *mcast_single_orig = NULL; return BATADV_FORW_ALL; } } /** + * batadv_mcast_list_add - grab a lock and add a node to a head + * @node: the node to add + * @head: the head to add the node to + * @lock: the lock to grab while adding the node to the head + */ +static void batadv_mcast_list_add(struct hlist_node *node, + struct hlist_head *head, + spinlock_t *lock) +{ + spin_lock_bh(lock); + hlist_add_head_rcu(node, head); + spin_unlock_bh(lock); +} + +/** + * batadv_mcast_list_del - grab a lock and delete a node from its list + * @node: the node to delete from its list + * @lock: the lock to grab while deleting the node from its list + */ +static void batadv_mcast_list_del(struct hlist_node *node, spinlock_t *lock) +{ + spin_lock_bh(lock); + hlist_del_rcu(node); + spin_unlock_bh(lock); +} + +/** + * batadv_mcast_list_update - update the list of a flag + * @flag: the flag we want to update the list for + * @node: a list node of an originator + * @head: the list head the node might be added to + * @lock: the lock that synchronizes list modifications + * @new_flags: the new capability bitset of a node + * @old_flags: the current, to be updated bitset of a node + * + * Update the list of the given node/head with the help of the new flag + * information of an originator to contain the nodes which have the given + * flag set. + */ +static void batadv_mcast_list_update(uint8_t flag, + struct hlist_node *node, + struct hlist_head *head, + spinlock_t *lock, + uint8_t new_flags, int old_flags) +{ + if (new_flags & flag && !(old_flags & flag)) + batadv_mcast_list_add(node, head, lock); + else if (!(new_flags & flag) && old_flags & flag) + batadv_mcast_list_del(node, lock); +} + +/** * batadv_mcast_tvlv_ogm_handler_v1 - process incoming multicast tvlv container * @bat_priv: the bat priv with all the soft interface information * @orig: the orig_node of the ogm @@ -448,6 +589,19 @@ static void batadv_mcast_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv, (tvlv_value_len >= sizeof(mcast_flags))) mcast_flags = *(uint8_t *)tvlv_value; + if (mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES && + !(orig->mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES)) + atomic_inc(&bat_priv->mcast.num_want_all_unsnoopables); + else if (!(mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) && + orig->mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) + atomic_dec(&bat_priv->mcast.num_want_all_unsnoopables); + + batadv_mcast_list_update(BATADV_MCAST_WANT_ALL_UNSNOOPABLES, + &orig->mcast_want_all_unsnoopables_node, + &bat_priv->mcast.want_all_unsnoopables_list, + &bat_priv->mcast.want_lists_lock, + mcast_flags, orig->mcast_flags); + orig->mcast_flags = mcast_flags; } @@ -484,4 +638,12 @@ void batadv_mcast_purge_orig(struct batadv_orig_node *orig) if (!(orig->capabilities & BATADV_ORIG_CAPA_HAS_MCAST)) atomic_dec(&bat_priv->mcast.num_disabled); + if (orig->mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) + atomic_dec(&bat_priv->mcast.num_want_all_unsnoopables); + + batadv_mcast_list_update(BATADV_MCAST_WANT_ALL_UNSNOOPABLES, + &orig->mcast_want_all_unsnoopables_node, + &bat_priv->mcast.want_all_unsnoopables_list, + &bat_priv->mcast.want_lists_lock, + BATADV_NO_FLAGS, orig->mcast_flags); } diff --git a/packet.h b/packet.h index e8c483d..0aada24 100644 --- a/packet.h +++ b/packet.h @@ -89,6 +89,15 @@ enum batadv_icmp_packettype { BATADV_PARAMETER_PROBLEM = 12, }; +/** + * enum batadv_mcast_flags - flags for multicast capabilities and settings + * @BATADV_MCAST_WANT_ALL_UNSNOOPABLES: we want all packets destined for + * 224.0.0.0/24 or ff02::1 + */ +enum batadv_mcast_flags { + BATADV_MCAST_WANT_ALL_UNSNOOPABLES = BIT(0), +}; + /* tt data subtypes */ #define BATADV_TT_DATA_TYPE_MASK 0x0F diff --git a/soft-interface.c b/soft-interface.c index 6b1eb75..bfbb1de 100644 --- a/soft-interface.c +++ b/soft-interface.c @@ -713,6 +713,7 @@ static int batadv_softif_init_late(struct net_device *dev) bat_priv->mcast.flags = BATADV_NO_FLAGS; atomic_set(&bat_priv->multicast_mode, 1); atomic_set(&bat_priv->mcast.num_disabled, 0); + atomic_set(&bat_priv->mcast.num_want_all_unsnoopables, 0); #endif atomic_set(&bat_priv->gw_mode, BATADV_GW_MODE_OFF); atomic_set(&bat_priv->gw_sel_class, 20); diff --git a/types.h b/types.h index c28fc4a..1a674cb 100644 --- a/types.h +++ b/types.h @@ -205,6 +205,8 @@ struct batadv_orig_bat_iv { * @last_seen: time when last packet from this node was received * @bcast_seqno_reset: time when the broadcast seqno window was reset * @mcast_flags: multicast flags announced by the orig node + * @mcast_want_all_unsnoop_node: a list node for the + * mcast.want_all_unsnoopables list * @capabilities: announced capabilities of this originator * @capa_initialized: bitfield to remember whether a capability was initialized * @last_ttvn: last seen translation table version number @@ -249,6 +251,7 @@ struct batadv_orig_node { unsigned long bcast_seqno_reset; #ifdef CONFIG_BATMAN_ADV_MCAST uint8_t mcast_flags; + struct hlist_node mcast_want_all_unsnoopables_node; #endif uint8_t capabilities; uint8_t capa_initialized; @@ -619,15 +622,24 @@ struct batadv_priv_dat { /** * struct batadv_priv_mcast - per mesh interface mcast data * @mla_list: list of multicast addresses we are currently announcing via TT + * @want_all_unsnoopables_list: a list of orig_nodes wanting all unsnoopable + * multicast traffic * @flags: the flags we have last sent in our mcast tvlv * @enabled: whether the multicast tvlv is currently enabled * @num_disabled: number of nodes that have no mcast tvlv + * @num_want_all_unsnoopables: number of nodes wanting unsnoopable IP traffic + * @want_lists_lock: lock for protecting modifications to mcast want lists + * (traversals are rcu-locked) */ struct batadv_priv_mcast { struct hlist_head mla_list; + struct hlist_head want_all_unsnoopables_list; uint8_t flags; bool enabled; atomic_t num_disabled; + atomic_t num_want_all_unsnoopables; + /* protects want_all_unsnoopables_list */ + spinlock_t want_lists_lock; }; #endif