~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/batman-adv/multicast.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* Copyright (C) 2014-2015 B.A.T.M.A.N. contributors:
  2  *
  3  * Linus L├╝ssing
  4  *
  5  * This program is free software; you can redistribute it and/or
  6  * modify it under the terms of version 2 of the GNU General Public
  7  * License as published by the Free Software Foundation.
  8  *
  9  * This program is distributed in the hope that it will be useful, but
 10  * WITHOUT ANY WARRANTY; without even the implied warranty of
 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 12  * General Public License for more details.
 13  *
 14  * You should have received a copy of the GNU General Public License
 15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
 16  */
 17 
 18 #include "multicast.h"
 19 #include "main.h"
 20 
 21 #include <linux/atomic.h>
 22 #include <linux/bitops.h>
 23 #include <linux/bug.h>
 24 #include <linux/byteorder/generic.h>
 25 #include <linux/errno.h>
 26 #include <linux/etherdevice.h>
 27 #include <linux/fs.h>
 28 #include <linux/if_ether.h>
 29 #include <linux/in6.h>
 30 #include <linux/in.h>
 31 #include <linux/ip.h>
 32 #include <linux/ipv6.h>
 33 #include <linux/list.h>
 34 #include <linux/lockdep.h>
 35 #include <linux/netdevice.h>
 36 #include <linux/rculist.h>
 37 #include <linux/rcupdate.h>
 38 #include <linux/skbuff.h>
 39 #include <linux/slab.h>
 40 #include <linux/spinlock.h>
 41 #include <linux/stddef.h>
 42 #include <linux/string.h>
 43 #include <linux/types.h>
 44 #include <net/addrconf.h>
 45 #include <net/ipv6.h>
 46 
 47 #include "packet.h"
 48 #include "translation-table.h"
 49 
 50 /**
 51  * batadv_mcast_mla_softif_get - get softif multicast listeners
 52  * @dev: the device to collect multicast addresses from
 53  * @mcast_list: a list to put found addresses into
 54  *
 55  * Collect multicast addresses of the local multicast listeners
 56  * on the given soft interface, dev, in the given mcast_list.
 57  *
 58  * Returns -ENOMEM on memory allocation error or the number of
 59  * items added to the mcast_list otherwise.
 60  */
 61 static int batadv_mcast_mla_softif_get(struct net_device *dev,
 62                                        struct hlist_head *mcast_list)
 63 {
 64         struct netdev_hw_addr *mc_list_entry;
 65         struct batadv_hw_addr *new;
 66         int ret = 0;
 67 
 68         netif_addr_lock_bh(dev);
 69         netdev_for_each_mc_addr(mc_list_entry, dev) {
 70                 new = kmalloc(sizeof(*new), GFP_ATOMIC);
 71                 if (!new) {
 72                         ret = -ENOMEM;
 73                         break;
 74                 }
 75 
 76                 ether_addr_copy(new->addr, mc_list_entry->addr);
 77                 hlist_add_head(&new->list, mcast_list);
 78                 ret++;
 79         }
 80         netif_addr_unlock_bh(dev);
 81 
 82         return ret;
 83 }
 84 
 85 /**
 86  * batadv_mcast_mla_is_duplicate - check whether an address is in a list
 87  * @mcast_addr: the multicast address to check
 88  * @mcast_list: the list with multicast addresses to search in
 89  *
 90  * Returns true if the given address is already in the given list.
 91  * Otherwise returns false.
 92  */
 93 static bool batadv_mcast_mla_is_duplicate(u8 *mcast_addr,
 94                                           struct hlist_head *mcast_list)
 95 {
 96         struct batadv_hw_addr *mcast_entry;
 97 
 98         hlist_for_each_entry(mcast_entry, mcast_list, list)
 99                 if (batadv_compare_eth(mcast_entry->addr, mcast_addr))
100                         return true;
101 
102         return false;
103 }
104 
105 /**
106  * batadv_mcast_mla_list_free - free a list of multicast addresses
107  * @bat_priv: the bat priv with all the soft interface information
108  * @mcast_list: the list to free
109  *
110  * Removes and frees all items in the given mcast_list.
111  */
112 static void batadv_mcast_mla_list_free(struct batadv_priv *bat_priv,
113                                        struct hlist_head *mcast_list)
114 {
115         struct batadv_hw_addr *mcast_entry;
116         struct hlist_node *tmp;
117 
118         lockdep_assert_held(&bat_priv->tt.commit_lock);
119 
120         hlist_for_each_entry_safe(mcast_entry, tmp, mcast_list, list) {
121                 hlist_del(&mcast_entry->list);
122                 kfree(mcast_entry);
123         }
124 }
125 
126 /**
127  * batadv_mcast_mla_tt_retract - clean up multicast listener announcements
128  * @bat_priv: the bat priv with all the soft interface information
129  * @mcast_list: a list of addresses which should _not_ be removed
130  *
131  * Retracts the announcement of any multicast listener from the
132  * translation table except the ones listed in the given mcast_list.
133  *
134  * If mcast_list is NULL then all are retracted.
135  */
136 static void batadv_mcast_mla_tt_retract(struct batadv_priv *bat_priv,
137                                         struct hlist_head *mcast_list)
138 {
139         struct batadv_hw_addr *mcast_entry;
140         struct hlist_node *tmp;
141 
142         lockdep_assert_held(&bat_priv->tt.commit_lock);
143 
144         hlist_for_each_entry_safe(mcast_entry, tmp, &bat_priv->mcast.mla_list,
145                                   list) {
146                 if (mcast_list &&
147                     batadv_mcast_mla_is_duplicate(mcast_entry->addr,
148                                                   mcast_list))
149                         continue;
150 
151                 batadv_tt_local_remove(bat_priv, mcast_entry->addr,
152                                        BATADV_NO_FLAGS,
153                                        "mcast TT outdated", false);
154 
155                 hlist_del(&mcast_entry->list);
156                 kfree(mcast_entry);
157         }
158 }
159 
160 /**
161  * batadv_mcast_mla_tt_add - add multicast listener announcements
162  * @bat_priv: the bat priv with all the soft interface information
163  * @mcast_list: a list of addresses which are going to get added
164  *
165  * Adds multicast listener announcements from the given mcast_list to the
166  * translation table if they have not been added yet.
167  */
168 static void batadv_mcast_mla_tt_add(struct batadv_priv *bat_priv,
169                                     struct hlist_head *mcast_list)
170 {
171         struct batadv_hw_addr *mcast_entry;
172         struct hlist_node *tmp;
173 
174         lockdep_assert_held(&bat_priv->tt.commit_lock);
175 
176         if (!mcast_list)
177                 return;
178 
179         hlist_for_each_entry_safe(mcast_entry, tmp, mcast_list, list) {
180                 if (batadv_mcast_mla_is_duplicate(mcast_entry->addr,
181                                                   &bat_priv->mcast.mla_list))
182                         continue;
183 
184                 if (!batadv_tt_local_add(bat_priv->soft_iface,
185                                          mcast_entry->addr, BATADV_NO_FLAGS,
186                                          BATADV_NULL_IFINDEX, BATADV_NO_MARK))
187                         continue;
188 
189                 hlist_del(&mcast_entry->list);
190                 hlist_add_head(&mcast_entry->list, &bat_priv->mcast.mla_list);
191         }
192 }
193 
194 /**
195  * batadv_mcast_has_bridge - check whether the soft-iface is bridged
196  * @bat_priv: the bat priv with all the soft interface information
197  *
198  * Checks whether there is a bridge on top of our soft interface. Returns
199  * true if so, false otherwise.
200  */
201 static bool batadv_mcast_has_bridge(struct batadv_priv *bat_priv)
202 {
203         struct net_device *upper = bat_priv->soft_iface;
204 
205         rcu_read_lock();
206         do {
207                 upper = netdev_master_upper_dev_get_rcu(upper);
208         } while (upper && !(upper->priv_flags & IFF_EBRIDGE));
209         rcu_read_unlock();
210 
211         return upper;
212 }
213 
214 /**
215  * batadv_mcast_mla_tvlv_update - update multicast tvlv
216  * @bat_priv: the bat priv with all the soft interface information
217  *
218  * Updates the own multicast tvlv with our current multicast related settings,
219  * capabilities and inabilities.
220  *
221  * Returns true if the tvlv container is registered afterwards. Otherwise
222  * returns false.
223  */
224 static bool batadv_mcast_mla_tvlv_update(struct batadv_priv *bat_priv)
225 {
226         struct batadv_tvlv_mcast_data mcast_data;
227 
228         mcast_data.flags = BATADV_NO_FLAGS;
229         memset(mcast_data.reserved, 0, sizeof(mcast_data.reserved));
230 
231         /* Avoid attaching MLAs, if there is a bridge on top of our soft
232          * interface, we don't support that yet (TODO)
233          */
234         if (batadv_mcast_has_bridge(bat_priv)) {
235                 if (bat_priv->mcast.enabled) {
236                         batadv_tvlv_container_unregister(bat_priv,
237                                                          BATADV_TVLV_MCAST, 1);
238                         bat_priv->mcast.enabled = false;
239                 }
240 
241                 return false;
242         }
243 
244         if (!bat_priv->mcast.enabled ||
245             mcast_data.flags != bat_priv->mcast.flags) {
246                 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_MCAST, 1,
247                                                &mcast_data, sizeof(mcast_data));
248                 bat_priv->mcast.flags = mcast_data.flags;
249                 bat_priv->mcast.enabled = true;
250         }
251 
252         return true;
253 }
254 
255 /**
256  * batadv_mcast_mla_update - update the own MLAs
257  * @bat_priv: the bat priv with all the soft interface information
258  *
259  * Updates the own multicast listener announcements in the translation
260  * table as well as the own, announced multicast tvlv container.
261  */
262 void batadv_mcast_mla_update(struct batadv_priv *bat_priv)
263 {
264         struct net_device *soft_iface = bat_priv->soft_iface;
265         struct hlist_head mcast_list = HLIST_HEAD_INIT;
266         int ret;
267 
268         if (!batadv_mcast_mla_tvlv_update(bat_priv))
269                 goto update;
270 
271         ret = batadv_mcast_mla_softif_get(soft_iface, &mcast_list);
272         if (ret < 0)
273                 goto out;
274 
275 update:
276         batadv_mcast_mla_tt_retract(bat_priv, &mcast_list);
277         batadv_mcast_mla_tt_add(bat_priv, &mcast_list);
278 
279 out:
280         batadv_mcast_mla_list_free(bat_priv, &mcast_list);
281 }
282 
283 /**
284  * batadv_mcast_forw_mode_check_ipv4 - check for optimized forwarding potential
285  * @bat_priv: the bat priv with all the soft interface information
286  * @skb: the IPv4 packet to check
287  * @is_unsnoopable: stores whether the destination is snoopable
288  *
289  * Checks whether the given IPv4 packet has the potential to be forwarded with a
290  * mode more optimal than classic flooding.
291  *
292  * If so then returns 0. Otherwise -EINVAL is returned or -ENOMEM in case of
293  * memory allocation failure.
294  */
295 static int batadv_mcast_forw_mode_check_ipv4(struct batadv_priv *bat_priv,
296                                              struct sk_buff *skb,
297                                              bool *is_unsnoopable)
298 {
299         struct iphdr *iphdr;
300 
301         /* We might fail due to out-of-memory -> drop it */
302         if (!pskb_may_pull(skb, sizeof(struct ethhdr) + sizeof(*iphdr)))
303                 return -ENOMEM;
304 
305         iphdr = ip_hdr(skb);
306 
307         /* TODO: Implement Multicast Router Discovery (RFC4286),
308          * then allow scope > link local, too
309          */
310         if (!ipv4_is_local_multicast(iphdr->daddr))
311                 return -EINVAL;
312 
313         /* link-local multicast listeners behind a bridge are
314          * not snoopable (see RFC4541, section 2.1.2.2)
315          */
316         *is_unsnoopable = true;
317 
318         return 0;
319 }
320 
321 /**
322  * batadv_mcast_forw_mode_check_ipv6 - check for optimized forwarding potential
323  * @bat_priv: the bat priv with all the soft interface information
324  * @skb: the IPv6 packet to check
325  * @is_unsnoopable: stores whether the destination is snoopable
326  *
327  * Checks whether the given IPv6 packet has the potential to be forwarded with a
328  * mode more optimal than classic flooding.
329  *
330  * If so then returns 0. Otherwise -EINVAL is returned or -ENOMEM if we are out
331  * of memory.
332  */
333 static int batadv_mcast_forw_mode_check_ipv6(struct batadv_priv *bat_priv,
334                                              struct sk_buff *skb,
335                                              bool *is_unsnoopable)
336 {
337         struct ipv6hdr *ip6hdr;
338 
339         /* We might fail due to out-of-memory -> drop it */
340         if (!pskb_may_pull(skb, sizeof(struct ethhdr) + sizeof(*ip6hdr)))
341                 return -ENOMEM;
342 
343         ip6hdr = ipv6_hdr(skb);
344 
345         /* TODO: Implement Multicast Router Discovery (RFC4286),
346          * then allow scope > link local, too
347          */
348         if (IPV6_ADDR_MC_SCOPE(&ip6hdr->daddr) != IPV6_ADDR_SCOPE_LINKLOCAL)
349                 return -EINVAL;
350 
351         /* link-local-all-nodes multicast listeners behind a bridge are
352          * not snoopable (see RFC4541, section 3, paragraph 3)
353          */
354         if (ipv6_addr_is_ll_all_nodes(&ip6hdr->daddr))
355                 *is_unsnoopable = true;
356 
357         return 0;
358 }
359 
360 /**
361  * batadv_mcast_forw_mode_check - check for optimized forwarding potential
362  * @bat_priv: the bat priv with all the soft interface information
363  * @skb: the multicast frame to check
364  * @is_unsnoopable: stores whether the destination is snoopable
365  *
366  * Checks whether the given multicast ethernet frame has the potential to be
367  * forwarded with a mode more optimal than classic flooding.
368  *
369  * If so then returns 0. Otherwise -EINVAL is returned or -ENOMEM if we are out
370  * of memory.
371  */
372 static int batadv_mcast_forw_mode_check(struct batadv_priv *bat_priv,
373                                         struct sk_buff *skb,
374                                         bool *is_unsnoopable)
375 {
376         struct ethhdr *ethhdr = eth_hdr(skb);
377 
378         if (!atomic_read(&bat_priv->multicast_mode))
379                 return -EINVAL;
380 
381         if (atomic_read(&bat_priv->mcast.num_disabled))
382                 return -EINVAL;
383 
384         switch (ntohs(ethhdr->h_proto)) {
385         case ETH_P_IP:
386                 return batadv_mcast_forw_mode_check_ipv4(bat_priv, skb,
387                                                          is_unsnoopable);
388         case ETH_P_IPV6:
389                 return batadv_mcast_forw_mode_check_ipv6(bat_priv, skb,
390                                                          is_unsnoopable);
391         default:
392                 return -EINVAL;
393         }
394 }
395 
396 /**
397  * batadv_mcast_want_all_ip_count - count nodes with unspecific mcast interest
398  * @bat_priv: the bat priv with all the soft interface information
399  * @ethhdr: ethernet header of a packet
400  *
401  * Returns the number of nodes which want all IPv4 multicast traffic if the
402  * given ethhdr is from an IPv4 packet or the number of nodes which want all
403  * IPv6 traffic if it matches an IPv6 packet.
404  */
405 static int batadv_mcast_forw_want_all_ip_count(struct batadv_priv *bat_priv,
406                                                struct ethhdr *ethhdr)
407 {
408         switch (ntohs(ethhdr->h_proto)) {
409         case ETH_P_IP:
410                 return atomic_read(&bat_priv->mcast.num_want_all_ipv4);
411         case ETH_P_IPV6:
412                 return atomic_read(&bat_priv->mcast.num_want_all_ipv6);
413         default:
414                 /* we shouldn't be here... */
415                 return 0;
416         }
417 }
418 
419 /**
420  * batadv_mcast_forw_tt_node_get - get a multicast tt node
421  * @bat_priv: the bat priv with all the soft interface information
422  * @ethhdr: the ether header containing the multicast destination
423  *
424  * Returns an orig_node matching the multicast address provided by ethhdr
425  * via a translation table lookup. This increases the returned nodes refcount.
426  */
427 static struct batadv_orig_node *
428 batadv_mcast_forw_tt_node_get(struct batadv_priv *bat_priv,
429                               struct ethhdr *ethhdr)
430 {
431         return batadv_transtable_search(bat_priv, ethhdr->h_source,
432                                         ethhdr->h_dest, BATADV_NO_FLAGS);
433 }
434 
435 /**
436  * batadv_mcast_want_forw_ipv4_node_get - get a node with an ipv4 flag
437  * @bat_priv: the bat priv with all the soft interface information
438  *
439  * Returns an orig_node which has the BATADV_MCAST_WANT_ALL_IPV4 flag set and
440  * increases its refcount.
441  */
442 static struct batadv_orig_node *
443 batadv_mcast_forw_ipv4_node_get(struct batadv_priv *bat_priv)
444 {
445         struct batadv_orig_node *tmp_orig_node, *orig_node = NULL;
446 
447         rcu_read_lock();
448         hlist_for_each_entry_rcu(tmp_orig_node,
449                                  &bat_priv->mcast.want_all_ipv4_list,
450                                  mcast_want_all_ipv4_node) {
451                 if (!atomic_inc_not_zero(&tmp_orig_node->refcount))
452                         continue;
453 
454                 orig_node = tmp_orig_node;
455                 break;
456         }
457         rcu_read_unlock();
458 
459         return orig_node;
460 }
461 
462 /**
463  * batadv_mcast_want_forw_ipv6_node_get - get a node with an ipv6 flag
464  * @bat_priv: the bat priv with all the soft interface information
465  *
466  * Returns an orig_node which has the BATADV_MCAST_WANT_ALL_IPV6 flag set
467  * and increases its refcount.
468  */
469 static struct batadv_orig_node *
470 batadv_mcast_forw_ipv6_node_get(struct batadv_priv *bat_priv)
471 {
472         struct batadv_orig_node *tmp_orig_node, *orig_node = NULL;
473 
474         rcu_read_lock();
475         hlist_for_each_entry_rcu(tmp_orig_node,
476                                  &bat_priv->mcast.want_all_ipv6_list,
477                                  mcast_want_all_ipv6_node) {
478                 if (!atomic_inc_not_zero(&tmp_orig_node->refcount))
479                         continue;
480 
481                 orig_node = tmp_orig_node;
482                 break;
483         }
484         rcu_read_unlock();
485 
486         return orig_node;
487 }
488 
489 /**
490  * batadv_mcast_want_forw_ip_node_get - get a node with an ipv4/ipv6 flag
491  * @bat_priv: the bat priv with all the soft interface information
492  * @ethhdr: an ethernet header to determine the protocol family from
493  *
494  * Returns an orig_node which has the BATADV_MCAST_WANT_ALL_IPV4 or
495  * BATADV_MCAST_WANT_ALL_IPV6 flag, depending on the provided ethhdr, set and
496  * increases its refcount.
497  */
498 static struct batadv_orig_node *
499 batadv_mcast_forw_ip_node_get(struct batadv_priv *bat_priv,
500                               struct ethhdr *ethhdr)
501 {
502         switch (ntohs(ethhdr->h_proto)) {
503         case ETH_P_IP:
504                 return batadv_mcast_forw_ipv4_node_get(bat_priv);
505         case ETH_P_IPV6:
506                 return batadv_mcast_forw_ipv6_node_get(bat_priv);
507         default:
508                 /* we shouldn't be here... */
509                 return NULL;
510         }
511 }
512 
513 /**
514  * batadv_mcast_want_forw_unsnoop_node_get - get a node with an unsnoopable flag
515  * @bat_priv: the bat priv with all the soft interface information
516  *
517  * Returns an orig_node which has the BATADV_MCAST_WANT_ALL_UNSNOOPABLES flag
518  * set and increases its refcount.
519  */
520 static struct batadv_orig_node *
521 batadv_mcast_forw_unsnoop_node_get(struct batadv_priv *bat_priv)
522 {
523         struct batadv_orig_node *tmp_orig_node, *orig_node = NULL;
524 
525         rcu_read_lock();
526         hlist_for_each_entry_rcu(tmp_orig_node,
527                                  &bat_priv->mcast.want_all_unsnoopables_list,
528                                  mcast_want_all_unsnoopables_node) {
529                 if (!atomic_inc_not_zero(&tmp_orig_node->refcount))
530                         continue;
531 
532                 orig_node = tmp_orig_node;
533                 break;
534         }
535         rcu_read_unlock();
536 
537         return orig_node;
538 }
539 
540 /**
541  * batadv_mcast_forw_mode - check on how to forward a multicast packet
542  * @bat_priv: the bat priv with all the soft interface information
543  * @skb: The multicast packet to check
544  * @orig: an originator to be set to forward the skb to
545  *
546  * Returns the forwarding mode as enum batadv_forw_mode and in case of
547  * BATADV_FORW_SINGLE set the orig to the single originator the skb
548  * should be forwarded to.
549  */
550 enum batadv_forw_mode
551 batadv_mcast_forw_mode(struct batadv_priv *bat_priv, struct sk_buff *skb,
552                        struct batadv_orig_node **orig)
553 {
554         int ret, tt_count, ip_count, unsnoop_count, total_count;
555         bool is_unsnoopable = false;
556         struct ethhdr *ethhdr;
557 
558         ret = batadv_mcast_forw_mode_check(bat_priv, skb, &is_unsnoopable);
559         if (ret == -ENOMEM)
560                 return BATADV_FORW_NONE;
561         else if (ret < 0)
562                 return BATADV_FORW_ALL;
563 
564         ethhdr = eth_hdr(skb);
565 
566         tt_count = batadv_tt_global_hash_count(bat_priv, ethhdr->h_dest,
567                                                BATADV_NO_FLAGS);
568         ip_count = batadv_mcast_forw_want_all_ip_count(bat_priv, ethhdr);
569         unsnoop_count = !is_unsnoopable ? 0 :
570                         atomic_read(&bat_priv->mcast.num_want_all_unsnoopables);
571 
572         total_count = tt_count + ip_count + unsnoop_count;
573 
574         switch (total_count) {
575         case 1:
576                 if (tt_count)
577                         *orig = batadv_mcast_forw_tt_node_get(bat_priv, ethhdr);
578                 else if (ip_count)
579                         *orig = batadv_mcast_forw_ip_node_get(bat_priv, ethhdr);
580                 else if (unsnoop_count)
581                         *orig = batadv_mcast_forw_unsnoop_node_get(bat_priv);
582 
583                 if (*orig)
584                         return BATADV_FORW_SINGLE;
585 
586                 /* fall through */
587         case 0:
588                 return BATADV_FORW_NONE;
589         default:
590                 return BATADV_FORW_ALL;
591         }
592 }
593 
594 /**
595  * batadv_mcast_want_unsnoop_update - update unsnoop counter and list
596  * @bat_priv: the bat priv with all the soft interface information
597  * @orig: the orig_node which multicast state might have changed of
598  * @mcast_flags: flags indicating the new multicast state
599  *
600  * If the BATADV_MCAST_WANT_ALL_UNSNOOPABLES flag of this originator,
601  * orig, has toggled then this method updates counter and list accordingly.
602  *
603  * Caller needs to hold orig->mcast_handler_lock.
604  */
605 static void batadv_mcast_want_unsnoop_update(struct batadv_priv *bat_priv,
606                                              struct batadv_orig_node *orig,
607                                              u8 mcast_flags)
608 {
609         struct hlist_node *node = &orig->mcast_want_all_unsnoopables_node;
610         struct hlist_head *head = &bat_priv->mcast.want_all_unsnoopables_list;
611 
612         lockdep_assert_held(&orig->mcast_handler_lock);
613 
614         /* switched from flag unset to set */
615         if (mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES &&
616             !(orig->mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES)) {
617                 atomic_inc(&bat_priv->mcast.num_want_all_unsnoopables);
618 
619                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
620                 /* flag checks above + mcast_handler_lock prevents this */
621                 WARN_ON(!hlist_unhashed(node));
622 
623                 hlist_add_head_rcu(node, head);
624                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
625         /* switched from flag set to unset */
626         } else if (!(mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) &&
627                    orig->mcast_flags & BATADV_MCAST_WANT_ALL_UNSNOOPABLES) {
628                 atomic_dec(&bat_priv->mcast.num_want_all_unsnoopables);
629 
630                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
631                 /* flag checks above + mcast_handler_lock prevents this */
632                 WARN_ON(hlist_unhashed(node));
633 
634                 hlist_del_init_rcu(node);
635                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
636         }
637 }
638 
639 /**
640  * batadv_mcast_want_ipv4_update - update want-all-ipv4 counter and list
641  * @bat_priv: the bat priv with all the soft interface information
642  * @orig: the orig_node which multicast state might have changed of
643  * @mcast_flags: flags indicating the new multicast state
644  *
645  * If the BATADV_MCAST_WANT_ALL_IPV4 flag of this originator, orig, has
646  * toggled then this method updates counter and list accordingly.
647  *
648  * Caller needs to hold orig->mcast_handler_lock.
649  */
650 static void batadv_mcast_want_ipv4_update(struct batadv_priv *bat_priv,
651                                           struct batadv_orig_node *orig,
652                                           u8 mcast_flags)
653 {
654         struct hlist_node *node = &orig->mcast_want_all_ipv4_node;
655         struct hlist_head *head = &bat_priv->mcast.want_all_ipv4_list;
656 
657         lockdep_assert_held(&orig->mcast_handler_lock);
658 
659         /* switched from flag unset to set */
660         if (mcast_flags & BATADV_MCAST_WANT_ALL_IPV4 &&
661             !(orig->mcast_flags & BATADV_MCAST_WANT_ALL_IPV4)) {
662                 atomic_inc(&bat_priv->mcast.num_want_all_ipv4);
663 
664                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
665                 /* flag checks above + mcast_handler_lock prevents this */
666                 WARN_ON(!hlist_unhashed(node));
667 
668                 hlist_add_head_rcu(node, head);
669                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
670         /* switched from flag set to unset */
671         } else if (!(mcast_flags & BATADV_MCAST_WANT_ALL_IPV4) &&
672                    orig->mcast_flags & BATADV_MCAST_WANT_ALL_IPV4) {
673                 atomic_dec(&bat_priv->mcast.num_want_all_ipv4);
674 
675                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
676                 /* flag checks above + mcast_handler_lock prevents this */
677                 WARN_ON(hlist_unhashed(node));
678 
679                 hlist_del_init_rcu(node);
680                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
681         }
682 }
683 
684 /**
685  * batadv_mcast_want_ipv6_update - update want-all-ipv6 counter and list
686  * @bat_priv: the bat priv with all the soft interface information
687  * @orig: the orig_node which multicast state might have changed of
688  * @mcast_flags: flags indicating the new multicast state
689  *
690  * If the BATADV_MCAST_WANT_ALL_IPV6 flag of this originator, orig, has
691  * toggled then this method updates counter and list accordingly.
692  *
693  * Caller needs to hold orig->mcast_handler_lock.
694  */
695 static void batadv_mcast_want_ipv6_update(struct batadv_priv *bat_priv,
696                                           struct batadv_orig_node *orig,
697                                           u8 mcast_flags)
698 {
699         struct hlist_node *node = &orig->mcast_want_all_ipv6_node;
700         struct hlist_head *head = &bat_priv->mcast.want_all_ipv6_list;
701 
702         lockdep_assert_held(&orig->mcast_handler_lock);
703 
704         /* switched from flag unset to set */
705         if (mcast_flags & BATADV_MCAST_WANT_ALL_IPV6 &&
706             !(orig->mcast_flags & BATADV_MCAST_WANT_ALL_IPV6)) {
707                 atomic_inc(&bat_priv->mcast.num_want_all_ipv6);
708 
709                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
710                 /* flag checks above + mcast_handler_lock prevents this */
711                 WARN_ON(!hlist_unhashed(node));
712 
713                 hlist_add_head_rcu(node, head);
714                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
715         /* switched from flag set to unset */
716         } else if (!(mcast_flags & BATADV_MCAST_WANT_ALL_IPV6) &&
717                    orig->mcast_flags & BATADV_MCAST_WANT_ALL_IPV6) {
718                 atomic_dec(&bat_priv->mcast.num_want_all_ipv6);
719 
720                 spin_lock_bh(&bat_priv->mcast.want_lists_lock);
721                 /* flag checks above + mcast_handler_lock prevents this */
722                 WARN_ON(hlist_unhashed(node));
723 
724                 hlist_del_init_rcu(node);
725                 spin_unlock_bh(&bat_priv->mcast.want_lists_lock);
726         }
727 }
728 
729 /**
730  * batadv_mcast_tvlv_ogm_handler_v1 - process incoming multicast tvlv container
731  * @bat_priv: the bat priv with all the soft interface information
732  * @orig: the orig_node of the ogm
733  * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags)
734  * @tvlv_value: tvlv buffer containing the multicast data
735  * @tvlv_value_len: tvlv buffer length
736  */
737 static void batadv_mcast_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv,
738                                              struct batadv_orig_node *orig,
739                                              u8 flags,
740                                              void *tvlv_value,
741                                              u16 tvlv_value_len)
742 {
743         bool orig_mcast_enabled = !(flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
744         u8 mcast_flags = BATADV_NO_FLAGS;
745         bool orig_initialized;
746 
747         if (orig_mcast_enabled && tvlv_value &&
748             (tvlv_value_len >= sizeof(mcast_flags)))
749                 mcast_flags = *(u8 *)tvlv_value;
750 
751         spin_lock_bh(&orig->mcast_handler_lock);
752         orig_initialized = test_bit(BATADV_ORIG_CAPA_HAS_MCAST,
753                                     &orig->capa_initialized);
754 
755         /* If mcast support is turned on decrease the disabled mcast node
756          * counter only if we had increased it for this node before. If this
757          * is a completely new orig_node no need to decrease the counter.
758          */
759         if (orig_mcast_enabled &&
760             !test_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities)) {
761                 if (orig_initialized)
762                         atomic_dec(&bat_priv->mcast.num_disabled);
763                 set_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities);
764         /* If mcast support is being switched off or if this is an initial
765          * OGM without mcast support then increase the disabled mcast
766          * node counter.
767          */
768         } else if (!orig_mcast_enabled &&
769                    (test_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities) ||
770                     !orig_initialized)) {
771                 atomic_inc(&bat_priv->mcast.num_disabled);
772                 clear_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities);
773         }
774 
775         set_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capa_initialized);
776 
777         batadv_mcast_want_unsnoop_update(bat_priv, orig, mcast_flags);
778         batadv_mcast_want_ipv4_update(bat_priv, orig, mcast_flags);
779         batadv_mcast_want_ipv6_update(bat_priv, orig, mcast_flags);
780 
781         orig->mcast_flags = mcast_flags;
782         spin_unlock_bh(&orig->mcast_handler_lock);
783 }
784 
785 /**
786  * batadv_mcast_init - initialize the multicast optimizations structures
787  * @bat_priv: the bat priv with all the soft interface information
788  */
789 void batadv_mcast_init(struct batadv_priv *bat_priv)
790 {
791         batadv_tvlv_handler_register(bat_priv, batadv_mcast_tvlv_ogm_handler_v1,
792                                      NULL, BATADV_TVLV_MCAST, 1,
793                                      BATADV_TVLV_HANDLER_OGM_CIFNOTFND);
794 }
795 
796 /**
797  * batadv_mcast_free - free the multicast optimizations structures
798  * @bat_priv: the bat priv with all the soft interface information
799  */
800 void batadv_mcast_free(struct batadv_priv *bat_priv)
801 {
802         batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_MCAST, 1);
803         batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_MCAST, 1);
804 
805         batadv_mcast_mla_tt_retract(bat_priv, NULL);
806 }
807 
808 /**
809  * batadv_mcast_purge_orig - reset originator global mcast state modifications
810  * @orig: the originator which is going to get purged
811  */
812 void batadv_mcast_purge_orig(struct batadv_orig_node *orig)
813 {
814         struct batadv_priv *bat_priv = orig->bat_priv;
815 
816         spin_lock_bh(&orig->mcast_handler_lock);
817 
818         if (!test_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capabilities) &&
819             test_bit(BATADV_ORIG_CAPA_HAS_MCAST, &orig->capa_initialized))
820                 atomic_dec(&bat_priv->mcast.num_disabled);
821 
822         batadv_mcast_want_unsnoop_update(bat_priv, orig, BATADV_NO_FLAGS);
823         batadv_mcast_want_ipv4_update(bat_priv, orig, BATADV_NO_FLAGS);
824         batadv_mcast_want_ipv6_update(bat_priv, orig, BATADV_NO_FLAGS);
825 
826         spin_unlock_bh(&orig->mcast_handler_lock);
827 }
828 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp